Intel® oneAPI DPC++ Library (Beta) Release Notes

Última atualização: 06/19/2020

Where to Find the Release

Please follow the steps to download the toolkit from the Web Configurator, and follow the installation instructions.

New in 2021.1-beta08

New Features

  • Added random number generation functionality in <oneapi/dpl/random>:
    • linear_congruential_enginesubtract_with_carry_enginediscard_block_engine;
    • predefined engine instantiations, including minstd_rand and ranlux48;
    • uniform_real_distributionuniform_int_distributionnormal_distribution.
  • Added implicit conversion of a DPC++ policy to sycl::queue.
  • Added the ONEDPL_STANDARD_POLICIES_ONLY macro (defaults to 0) that makes the DPC++ policies unavailable, avoiding dependency on the DPC++ compiler and limiting oneDPL algorithms to only use the standard C++ policies(seqparunseqpar_unseq) for the host CPUs. It replaces the former _PSTL_BACKEND_SYCL macro with the opposite meaning.
  • Added permutation_iterator and discard_iterator in <oneapi/dpl/iterator>.

Changes to Existing Features

  • Improved performance of the sort and stable_sort algorithms with device_policy for non-arithmetic data types.
  • The dpstd include folder was renamed. Include <oneapi/dpl/...> headers instead of <dpstd/...>.
  • The main namespace of the library changed to oneapi::dpl. The dpstd namespace is deprecated, and will be removed in one of the next releases.
  • The following API elements of oneDPL were changed or removed:
    • the default_policy object was renamed to dpcpp_default;
    • the fpga_policy object was renamed to dpcpp_fpga;
    • the fpga_device_policy class was renamed to fpga_policy;
    • the _PSTL_FPGA_DEVICE macro was renamed to ONEDPL_FPGA_DEVICE;
    • the _PSTL_FPGA_EMU macro was renamed to ONEDPL_FPGA_EMULATOR;
    • the _PSTL_COMPILE_KERNEL macro was removed;
    • the _PSTL_BACKEND_SYCL macro was removed.

Note: The default_policyfpga_device_policy names are deprecated, and will be removed in one of the next releases. Other previous names are no more valid.

Fixed Issues

  • Fixed scan-based algorithms to not rely on independent forward progress for workgroups.

Known Issues

  • On the DPC++ CPU device, RNG sequences produced by discard_block_engine may deviate from those generated by other implementations of the engine.
  • If <oneapi/dpl/random> is included into code before other oneDPL header files, compilation can fail. In order to avoid failures, include <oneapi/dpl/random> after any other oneDPL header file.
  • The following algorithms may be significantly slower with device_policy than in previous Beta releases: copy_ifexclusive_scaninclusive_scanpartitionpartition_copyremoveremove_copyremove_ifset_differenceset_intersectionset_symmetric_differenceset_unionstable_partitiontransform_exclusive_scantransform_inclusive_scanuniqueunique_copy.
  • sort,  stable_sort,  partial_sort,  partial_sort_copy  algorithms may work incorrectly in debug mode.
  • Some algorithms with a DPC++ policy may fail on CPU or on FPGA emulator.
  • std::tuple cannot be used with SYCL buffers to transfer data between host and device.
  • When used within DPC++ kernels or transferred to/from a device, std::tuplestd::pair and std::array can only hold objects whose type meets DPC++ requirements for use in kernels and for data transfer, respectively.
  • std::array::at member function cannot be used in kernels because it may throw an exception; use std::array::operator[] instead.
  • std::array member function swap and std::swap for std::array cannot be used in DPC++ kernels on Windows* platform.
  • Not all functions in <cmath> are supported currently, please refer to DPC++ library guide for detail list.
  • Due to specifics of Microsoft* Visual C++ implementation, some standard math functions for float (including: std::ldexpstd::frexpstd::sqrt(std::complex<float>)) require device support for double precision.

2021.1-beta07

New Features

  • The Microsoft* Visual C++ implementation of std::complex is now supported in device code.

Changes to Existing Features

  • dpstd/iterators.h is deprecated and replaced with dpstd/iterator.
  • Improved performance of the any_ofadjacent_findall_of,  equal,  find,  find_end,  find_first_of,  find_iffind_if_notincludesis_heapis_heap_untilis_sorted,  is_sorted_untilmismatchnone_ofsearchsearch_n  algorithms using DPC++ policies.

Fixed Issues

  • Fixed error with usage of  dpstd::zip_iterator  on Windows.
  • Fixed  exclusive_scan  compilation errors with GCC 9 and Clang 9 in C++17 mode.
  • Eliminated warnings about deprecated sub-group interfaces.

Known Issues

  • sort,  stable_sort,  partial_sort,  partial_sort_copy  algorithms may work incorrectly in debug mode.
  • Some algorithms with a DPC++ policy may fail on CPU or on FPGA emulator.
  • std::tuple cannot be used with SYCL buffers to transfer data between host and device.
  • When used within DPC++ kernels or transferred to/from a device, std::tuplestd::pair and std::array can only hold objects whose type meets DPC++ requirements for use in kernels and for data transfer, respectively.
  • std::array::at member function cannot be used in kernels because it may throw an exception; use std::array::operator[] instead.
  • std::array member function swap and std::swap for std::array cannot be used in DPC++ kernels on Windows* platform.
  • Not all functions in <cmath> are supported currently, please refer to DPC++ library guide for detail list.
  • Due to specifics of Microsoft* Visual C++ implementation, some standard math functions for float (including: std::ldexpstd::frexpstd::sqrt(std::complex<float>)) require device support for double precision.
  • There is a known issue on Windows with trying to use clGetPlatformInfo and ClGetDeviceInfo when using a graphics driver older than 27.20.100.8280.  If you run into this issue, please upgrade to the latest driver of at least version 27.20.100.8280  from the Download Center.

2021.1-beta06

New Features

  • Added fpga_device_policy class, make_fpga_policy function and fpga_policy object which may help achieve better performance on FPGA hardware.
  • Added support for <cmath> on Windows platform.
  • Added vectorized search algorithms binary_searchlower_bound and upper_bound.

Changes to Existing Features

  • Host side (synchronous) exceptions are no more handled, and instead passed through algorithms to the calling function.
  • For better performance sorting algorithms are specialized to use Radix sort with arithmetic data types and std::lessstd::greater comparators.
  • Improved performance of algorithms when used with Intel® DPC++ Compatibility Tool iterator and pointer types.
  • Improved performance of the merge algorithm with a DPC++ device_policy.

Fixed Issues

  • Fixed errors with usage of std::tuple in user-provided functors when dpstd::zip_iterator is passed to Parallel STL algorithms.

Known Issues

  • sortstable_sortpartial_sortpartial_sort_copy algorithms may work incorrectly in debug mode.
  • Using DPC++ policy some algorithms might fail on CPU.
  • std::tuple cannot be used with SYCL buffers to transfer data between host and device.
  • When used within DPC++ kernels or transferred to/from a device, std::tuplestd::pair and std::array can only hold objects whose type meets DPC++ requirements for use in kernels and for data transfer, respectively.
  • std::array::at member function cannot be used in kernels because it may throw an exception; use std::array::operator[] instead.
  • std::array member function swap cannot be used in DPC++ kernels on Windows* platform.
  • std::swap for std::array cannot work in DPC++ kernels on Windows platform.
  • Not all functions in <cmath> are supported currently, please refer to DPC++ library guide for detail list.
  • std::complex division may fail in kernel code on some CPU platform.

2021.1-beta05

Changes to Existing Features

  • Improved USM pointers support.

Note Non-USM pointers are not supported by the DPC++ execution policies anymore.

  • A performance optimization has been implemented for partial_sort, partial_sort_copy algorithms using standard C++ policies.

Fixed Issues

  • Usage of non-trivial user types with standard C++ policies is fixed for the following algorithms: remove_if, unique, rotate, partial_sort_copy, set_intersection, set_union, set_difference, set_symmetric_difference.

Known Issues

  • Some algorithms might fail on CPU when using DPC++ policy.
  • std::tuple cannot be used with SYCL buffers to transfer data between host and device.
  • When used within DPC++ kernels or transferred to/from a device, std::tuple, std::pair and std::array can only hold objects whose type meets DPC++ requirements for use in kernels and for data transfer, respectively.
  • std::array::at member function cannot be used in kernels because it may throw an exception, work around is to use std::array::operator[].
  • std::array member function swap cannot be used in DPC++ kernels on Windows* platform.
  • std::swap for std::array cannot work in DPC++ kernels on Windows platform.
  • Not all functions in <cmath> are supported currently, please refer to DPC++ library guide for detail list.
  • std::complex division may fail in kernel code on some CPU platforms.

2021.1-beta04

New Features

  • Added 64-bit atomics support.
  • Added the following to Tested standard C++ APIs
    •  <complex> and most functions in <cmath>(GNU libstdc++)
    • <ratio> (GNU libstdc++, LLVM libc++, MSVC)
    • std::numeric_limits(GNU libstdc++, MSVC)

Changes to Existing Features

  • The following DPC++ execution policies were renamed.
    • From dpstd::execution::sycl_policy to dpstd::execution::device_policy.
    • From dpstd::execution::make_sycl_policy to dpstd::execution::make_device_policy.
    • From dpstd::execution::sycl object to dpstd::execution::default_policy

    dpstd::execution::sycl_policy, dpstd::execution::make_sycl_policy, dpstd::execution::sycl were deprecated.

  • The following algorithms in Extension API were renamed.
    • From reduce_by_key to reduce_by_segment.
    • From inclusive_scan_by_key to inclusive_scan_by_segment.
    • From exclusive_scan_by_keyto exclusive_scan_by_segment.

Known Issues

  • Using DPC++ policy some algorithms might fail on CPU.
  • std::tuple cannot be used with SYCL buffers to transfer data between host and device.
  • When used within DPC++ kernels or transferred to/from a device, std::tuple, std::pair, and std::array can only hold objects whose type meets DPC++ requirements for use in kernels and for data transfer, respectively. 
  • std::array::at member function cannot be used in kernels because it may throw an exception; use std::array::operator[] instead.
  • std::array member function swap cannot be used in DPC++ kernels on Windows* platform.
  • std::swap for std::array cannot work in DPC++ kernels on Windows platform.
  • Not all functions in <cmath> are supported currently, please refer to DPC++ library guide for detail list.
  • std::complex division may fail in kernel code on some CPU platform.

2021.1-beta03

New Features

  • Added support for Data Parallel C++ (DPC++) to Parallel STL algorithms. For a complete list of Parallel STL algorithms see the ISO/IEC 14882:2017 standard (C++17).
  • Added dpstd::begin, dpstd::end helper functions to pass the cl::sycl::buffer into Parallel STL algorithms.
  • Added initial support for Unified Shared Memory in Parallel STL algorithms.
  • More than 80 C++ standard APIs from <algorithm>, <array>, <tuple>, <utility>, <functional>, <type_traits>, <initializer_list> were tested for use in DPC++ kernels. For more information, see the library guide.
  • Added counting_iterator, zip_iterator, transform_iterator, reduce_by_key, inclusive_scan_by_key, and exclusive_scan_by_key to the extension API.
  • Added functional utility classes that include identity, minimum, maximum to the extension API.

Changes to Existing Features

  • Construction of a DPC++ execution policy from the cl::sycl::ordered queue.

Fixed Issues

  • Errors no longer appear when the <dpstd/execution> header is included after other the oneDPL headers.
  • Algorithms now work with zip iterators if standard C++ execution policies are used.

Known Issues

  • Algorithms adjacent_find, find, find_end, find_first_of, find_if, find_if_not, is_sorted, is_sorted_until, mismatch, search, and search_n do not use iterators with the size of difference_type more than 32 bits.
  • std::tuple cannot be used with SYCL* buffers to transfer data between the host and device.
  • When used within DPC++ kernels or transferred to or from a device, std::tuple, std::pair, and std::array can only hold objects whose type meets DPC++ requirements for use in kernels and for data transfer, respectively.
  • std::array::at member function cannot be used in kernels because it may throw an exception; use std::array::operator[] instead.
  • A std::array member function swap and std::swap for std::array cannot be used in DPC++ kernels on Windows* platforms.

Notices and Disclaimers

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.
Intel's compilers may or may not optimize to the same degree for non-Intel microprocessors for optimizations that are not unique to Intel microprocessors. These optimizations include SSE2, SSE3, and SSSE3 instruction sets and other optimizations. Intel does not guarantee the availability, functionality, or effectiveness of any optimization on microprocessors not manufactured by Intel. Microprocessor-dependent optimizations in this product are intended for use with Intel microprocessors. Certain optimizations not specific to Intel microarchitecture are reserved for Intel microprocessors. Please refer to the applicable product User and Reference Guides for more information regarding the specific instruction sets covered by this notice.

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 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 course of performance, course of dealing, or usage in trade.

Informações de produto e desempenho

1

Os compiladores da Intel podem ou não otimizar para o mesmo nível de microprocessadores não Intel no caso de otimizações que não são exclusivas para microprocessadores Intel. Essas otimizações incluem os conjuntos de instruções SSE2, SSE3 e SSSE3, e outras otimizações. A Intel não garante a disponibilidade, a funcionalidade ou eficácia de qualquer otimização sobre microprocessadores não fabricados pela Intel. As otimizações que dependem de microprocessadores neste produto são destinadas ao uso com microprocessadores Intel. Algumas otimizações não específicas da microarquitetura Intel são reservadas para os microprocessadores Intel. Consulte os Guias de Usuário e Referência do produto aplicáveis para obter mais informações sobre os conjuntos de instruções específicos cobertos por este aviso.

Revisão do aviso #20110804