A newer version of this document is available. Customers should click here to go to the newest version.
                                                
                                                
                                                    
                                                    
                                                        Why is FPGA Compilation Different?
                                                    
                                                    
                                                
                                                    
                                                    
                                                        Types of SYCL* FPGA Compilation
                                                    
                                                    
                                                
                                                    
                                                    
                                                        FPGA Compilation Flags
                                                    
                                                    
                                                
                                                    
                                                        Emulate and Debug Your Design
                                                    
                                                    
                                                    
                                                
                                                    
                                                        Evaluate Your Kernel Through Simulation
                                                    
                                                    
                                                    
                                                
                                                    
                                                    
                                                        Device Selectors for FPGA
                                                    
                                                    
                                                
                                                    
                                                        FPGA IP Authoring Flow
                                                    
                                                    
                                                    
                                                
                                                    
                                                    
                                                        Fast Recompile for FPGA
                                                    
                                                    
                                                
                                                    
                                                    
                                                        Generate Multiple FPGA Images (Linux only)
                                                    
                                                    
                                                
                                                    
                                                        FPGA BSPs and Boards
                                                    
                                                    
                                                    
                                                
                                                    
                                                    
                                                        Targeting Multiple Homogeneous FPGA Devices
                                                    
                                                    
                                                
                                                    
                                                    
                                                        Targeting Multiple Platforms
                                                    
                                                    
                                                
                                                    
                                                    
                                                        FPGA-CPU Interaction
                                                    
                                                    
                                                
                                                    
                                                    
                                                        FPGA Performance Optimization
                                                    
                                                    
                                                
                                                    
                                                        Use of RTL Libraries for FPGA
                                                    
                                                    
                                                    
                                                
                                                    
                                                    
                                                        Use SYCL Shared Library With Third-Party Applications
                                                    
                                                    
                                                
                                                    
                                                    
                                                        FPGA Workflows in IDEs
                                                    
                                                    
                                                
                                            
                                        
                                                            
                                                            
                                                                
                                                                
                                                                    Emulator Environment Variables
                                                                
                                                                
                                                            
                                                                
                                                                
                                                                    Emulate Pipe Depth
                                                                
                                                                
                                                            
                                                                
                                                                
                                                                    Emulate Applications with a Pipe That Reads or Writes to an I/O Pipe
                                                                
                                                                
                                                                    
                                                                        For Input I/O Pipes
                                                                    
                                                                        For Output I/O Pipes
                                                                    
                                                                
                                                            
                                                                
                                                                
                                                                    Compile and Emulate Your Design
                                                                
                                                                
                                                            
                                                                
                                                                
                                                                    Limitations of the Emulator
                                                                
                                                                
                                                            
                                                                
                                                                
                                                                    Troubleshooting Discrepancies in Hardware and Emulator Results
                                                                
                                                                
                                                            
                                                                
                                                                
                                                                    Emulator Known Issues
                                                                
                                                                
                                                            
                                                        
                                                    
                                    
                                    
                                        
                                            Intel oneAPI DPC++ Library (oneDPL)
                                        
                                        
                                        
                                    
                                        
                                            Intel oneAPI Math Kernel Library (oneMKL)
                                        
                                        
                                        
                                    
                                        
                                            Intel oneAPI Threading Building Blocks (oneTBB)
                                        
                                        
                                        
                                    
                                        
                                            Intel oneAPI Data Analytics Library (oneDAL)
                                        
                                        
                                        
                                    
                                        
                                            Intel oneAPI Collective Communications Library (oneCCL)
                                        
                                        
                                        
                                    
                                        
                                            Intel oneAPI Deep Neural Network Library (oneDNN)
                                        
                                        
                                        
                                    
                                        
                                            Intel oneAPI Video Processing Library (oneVPL)
                                        
                                        
                                        
                                    
                                        
                                        
                                            Other Libraries
                                        
                                        
                                    
                                
                            Emulate Applications with a Pipe That Reads or Writes to an I/O Pipe
The Intel® FPGA Emulation Platform for OpenCL™ software emulates kernel-to-kernel pipes. However, it does not support interacting directly with the hardware I/O pipes on your target board. Nevertheless, you can emulate the behavior of I/O pipes using the following procedures:
For Input I/O Pipes
- Store input data to be transferred to the pipe in a file with a name matching the id specialization of the pipe. Consider the following example: - // Specialize a pipe type struct read_io_pipe { static constexpr unsigned id = 0; }; using read_iopipe = sycl::ext::intel::kernel_readable_io_pipe<read_io_pipe, unsigned, 4>;
- Create a file named 0. 
- Store the test input data in the file 0. 
For Output I/O Pipes
Output data is automatically written to a file with a name matching the id specialization of the output pipe.