Visible to Intel only — GUID: rzh1521467374162
Ixiasoft
1. Intel® FPGA SDK for OpenCL™ Standard Edition Overview
2. Intel® FPGA SDK for OpenCL™ Offline Compiler Kernel Compilation Flows
3. Obtaining General Information on Software, Compiler, and Custom Platform
4. Managing an FPGA Board
5. Structuring Your OpenCL Kernel
6. Designing Your Host Application
7. Compiling Your OpenCL Kernel
8. Emulating and Debugging Your OpenCL Kernel
9. Reviewing Your Kernel's report.html File
10. Profiling Your OpenCL Kernel
11. Developing OpenCL™ Applications Using Intel® Code Builder for OpenCL™
12. Intel® FPGA SDK for OpenCL™ Standard Edition Advanced Features
A. Support Statuses of OpenCL Features
B. Document Revision History of the Intel® FPGA SDK for OpenCL™ Standard Edition Programming Guide
3.1. Displaying the Software Version (version)
3.2. Displaying the Compiler Version (-version)
3.3. Listing the Intel® FPGA SDK for OpenCL™ Standard Edition Utility Command Options (help)
3.4. Listing the Intel® FPGA SDK for OpenCL™ Offline Compiler Command Options (no argument, -help, or -h)
3.5. Listing the Available FPGA Boards in Your Custom Platform (-list-boards)
3.6. Displaying the Compilation Environment of an OpenCL Binary (env)
4.1. Installing an FPGA Board (install)
4.2. Uninstalling the FPGA Board (uninstall)
4.3. Querying the Device Name of Your FPGA Board (diagnose)
4.4. Running a Board Diagnostic Test (diagnose <device_name>)
4.5. Programming the FPGA Offline or without a Host (program <device_name>)
4.6. Programming the Flash Memory (flash <device_name>)
5.1. Guidelines for Naming the Kernel
5.2. Programming Strategies for Optimizing Data Processing Efficiency
5.3. Programming Strategies for Optimizing Pointer-to-Local Memory Size
5.4. Implementing the Intel® FPGA SDK for OpenCL™ Standard Edition Channels Extension
5.5. Implementing OpenCL Pipes
5.6. Implementing Arbitrary Precision Integers
5.7. Using Predefined Preprocessor Macros in Conditional Compilation
5.8. Declaring __constant Address Space Qualifiers
5.9. Including Structure Data Types as Arguments in OpenCL Kernels
5.10. Inferring a Register
5.11. Enabling Double Precision Floating-Point Operations
5.12. Single-Cycle Floating-Point Accumulator for Single Work-Item Kernels
5.4.1. Overview of the Intel® FPGA SDK for OpenCL™ Standard Edition Channels Extension
5.4.2. Channel Data Behavior
5.4.3. Multiple Work-Item Ordering for Channels
5.4.4. Restrictions in the Implementation of Intel® FPGA SDK for OpenCL™ Standard Edition Channels Extension
5.4.5. Enabling the Intel® FPGA SDK for OpenCL™ Standard Edition Channels for OpenCL Kernel
5.4.5.1. Declaring the Channel Handle
5.4.5.2. Implementing Blocking Channel Writes
5.4.5.3. Implementing Blocking Channel Reads
5.4.5.4. Implementing I/O Channels Using the io Channels Attribute
5.4.5.5. Emulating I/O Channels
5.4.5.6. Use Models of Intel® FPGA SDK for OpenCL™ Standard Edition Channels Implementation
5.4.5.7. Implementing Buffered Channels Using the depth Channels Attribute
5.4.5.8. Enforcing the Order of Channel Calls
5.5.5.1. Ensuring Compatibility with Other OpenCL SDKs
5.5.5.2. Declaring the Pipe Handle
5.5.5.3. Implementing Pipe Writes
5.5.5.4. Implementing Pipe Reads
5.5.5.5. Implementing Buffered Pipes Using the depth Attribute
5.5.5.6. Implementing I/O Pipes Using the io Attribute
5.5.5.7. Enforcing the Order of Pipe Calls
6.1. Host Programming Requirements
6.2. Allocating OpenCL Buffers for Manual Partitioning of Global Memory
6.3. Collecting Profile Data During Kernel Execution
6.4. Accessing Custom Platform-Specific Functions
6.5. Modifying Host Program for Structure Parameter Conversion
6.6. Managing Host Application
6.7. Allocating Shared Memory for OpenCL Kernels Targeting SoCs
6.8. Debugging Your OpenCL System That is Gradually Slowing Down
6.6.1. Displaying Example Makefile Fragments (example-makefile or makefile)
6.6.2. Compiling and Linking Your Host Application
6.6.3. Linking Your Host Application to the Khronos ICD Loader Library
6.6.4. Programming an FPGA via the Host
6.6.5. Termination of the Runtime Environment and Error Recovery
6.6.2.1. Displaying Flags for Compiling Host Application (compile-config)
6.6.2.2. Displaying Paths to OpenCL Host Runtime and MMD Libraries (ldflags)
6.6.2.3. Listing OpenCL Host Runtime and MMD Libraries (ldlibs)
6.6.2.4. Displaying Information on OpenCL Host Runtime and MMD Libraries (link-config or linkflags)
7.1. Compiling Your Kernel to Create Hardware Configuration File
7.2. Compiling Your Kernel without Building Hardware (-c)
7.3. Specifying the Location of Header Files (-I=<directory>)
7.4. Specifying the Name of an Intel® FPGA SDK for OpenCL™ Offline Compiler Output File (-o=<filename>)
7.5. Compiling a Kernel for a Specific FPGA Board (-board=<board_name>)
7.6. Resolving Hardware Generation Fitting Errors during Kernel Compilation (-high-effort)
7.7. Defining Preprocessor Macros to Specify Kernel Parameters (-D<macro_name>)
7.8. Generating Compilation Progress Report (-v)
7.9. Displaying the Estimated Resource Usage Summary On-Screen (-report)
7.10. Suppressing Warning Messages from the Intel® FPGA SDK for OpenCL™ Offline Compiler (-W)
7.11. Converting Warning Messages from the Intel® FPGA SDK for OpenCL™ Offline Compiler into Error Messages (-Werror)
7.12. Removing Debug Data from Compiler Reports and Source Code from the .aocx File (-g0)
7.13. Disabling Burst-Interleaving of Global Memory (-no-interleaving=<global_memory_type>)
7.14. Configuring Constant Memory Cache Size (-const-cache-bytes=<N>)
7.15. Relaxing the Order of Floating-Point Operations (-fp-relaxed)
7.16. Reducing Floating-Point Rounding Operations (-fpc)
8.1. Modifying Channels Kernel Code for Emulation
8.2. Compiling a Kernel for Emulation (-march=emulator)
8.3. Emulating Your OpenCL Kernel
8.4. Debugging Your OpenCL Kernel on Linux
8.5. Limitations of the Intel® FPGA SDK for OpenCL™ Standard Edition Emulator
8.6. Discrepancies in Hardware and Emulator Results
12.1.1. Understanding RTL Modules and the OpenCL Pipeline
12.1.2. Packaging an OpenCL Helper Function File for an OpenCL Library
12.1.3. Packaging an RTL Component for an OpenCL Library
12.1.4. Verifying the RTL Modules
12.1.5. Packaging Multiple Object Files into a Library File
12.1.6. Specifying an OpenCL Library when Compiling an OpenCL Kernel
12.1.7. Using an OpenCL Library that Works with Simple Functions (Example 1)
12.1.8. Using an OpenCL Library that Works with External Memory (Example 2)
12.1.9. OpenCL Library Command-Line Options
12.1.1.1. Overview: Intel FPGA SDK for OpenCL Pipeline Approach
12.1.1.2. Integration of an RTL Module into the Intel FPGA SDK for OpenCL Pipeline
12.1.1.3. Stall-Free RTL
12.1.1.4. RTL Module Interfaces
12.1.1.5. Avalon Streaming (Avalon-ST) Interface
12.1.1.6. RTL Reset and Clock Signals
12.1.1.7. XML Syntax of an RTL Module
12.1.1.8. Interaction between RTL Module and External Memory
12.1.1.9. Order of Threads Entering an RTL Module
12.1.1.10. OpenCL C Model of an RTL Module
12.1.1.11. Potential Incompatibility between RTL Modules and Partial Reconfiguration
A.1.1. OpenCL1.0 C Programming Language Implementation
A.1.2. OpenCL C Programming Language Restrictions
A.1.3. Argument Types for Built-in Geometric Functions
A.1.4. Numerical Compliance Implementation
A.1.5. Image Addressing and Filtering Implementation
A.1.6. Atomic Functions
A.1.7. Embedded Profile Implementation
Visible to Intel only — GUID: rzh1521467374162
Ixiasoft
6.7. Allocating Shared Memory for OpenCL Kernels Targeting SoCs
Intel® recommends that OpenCL™ kernels that run on Intel® SoCs access shared memory instead of the FPGA DDR memory. FPGA DDR memory is accessible to kernels with very high bandwidths. However, read and write operations from the ARM® CPU to FPGA DDR memory are very slow because they do not use direct memory access (DMA). Reserve FPGA DDR memory only for passing temporary data between kernels or within a single kernel for testing purposes.
Note:
- Mark the shared buffers between kernels as volatile to ensure that buffer modification by one kernel is visible to the other kernel.
- To access shared memory, you only need to modify the host code. Modifications to the kernel code are unnecessary.
- You cannot use the library function malloc or the operator new to allocate physically shared memory. Also, the CL_MEM_USE_HOST_PTR flag does not work with shared memory.
In DDR memory, shared memory must be physically contiguous. The FPGA cannot consume virtually contiguous memory without a scatter-gather direct memory access (SG-DMA) controller core. The malloc function and the new operator are for accessing memory that is virtually contiguous.
- CPU caching is disabled for the shared memory.
- When you use shared memory, one copy of the data is used for both the host and the kernel. When this memory is used, OpenCL memory calls are done as zero-copy transfers for buffer reads, buffer writers, maps, and unmaps.
The ARM CPU and the FPGA can access the shared memory simultaneously. You do not need to include the clEnqueueReadBuffer and clEnqueueWriteBuffer calls in your host code to make data visible to either the FPGA or the CPU.
- To allocate and access shared memory, structure your host code in a similar manner as the following example:
cl_mem src = clCreateBuffer(…, CL_MEM_ALLOC_HOST_PTR, size, …); int *src_ptr = (int*)clEnqueueMapBuffer (…, src, size, …); *src_ptr = input_value; //host writes to ptr directly clSetKernelArg (…, src); clEnqueueNDRangeKernel(…); clFinish(); printf (“Result = %d\n”, *dst_ptr); //result is available immediately clEnqueueUnmapMemObject(…, src, src_ptr, …); clReleaseMemObject(src); // actually frees physical memory
You can include the CONFIG_CMA_SIZE_MBYTES kernel configuration option to control the maximum total amount of shared memory available for allocation. In practice, the total amount of allocated shared memory is smaller than the value of CONFIG_CMA_SIZE_MBYTES.Important:- If your target board has multiple DDR memory banks, the clCreateBuffer(..., CL_MEM_READ_WRITE, ...) function allocates memory to the nonshared DDR memory banks. However, if the FPGA has access to a single DDR bank that is shared memory, then clCreateBuffer(..., CL_MEM_READ_WRITE, ...) allocates to shared memory, similar to using the CL_MEM_ALLOC_HOST_PTR flag.
- The shared memory that you request with the clCreateBuffer(..., CL_MEM_ALLOC_HOST_PTR, size, ...) function is allocated in the Linux OpenCL kernel driver, and it relies on the contiguous memory allocator (CMA) feature of the Linux kernel. For detailed information on enabling and configuring the CMA, refer to the Recompiling the Linux Kernel and the OpenCL Linux Kernel Driver section of the Intel® FPGA SDK for OpenCL™ Cyclone V SoC Development Kit Reference Platform Porting Guide.
- To transfer data from shared hard processor system (HPS) DDR to FPGA DDR efficiently, include a kernel that performs the memcpy function, as shown below.
__attribute__((num_simd_work_items(8))) mem_stream(__global uint * src, __global uint * dst) { size_t gid = get_global_id(0); dst[gid] = src[gid]; }
Attention: Allocate the src pointer in the HPS DDR as shared memory using the CL_MEM_ALLOC_HOST_PTR flag. - If the host allocates constant memory to shared HPS DDR system and then modifies it after kernel execution, the modifications might not take effect. As a result, subsequent kernel executions might use outdated data. To prevent kernel execution from using outdated constant memory, perform one of the following tasks:
- Do not modify constant memory after its initialization.
- Create multiple constant memory buffers if you require multiple __constant data sets.
- If available, allocate constant memory to the FPGA DDR on your accelerator board.
Related Information