Intel® oneAPI DPC++/C++ Compiler Release Notes

This document summarizes new and changed product features and includes notes about features and problems not described in the product documentation.

Where to Find the Release

Please follow the steps to download the Intel® oneAPI toolkit from the Intel® oneAPI Base Toolkit Download page and follow the installation instructions to install.

Compiler Patch Release 2025.0.1

This patch release consists of the following new features, improvements and bug fixes:

• Added functionality to compress device images during compilation and decompress them at runtime as needed.
• The Unified Runtime Level Zero Adapter enabled the usage of Level Zero System Management functionality by default.
• Created the launch API to SYCL Compat API library.
• ABI neutral version of modifiable_command_graph::print_graph has been enabled under preview option and will be enabled by default in the next major release.
• Fixed "-ipp" / "-qipp" switch linkage error.
• Added the following missing option values in IDE for -x, -ax, /arch, /Qx, /Qax flags:

  • [-x|-ax][SIERRAFOREST|GRANDRIDGE|GRANITERAPIDS|EMERALDRAPIDS|GRANITERAPIDS-D|ARROWLAKE|ARROWLAKE-S|LUNARLAKE|PANTHERLAKE|CLEARWATERFOREST] // Linux
    [/arch:|/Qx|/Qax][SIERRAFOREST|GRANDRIDGE|GRANITERAPIDS|EMERALDRAPIDS|GRANITERAPIDS-D|ARROWLAKE|ARROWLAKE-S|LUNARLAKE|PANTHERLAKE|CLEARWATERFOREST] // Windows

• Other small usability improvements

oneAPI 2025.0, Compiler Release 2025.0

Major Enhancements and New Features

New Features:

• Hardware Enablement: Optimized for new Intel hardware including EMR, GNR, BMG, and LNL, with features such as cache hints and new data types for AI applications, delivering improved efficiency and computing power.
• Bindless Textures Support: Implemented Bindless Textures for Intel GPUs (DG2, Arc), allowing dynamic texture usage at runtime without compile-time knowledge, enabling enhanced performance and scalability.

Performance Tuning and Enhancements:

• AI and HPC Optimization: Tuned performance for AI frameworks and HPC applications.
• OpenMP Enhancements: Early support for OpenMP 6.0 features, including the DEVICE_TYPE clause for TARGET construct and mandatory offloading support. Also, fixed the OpenMP loop rotation issue. Checkout Advanced OpenMP* Device Offload with Intel® Compilers for more details. 
• Compiler Reports: Enhanced opt-report for better user experience, now providing detailed information on OpenMP offloading and integrating with the open-source optimization remark framework. Details on recent enhancements can be found at Develop Highly Optimized Applications Faster with Compiler Optimization Reports
• Sanitizers for Device Code: Device code now supports LLVM sanitizers to help detect and resolve issues during development. It includes a compiler instrumentation module and runtime support, allowing it to detect issues such as out-of-bounds memory access on USM, SYCL buffers, local memory, and device globals, as well as bad-free, use-after-free, bad context, and more. In this release, PVC GPUs and CPUs are supported on Linux OS. More details on how and when to use sanitizers can be found at Find Bugs Quickly Using Sanitizers with the Intel® oneAPI DPC++/C++ Compiler.
• Comprehensive Performance Insights: Upgraded optimization reports now cover SYCL, OpenMP, and AOT compilation, offering developers deeper insights into application performance.
• Hardware Profile Guided Optimization (HWPGO): Key improvements include enhanced profile propagation for better accuracy, additional profile-driven optimizations to further boost performance, and early support for "pseudo probes" on Windows as an alternative to DWARF for profiling. Additionally, HWPGO has introduced selective function outlining, allowing for specific functions to be optimized based on profiling data, further enhancing runtime efficiency.​

New Features

SYCL Compiler:

• SYCL Offload Model: Introduced a new SYCL offload driver mechanism with --offload-new-driver to improve infrastructure for better link times by reducing I/O and external processes.
• Range Rounding Control: Added -fsycl-range-rounding option for managing range rounding, including forcing full rounding to reduce binary size. Additionally, the experimental -fsycl-exp-range-rounding option performs rounding across all dimensions.
• Double Type Emulation: Added -fsycl-fp64-conv-emu option for partial emulation of double data types on Intel GPUs.
• Dynamic Linking: Initial support added for dynamic linking, though some features like kernel_bundle API and AOT mode are not yet supported.

SYCL Library:

• Extensions: Implemented multiple extensions, including sycl_ext_oneapi_prod, sycl_ext_oneapi_profiling_tag, sycl_ext_oneapi_forward_progress, sycl_ext_oneapi_private_alloca, syclext_codeplay_enqueue_native_command, and sycl_ext_oneapi_enqueue_functions.
• Group Load/Store: Added support for sycl_ext_oneapi_group_load_store, enabling native hardware block read/write capabilities where applicable.
• Free Function Kernels: Initial support for sycl_ext_oneapi_free_function_kernels extension, with known limitations around argument types and diagnostics.
• Fused Multiply-Add (FMA): Added experimental ESIMD function fma which results in a guaranteed fused multiply-add operation performed.
• Improvedsycl_ext_oneapi_group_sortextension: Updated implementation of sycl_ext_oneapi_group_sort extension to match revision 2 of the specification. Previous version 1 is not available anymore and some code changes may be required.

Improvements

SYCL Compiler

• Improved Compilation Flow: The process of generating integration footers has been optimized when no third-party host compiler is used, resulting in fewer temporary files and faster compilation times.

• Additional Math Function Support: New support for math functions like truncf, sinpif, rsqrtf, exp10f, ceilf, copysignf, cospif, fmaxf, and fminf in SYCL kernels has been added as part of the C-CXX-StandardLibrary extension. More Intel Math Functions (IMF), ::rand and ::srand in device code on Intel devices, have also been integrated.

• Enhanced Error Messaging: Error messages have been improved for scenarios involving implicit this capture in kernels and missing architecture information when multiple targets are passed into the -fsycl-targets flag.

• Optimized Compilation Flow: The number of commands needed for generating dependencies using the -MD flag has been reduced, streamlining the build process.

• Security and Debugging: Security-related compilation flags for libraries and tools have been strengthened, and the debugging experience has been improved for both Linux and Windows environments.

SYCL Library

• Support for ESIMD functions: Added support for sqrt and rsqrt functions for double data types in ESIMD.
• Cubemap and Sampled Image Arrays Support: Updated sycl_ext_oneapi_bindless_images extension to support cubemap images and sampled image arrays.
• Named Barrier Allocation in ESIMD: Introduced ESIMD API for dynamic allocation of named barriers.
• Executable Command Graph Update: Added support for whole graph updates using executable_command_graph::update.
• Deprecation Warning: A warning has been added for the use of the deprecated <CL/sycl.hpp> header.
• Accessor Improvements: local_accessor::get_pointer and local_accessor::get_multi_ptr now throw an invalid exception if called on the host.
• Queue Operations Detection: Extended detection of nested queue operations to support shortcut methods.
• Simplified ESIMD API Interface: Added overloads of various ESIMD APIs (e.g., atomic_update, block_load, block_store) allowing omission of some template arguments.
• Bfloat16 Math Functions: Updated sycl_ext_oneapi_bfloat16_math_functions to support vectors of bfloat16 passed to math functions.
• Optimized sycl::vec::as: Improved the performance of sycl::vec::as by optimizing the implementation of sycl::detail::memcpy.
• SYCL 2020 Exception Updates: Updated the implementation to throw SYCL 2020 exceptions instead of legacy SYCL 1.2.1 exceptions across the board.
• sycl::vec::convert Support: Added support for sycl::vec::convert to and from vec<bfloat16, N>.
• Deprecations: marray<bool, n>::operator++/-- and accessor::get_multi_ptr for non-device accessors have been deprecated.
• ESIMD Named Barriers: Moved ESIMD named barrier APIs out of the experimental namespace.
• SYCL Extensions and API Enhancements:
  • Implemented the latest revision of sycl_ext_oneapi_free_function_queries.
  • Extended sycl-ls --verbose to print detailed device information, including UUIDs and architecture.
  • Introduced support for compile-time properties in copy_to and copy_from ESIMD APIs.
• Non-Variadic printf Interface: Switched experimental::printf to a non-variadic interface to improve usability when printing float values.
• Enhanced ESIMD API Validation: Improved validation for rdregion and wrregion APIs using static assertions on template arguments.
• SYCL 2020 Specification Alignment: Updated mutating swizzle operators and scalar conversions for vec to align with the SYCL 2020 specification.
• Miscellaneous ESIMD Improvements:
  • Added support for 1- and 2-byte data types to ESIMD prefetch APIs.
  • Enabled ext_intel_matrix support for Intel GNR devices.
  • Introduced new overloads of load_2d, store_2d, and prefetch_2d ESIMD APIs with compile-time properties.
  • Added support for group shift algorithms (e.g., shift_group_left, permute_group_by_xor) for non-uniform groups.
  • Lifted restrictions on the ESIMD block_store API and enhanced the slm_atomic_update API to support fsub and fadd.
• Graph and Semaphore Support:
  • Added support for graph update functionality and external semaphore wait/signal operations with values in the bindless images extension.
  • Introduced device-to-device copying of image_device_handle.
• Unified Runtime: Removed the Plugin Interface, replacing it with the Unified Runtime, which reduces the number and size of redistributable libraries.
• Performance Improvements: Reduced startup overhead of libsycl.so by outlining the SYCL JIT compiler into a standalone library, dynamically loaded on first use.

Bug Fix

SYCL Compiler

• Fixed a bug where using the -fsycl-link-targets flag would inadvertently trigger additional device code linking steps.
• Resolved an issue where AOT-compiling for Intel GPUs would pass PVC-specific flags even if the target device was not a PVC.
• Fixed a bug with incorrect file extensions being emitted in AOT compilation when using --save-temps.
• Fixed an issue where performing separate compilation and linking with -fsycl-link resulted in a "number of output files and targets should match in unbundling mode" error during the link step.
• Resolved an issue where passing pointers in the generic address space to certain built-in math functions could cause compilation failure.
• Fixed a bug where compiling kernels with different reqd_work_group_size attributes using -fsycl-device-code-split=none could result in a runtime exception about mismatching work-group sizes.
• Resolved a bug where using the reqd_work_group_size attribute with fewer than three arguments caused a crash.
• Addressed issues with shift_group_[right|left], permute_by_xor, and select_from_group algorithms returning invalid values when used with the half data type.

SYCL Library

• Fixed a situation where querying sycl::ext::oneapi::experimental::info::device could result in an exception instead of returning an empty vector.
• Corrected the esimd::atan implementation under the -ffast-math flag.
• Fixed an issue where component devices were not correctly identified as descendants of composite devices when creating a queue.
• Addressed an issue where querying for composite devices could return duplicate entries.
• Fixed bugs in the copy-constructor of the config_2d_mem_access ESIMD class, which led to compilation errors.
• Resolved an issue where the use of atomic_ref<T*> was not detected as using the atomic64 aspect, leading to errors.
• Fixed bugs with ctanh and cexp returning incorrect values in edge cases.
• Fixed an issue where values passed to the -Xs option via build_options were not passed down to the device compiler.
• Fixed a compilation error when defining kernels as named functors while using -fno-sycl-unnamed-lambda.
• Corrected compilation issues with the -fpreview-breaking-changes flag caused by conflicts with macros in windows.h.
• Resolved strict aliasing violations in the implementation of sycl::vec<sycl::half, N>::operator[] that caused errors.
• Fixed bugs where barriers submitted to a command queue with host tasks ignored them, and improved synchronization of host tasks with barriers.
• Fixed issues where the compiler could emit unsupported SPIR-V instructions for bit-reversal.
• Addressed a bug where default-constructed local_accessor arguments could cause runtime errors, especially on Windows and under -O0 optimization on Linux.
• Resolved a hang when invalid values were passed to the ONEAPI_DEVICE_SELECTOR.
• Fixed issues with persistent cache functionality where certain setups would prevent necessary directories from being created.
• Corrected a bug where querying a kernel by name from a kernel bundle could crash the program.
• Fixed an error handling bug where non-blocking pipe operations would mistakenly throw exceptions.
• Addressed compilation issues when using non-uniform group built-ins with marray and vec.
• Resolved a bug where memory attributes applied to a struct used as a type of a device_global variable were ignored.
• Added missing value_type and vector_t member type aliases to swizzles.
• Fixed shutdown sequence issues when SYCL RT was used in applications or libraries with custom shutdown processes.
• Resolved a crash when calling event::get_backend() on a default-constructed event in environments with malformed ONEAPI_DEVICE_SELECTOR.
• Fixed a bug where sycl-ls with --ignore-device-selectors would not properly ignore the environment variable.
• Corrected memory order capabilities returned by the Native CPU backend.
• Fixed the variadic constructor of sycl::ext::oneapi::experimental::properties to match the extension specification.
• Fixed build program failures when using ESIMD functions like load_2d, store_2d, or prefetch_2d.
• Resolved a bug where querying free device memory on integrated Intel GPUs returned 0 instead of throwing an exception for unsupported features.
• Addressed a heap buffer overflow in the sycl_ext_oneapi_kernel_compiler_opencl extension implementation.
• Corrected a bug where the sycl_ext_oneapi_graph extension ignored the access mode of accessors, creating unnecessary graph edges.
• Fixed issues where graph submissions involving barriers could result in runtime errors or cause resource leaks.
• Addressed performance regressions when kernels without dependencies were submitted to in-order queues.
• Fixed profiling issues in Level Zero backend where timestamps could be zeros or incorrect for in-order queues.
• Resolved crashes when using multiple queues with immediate command list properties--immediate_command_list and no_immediate_command_list..
• Fixed a bug where info::kernel_device_specific::work_group_size would return the device-specific limit, ignoring the kernel on the Level Zero backend.

Misc

SYCL Compiler

• Reverted changes previously made on Windows to support a separate compilation scenario where the compilation step was performed without the -fsycl flag, but the link step included the -fsycl flag. This scenario is now considered unsupported, as the compiler does not know which version of the standard library to link during the link step.

API/ABI Breaking Changes in 2025.0

This release is an ABI-breaking release, meaning that any applications built with older versions of the toolchain must be recompiled to run with newer versions of the SYCL runtime library.

• Bumped the major version of the SYCL runtime library to 8.
• Cleaned up the list of symbols exported from the SYCL runtime library by dropping some legacy symbols and hiding others that should not have been exported.
• Updated the ABI of several functions and methods to avoid using std::string and other objects in the library interface, allowing SYCL RT to be used in applications built with pre-C++11 ABI.
• Changed the ext_oneapi_copy API from the experimental sycl_ext_oneapi_bindless_images extension to accept const-qualified types for the Src parameter.

Several API breaking changes were made, including dropping support for previously deprecated APIs and switching implementations of some classes to a preview implementation.

• Removed the sycl::abs overload taking a floating-point argument.
• Removed sycl::host_ptr and sycl::device_ptr.
• Removed queue::discard_or_return.
• Removed sycl::make_unique_ptr.
• Removed the use_primary_context property and methods related to the previously removed host device.
• Removed SYCL 1.2.1 exception subclasses, including runtime_error, nd_range_error, invalid_parameter_error, device_error, and feature_not_supported.
• Removed queue::mem_advice overload accepting pi_mem_advice.
• Removed several deprecated ESIMD APIs.
• Removed the non-standard sycl::id -> sycl::range conversion operator.
• Removed deprecated APIs from the sycl_ext_oneapi_bindless_images extension implementation.
• Renamed the experimental destroy_external_semaphore API from the sycl_ext_oneapi_bindless_images extension to release_external_semaphore.
• Replaced the image_channel_order field of the image_descriptor struct with the number of channels in the experimental sycl_ext_oneapi_bindless_images extension.
• Enforced restrictions on the first argument of lambdas/functors passed to parallel_for(range) and parallel_for(nd_range).
• Switched the sycl::vec implementation to its preview version, which uses a different storage type to fix several strict aliasing rule violations.
• Restricted math operations available to vec<std::byte, N> to those applicable to std::byte.
• Switched the sycl::exception implementation to its preview version.
• Switched math built-ins implementation to use their preview version.
• Switched bfloat16 implementation to use its preview version.
• Switched sycl::nd_item implementation to use its preview version.
• Enforced a restriction that a buffer's element type must be device copyable.
• Restructured SYCL headers to exclude <cmath> and <complex>.
• Dropped support for the SYCL_DEVICE_FILTER environment variable.
• Updated the accessor::get_pointer interface to return global_ptr<value_type>, which can be const-qualified if the accessor data type is const-qualified or if the accessor is read-only.
• Removed deprecated APIs related to sycl_ext_oneapi_free_function_queries.
• Moved slm_allocator ESIMD APIs into the experimental namespace.
• Removed the deprecated usm_system_allocator aspect.
• Removed get_child_group API from the experimental sycl_ext_oneapi_root_group extension.
• Simplified template arguments related to simd_view of many ESIMD APIs.
• Removed ESIMD atomic_op::predec.
• Dropped interfaces from revision 1 of the experimental sycl_ext_oneapi_group_sort extension.
• Changed the return type of command_graph::begin_recording and command_graph::end_recording from void to bool in the experimental sycl_ext_oneapi_graph extension.

Breaking changes were also made to compiler flags:

• Removed the deprecated -fsycl-link-huge-device-code, -fsycl-[add|link]-targets , -foffload-static-lib , -foffload-whole-static-lib , -fsycl-disable-range-rounding , -sycl-std flags.

 SYCL Known Issues

• On Windows, the Unified Runtime's Level Zero leak check does not work correctly with the default contexts. This is due to the release of the plugin DLLs racing against the release of static global variables, such as the default context.
• The Intel Graphic Compiler's Vector Compute backend does not support certain optimization levels and often produces incorrect results or crashes. This issue directly affects ESIMD code. As a temporary workaround, optimize ESIMD code even in the affected mode.
• When using the sycl_ext_oneapi_matrix extension, it is important for some devices to use the appropriate settings corresponding to the device that will run the program, particularly for matrix operations using half data type.
• When using queue shortcut functions with in-order queues, dependencies between commands submitted to different queues may be ignored. A workaround is to explicitly call .wait(). This issue will be fixed in the next release. In below example, the seocnd kernel will start execution before the first completes its execution. 

// q1 long running task
sycl::event e = q1.single_task([=](){ /* ... */ });
// q2 task
q2.single_task(e, [=](){ /* ... */ });

• C/C++ math built-ins can return incorrect results for some edge-case inputs when called from SYCL kernels.
• To enhance performance on Intel® GPUs using the Unified Runtime Level Zero Adapter, support for driver-optimized in-order lists has been introduced in version 2025.0. However, when running workloads with sycl::property::queue::enable_profiling, some performance overhead from these lists is expected. If this overhead negatively impacts performance, it can be mitigated by disabling the driver in-order lists. To do so, set UR_L0_USE_DRIVER_INORDER_LISTS=0.

• To ensure compatibility with the DPC++ Compiler on Windows*, which requires OpenCL 3.0, it is essential to address potential issues caused by older versions of opencl.dll on your system. If an outdated opencl.dll is present in system directories or takes precedence in the library path, it may lead to failures, including SYCL-related issues and crashes in tools like Intel VTune and Advisor when specific OpenCL 3.0 features are used. The recommended solution is to replace the old opencl.dll with the one installed in the DPC++ package. You can do this by copying the newer opencl.dll from $oneAPI_Install_Folder\compiler\latest\bin to your system folder. Be sure to back up the original opencl.dll in case it's needed for other applications.

• sycl_ext_oneapi_free_function_kernels has limitations including:
  • free function kernels are only supported if defined at file scope
  • SYCL_EXTERNAL has to be used alongside SYCL_EXT_ONEAPI_FUNCTION_PROPERTY to define free function kernel
  • compiler won't emit any diagnostics if some restrictions from the extension specification are violated
  • arguments of a free function kernels cannot be composite data types like structs or SYCL classes like accessor
  • using -fsycl-dead-args-optimization (ON by default) can lead to failures
  • info::kernel::num_args won't return the right result for free function kernels

New OpenMP Features

• Support for the -fopenmp-offload-mandatory compiler flag to omit creation of host-fallback code and emit a runtime error if OpenMP offload to the device fails.
• Improved optimization report support for OpenMP constructs.
• Enhanced conversion scheme of nested loop constructs to consider loop trip counts.
• Updates to the declare variant for a dispatch construct to include GPUs with the Xe2 architecture when the match clause specifies device={arch(gen)}.
• Support for the device_type(host|nohost|any) clause for the target construct.
• Inclusion of the if clause for the teams construct.
• Change of the map-type property to "default," allowing map-type modifiers to be specified without a map-type. For example, map(always : x) is equivalent to map(always, tofrom : x).
• Support for the Intel extension ompx_sub_group_size clause for the target construct to set the SIMD width of the kernel.
• Support for the Intel extension ompx_dyn_cgroup_mem clause for the target construct, allowing dynamic allocation in SLM for GPU offloading.
• Extension of environment variables OMP_THREAD_LIMIT, OMP_TEAMS_THREAD_LIMIT, and OMP_NUM_THREADS to support abstract names. For example, OMP_THREAD_LIMIT=n_cores.
• Extension of the syntax of the environment variable OMP_PLACES to support bound and stride for abstract names. For example, OMP_PLACES=threads(4:2).
• Host runtime support for the environment variable OMP_AVAILABLE_DEVICES.
• Extension of the environment variable OMP_DEFAULT_DEVICE to support device selection by traits.

Notable OpenMP Fixes

• Fixed a bug where the dispatch construct’s device clause was not updating OpenMP’s default-device-var ICV.
• Resolved an internal compiler error when the declare variant for a dispatch construct did not specify an adjust_args clause.
• Fixed an optimization bug in OpenMP for and simd loops with large trip counts.
• Corrected a regression where enclosing task constructs inside a teams construct triggered a compiler error message.
• When thread_limit is specified for both target and teams, the compiler now correctly chooses their minimum instead of always using the one specified for target.
• Fixed an internal compiler error related to the initialization of global variables allocated in GPU’s SLM.
• Addressed a problem in offload runtime where the reference counts of variables mapped using declare mapper were not decremented correctly.
• Fixed a GPU offload performance issue related to L1 cache being affected by temporary copies of reduction variables.
• Resolved a bug where user-defined reduction variables were not properly constructed or destructed.

OpenMP Known Issues

• Implicit barriers at the end of parallel regions do not act as synchronization points for the tasks associated with target nowait and dispatch nowait constructs. This may result in incorrect results or crashes. A workaround is to use #pragma omp taskwait at the end of parallel region to ensure synchronization of target/dispatch nowait regions, where it would otherwise have happened due to the presence of a parallel region’s implicit barrier.

Other Known Issues and Limitations

• Visual Studio IDE Integration: Users will encounter an error while building the C++ project using 'Intel C++ Compiler 2025' for Win32 platform. Please note that Win32 platform is not supported with 'Intel C++ Compiler 2025' and project should be compiled for x64 platform only. If Win32 platform is selected, an error will be raised that ICX compiler not found.

Hardware Support:

• -march=lunarlake
• -march=graniterapids

Please check here for details about -march usage. 

Toolchain Support to Intel Platforms

C/C++ Standard

• Intel® oneAPI DPC++/C++ Compiler version 2025.0 supports the C/C++ standards through the Clang 19 front end. 
• Initiated support for C++2c, the next release of C++ after C++23, and C2y, the next release of C after C23
• Finalized the implementation of “deducing this” (C++23)
• Relaxed some constexpr restrictions (C++23)
• Implemented the [[assume]] attribute (C++23)
• Completed support for Concepts (C++20)
• Added support for char8_t (C23)
• Implemented the constexpr keyword for object declarations (C23)
• Implemented #embed for embedding binary resources in source (C23)

System Requirements

• Intel® oneAPI DPC++/C++ Compiler System Requirements

Additional Documentation

• Get Started with the Intel^® oneAPI Toolkit for Linux*
• Get Started with the Intel^® oneAPI Toolkit for Windows* 
• OneAPI Versioning Schema based on Semantic Versioning
• Intel® oneAPI DPC++/C++ Compiler Developer Guide and Reference
• Intel® oneAPI Programming Guide
• SYCL* 2020 Specification Features and DPC++ Language Extensions Supported

• OpenMP* Features and Extensions Supported in Intel® oneAPI DPC++/C++ Compiler

Previous oneAPI Releases

• Intel® oneAPI DPC++/C++ Compiler 2024
• Intel® oneAPI DPC++/C++ Compiler 2023
• Intel® oneAPI DPC++/C++ Compiler 2022
• Intel® oneAPI DPC++/C++ Compiler 2021

Notices and Disclaimers

Intel optimizations, for Intel compilers or other products, may not optimize to the same degree for non-Intel products.

Intel technologies may require enabled hardware, software, or service activation.

No product or component can be absolutely secure.

Your costs and results may vary.

© Intel Corporation. Intel, the Intel logo, and other Intel marks are trademarks of Intel Corporation or its subsidiaries. Other names and brands may be claimed as the property of others.

No license (express or implied, by estoppel or otherwise) to any intellectual property rights is granted by this document.

The products described may contain design defects or errors known as errata which may cause the product to deviate from published specifications. Current characterized errata are available on request.

Intel optimizations, for Intel compilers or other products, may not optimize to the same degree for non-Intel products.

Intel disclaims all express and implied warranties, including without limitation, the implied warranties of merchantability, fitness for a particular purpose, and non-infringement, as well as any warranty arising from a course of performance, course of dealing, or usage in trade.