FPGA Optimization Guide for Intel® oneAPI Toolkits

Developer Guide

Contents

Data Types and Operations

Data Type Selection Considerations

Select the appropriate data type to optimize the FPGA area use by your SYCL* application:
  • Select the most appropriate data type for your application. For example, do not define your variable as 
    float
     if the data type 
    short
     is sufficient.
  • Ensure that both sides of an arithmetic expression belong to the same data type. Consider an example where one side of an arithmetic expression is a floating-point value and the other side is an integer. The mismatched data types cause the 
    Intel® oneAPI
    DPC++/C++
     Compiler
     to create implicit conversion operators, which can become expensive if they are present in large numbers.
  • Take advantage of padding if it exists in your data structures. For example, if you only need 
    float3
     data type, which has the same size as 
    float4
    , you may change the data type to 
    float4
     to make use of the extra dimension to carry an unrelated value.

Arithmetic Operation Considerations

Select the appropriate arithmetic operation for your SYCL application to avoid excessive FPGA area use.
  • Introduce floating-point arithmetic operations only when necessary.
  • The 
    Intel® oneAPI
    DPC++/C++
     Compiler
     defaults floating-point constants to double data type. Add an 
    f
     designation to the constant to make it a single precision floating-point operation. For example, the arithmetic operation 
    sin(1.0)
     represents a double precision floating-point sine function. The arithmetic operation 
    sin(1.0f)
     represents a single precision floating-point sine function.
  • If you do not require full precision result for a complex function, compute simpler arithmetic operations to approximate the result. Consider the following example scenarios:
    • Instead of computing the function 
      pow(x,n)
       where 
      n
       is a small value, approximate the result by performing repeated squaring operations because they require much less hardware resources and area.
    • Ensure you are aware of the original and approximated area uses because in some cases, computing a result via approximation might result in excess area use. For example, the 
      sqrt
       function is not resource-intensive. Other than a rough approximation, replacing the 
      sqrt
       function with arithmetic operations that the host must compute at runtime might result in larger area use.
    • If your kernel performs a complex arithmetic operation with a constant that the
      Intel® oneAPI
      DPC++/C++
       Compiler
       computes at compilation time (for example, 
      log(PI/2.0)
      ), perform the arithmetic operation on the host instead and pass the result as an argument to the kernel at runtime.
Currently, SYCL implementation of math functions is not supported on FPGAs.

Product and Performance Information

1

Performance varies by use, configuration and other factors. Learn more at www.Intel.com/PerformanceIndex.