Intel® Embree Documentation

To enable GPU support via SYCL, you must use either the open source "oneAPI DPC++ Compiler" or the "Intel(R) oneAPI DPC++/C++ Compiler". Other SYCL compilers are not supported.

Using oneAPI DPC++ Compiler (unpacked):

1. Set environment variables to point to your unpacked compiler:

   export SYCL_BUNDLE_ROOT=path_to_dpcpp_compiler
   export PATH=$SYCL_BUNDLE_ROOT/bin:$PATH
   export CPATH=$SYCL_BUNDLE_ROOT/include:$CPATH
   export LIBRARY_PATH=$SYCL_BUNDLE_ROOT/lib:$LIBRARY_PATH
   export LD_LIBRARY_PATH=$SYCL_BUNDLE_ROOT/lib:$LD_LIBRARY_PATH
   export LD_LIBRARY_PATH=$SYCL_BUNDLE_ROOT/linux/lib/x64:$LD_LIBRARY_PATH

2. Configure and build:

   cmake -B build -DCMAKE_CXX_COMPILER=clang++ -DCMAKE_C_COMPILER=clang -DEMBREE_SYCL_SUPPORT=ON
   cmake --build build -j 8

Using Intel(R) oneAPI DPC++/C++ Compiler (installed):

1. Source the environment script:

   source /opt/intel/oneAPI/compiler/latest/env/vars.sh

2. Configure and build:

   cmake -B build -DCMAKE_CXX_COMPILER=icpx -DCMAKE_C_COMPILER=icx -DEMBREE_SYCL_SUPPORT=ON
   cmake --build build -j 8

Note: To run SYCL code on Intel Xe HPG/HPC GPUs, install the latest GPGPU drivers and the intel-level-zero-gpu-raytracing package via apt.

# Example for oneAPI DPC++ Compiler
cmake -B build \
      -DCMAKE_CXX_COMPILER=clang++ \
      -DCMAKE_C_COMPILER=clang \
      -DEMBREE_SYCL_SUPPORT=ON

cmake --build build -j 8

To compile Embree on Windows, use Visual Studio (2017, 2019, or 2022) and CMake 3.1 or higher.

Key Requirements:

• TBB: Embree uses TBB as its tasking system. You can use the TBB version provided with the Intel® Compiler or install it manually and place it in a tbb folder in the Embree root. Ensure tbb.dll and tbb_malloc.dll are in your PATH.
• ISPC (Optional): If using Intel® ISPC, ensure it is compatible with your Visual Studio version and add it to your PATH or set EMBREE_ISPC_EXECUTABLE.

Building via Command Line: Use the Visual Studio command prompt to build:

cd path\to\embree
mkdir build
cd build
cmake -G "Visual Studio 16 2019" ..
cmake --build . --config Release

Building via IDE (cmake-gui):

1. Run cmake-gui and point to the Embree source and build directories.
2. Click Configure and select your Generator (e.g., "Visual Studio 12 2013 Win64").
3. To use Clang instead of MSVC, set the "Optional toolset to use (-T parameter)" to LLVM_v142.
4. Click Generate and open embree4.sln in Visual Studio.

When using Embree with SYCL, follow these best practices for performance:

• Low Code Complexity: Split your renderer into separate kernels instead of using a single "Uber kernel" to avoid spill code generation. Use SYCL specialization constants to enable only required features.
• Feature Flags: Use SYCL specialization constants and feature flags in rtcIntersect1 and rtcOccluded1 to JIT compile minimal code. Use JIT caching if compilation times are an issue.
• Inline Indirect Calls: Do not attach user geometry or intersection filter callbacks to geometries. Instead, pass the callback function directly through the RTCIntersectArguments (or RTCOccludedArguments) struct to rtcIntersect1 (or rtcOccluded1). This allows the SYCL compiler to inline the call. Do not read the function pointer from memory before passing it.
• 7-Bit Ray Mask: Use only the lower 7 bits of the ray and geometry mask whenever possible. While Embree supports 32-bit masks, hardware acceleration is optimized for 8-bit masks. Using bits 7-31 requires software intervention and reduces performance. To use 32-bit masks, enable RTC_FEATURE_FLAG_32_BIT_RAY_MASK.
• Motion Blur: For SYCL, keep primitive motion relatively small. If geometry moves fast, place the geometry into an instance and apply motion blur to the instance itself.

// Example of passing an intersection filter directly for SYCL inlining
RTC_SYCL_INDIRECTLY_CALLABLE void intersectionFilter(
  const RTCFilterFunctionNArguments* args
) { /* ... */ }

RTCIntersectArguments args;
rtcInitIntersectArguments(&args);
args.filter = intersectionFilter;

rtcIntersect1(scene, &ray, &args);