Intel® oneAPI Threading Building Blocks Release Notes

ID 768377
Updated 10/15/2024
Version 2022.0
Public

author-image

By

Where to Find the Release

Intel® oneAPI Threading Building Blocks

New in 2022.0 Release

New Features

  • Extended the Flow Graph receiving nodes with a new try_put_and_wait API that submits a message to the graph and waits for its completion.

Known Limitations

  • Intel® oneAPI Toolkits 2022.1.3 and earlier and Intel® Parallel Studio XE (any version) do not support Microsoft Visual Studio 2022. On systems with Microsoft Visual Studio 2022 installed, Intel® oneAPI and Intel® Parallel Studio XE installers may fail during installation, upgrade, modification, or uninstallation. Refer to this article for more information.
  • The oneapi::tbb::info namespace interfaces might unexpectedly change the process affinity mask on Windows* OS systems (see https://github.com/open-mpi/hwloc/issues/366 for details) when using hwloc version lower than 2.5.
  • Using a hwloc version other than 1.11, 2.0, or 2.5 may cause an undefined behavior on Windows OS. See https://github.com/open-mpi/hwloc/issues/477 for details.
  • The NUMA topology may be detected incorrectly on Windows OS machines where the number of NUMA node threads exceeds the size of 1 processor group.
  • On Windows OS on ARM64*, when compiling an application using oneTBB with the Microsoft* Compiler, the compiler issues a warning C4324 that a structure was padded due to the alignment specifier. Consider suppressing the warning by specifying /wd4324 to the compiler command line.
  • C++ exception handling mechanism on Windows* OS on ARM64* might corrupt memory if an exception is thrown from any oneTBB parallel algorithm (see Windows* OS on ARM64* compiler issue: https://developercommunity.visualstudio.com/t/ARM64-incorrect-stack-unwinding-for-alig/1544293).
  • When CPU resource coordination is enabled, tasks from a lower-priority task_arena might be executed before tasks from a higher-priority task_arena.
  • Note: To see known limitations that impact all versions of oneTBB, refer to oneTBB Developer Guide and Reference.

Fixed Issues

  • Fixed the missed signal for thread request for enqueue operation.
  • Significantly improved scalability of task_group, flow_graph, and parallel_for_each.
  • Removed usage of std::aligned_storage deprecated in C++23 (Inspired by Valery Matskevich https://github.com/oneapi-src/oneTBB/pull/1394).
  • Fixed the issue where `oneapi::tbb::info` interfaces might interfere with the process affinity mask on the Windows* OS systems with multiple processor groups.

Open-source Contributions Integrated

New in 2021.13 Release

New Features

  • Extended the parallel_reduce and parallel_deterministic_reduce functional form API to better support rvalues reduction (GitHub*  #1299).

Known Limitations

  • Intel® oneAPI Toolkits 2022.1.3 and earlier and Intel® Parallel Studio XE (any version) do not support Microsoft Visual Studio 2022. On systems with Microsoft Visual Studio 2022 installed, Intel® oneAPI and Intel® Parallel Studio XE installers may fail during installation, upgrade, modification, or uninstallation. Refer to this article for more information.
  • The oneapi::tbb::info namespace interfaces might unexpectedly change the process affinity mask on Windows* OS systems (see https://github.com/open-mpi/hwloc/issues/366 for details) when using hwloc version lower than 2.5.
  • Using a hwloc version other than 1.11, 2.0, or 2.5 may cause an undefined behavior on Windows OS. See https://github.com/open-mpi/hwloc/issues/477 for details.
  • The NUMA topology may be detected incorrectly on Windows OS machines where the number of NUMA node threads exceeds the size of 1 processor group.
  • On Windows OS on ARM64*, when compiling an application using oneTBB with the Microsoft* Compiler, the compiler issues a warning C4324 that a structure was padded due to the alignment specifier. Consider suppressing the warning by specifying /wd4324 to the compiler command line.
  • C++ exception handling mechanism on Windows* OS on ARM64* might corrupt memory if an exception is thrown from any oneTBB parallel algorithm (see Windows* OS on ARM64* compiler issue: https://developercommunity.visualstudio.com/t/ARM64-incorrect-stack-unwinding-for-alig/1544293).
  • When CPU resource coordination is enabled, tasks from a lower-priority task_arena might be executed before tasks from a higher-priority task_arena.
  • Note: To see known limitations that impact all versions of oneTBB, refer to oneTBB Developer Guide and Reference.

Fixed Issues

  • Improved security by excluding CWD from search of load-time dependencies.
  • Improved performance on Apple* platforms by aligning block-time behavior with other OS.
  • Improved performance on non-hybrid CPU hardware by reworking block-time behavior.
  • Improved performance on ARM64 platform by fixing backoff behavior for spin loops.
  • Improved performance when constraints API is used on server CPU HW with multiple NUMA nodes.

Open-source Contributions Integrated

Third Party Programs File

New in 2021.12 Release

Known Limitations

  • Intel® oneAPI Toolkits 2022.1.3 and earlier and Intel® Parallel Studio XE (any version) do not support Microsoft Visual Studio 2022. On systems with Microsoft Visual Studio 2022 installed, Intel® oneAPI and Intel® Parallel Studio XE installers may fail during installation, upgrade, modification, or uninstallation. Refer to this article for more information.
  • The oneapi::tbb::info namespace interfaces might unexpectedly change the process affinity mask on Windows* OS systems (see https://github.com/open-mpi/hwloc/issues/366 for details) when using hwloc version lower than 2.5.
  • Using a hwloc version other than 1.11, 2.0, or 2.5 may cause an undefined behavior on Windows OS. See https://github.com/open-mpi/hwloc/issues/477 for details.
  • The NUMA topology may be detected incorrectly on Windows OS machines where the number of NUMA node threads exceeds the size of 1 processor group.
  • On Windows OS on ARM64*, when compiling an application using oneTBB with the Microsoft* Compiler, the compiler issues a warning C4324 that a structure was padded due to the alignment specifier. Consider suppressing the warning by specifying /wd4324 to the compiler command line.
  • C++ exception handling mechanism on Windows* OS on ARM64* might corrupt memory if an exception is thrown from any oneTBB parallel algorithm (see Windows* OS on ARM64* compiler issue: https://developercommunity.visualstudio.com/t/ARM64-incorrect-stack-unwinding-for-alig/1544293).
  • When CPU resource coordination is enabled, tasks from a lower-priority task_arena might be executed before tasks from a higher-priority task_arena.
  • Note: To see known limitations that impact all versions of oneTBB, refer to oneTBB Developer Guide and Reference.

Fixed Issues

  • Fixed parallel_for_each algorithm behavior for iterators defining iterator_concept trait instead of iterator_category.
  • Fixed the redefinition issue for std::min and std::max on Windows* OS (GitHub* #832).
  • Fixed the incorrect binary search order in TBBConfig.cmake.
  • Enabled the oneTBB library search using the pkg-config tool in Conda packages.

Open-source Contributions Integrated

New in 2021.11 Release

New Features

  • oneTBB can now coordinate with Intel® OpenMP Runtime on CPU resource usage to avoid excessive oversubscription when both runtimes are used within a process. To use it, set the “TCM_ENABLE” environmental variable to 1.

Known Limitations

  • Intel® oneAPI Toolkits 2022.1.3 and earlier and Intel® Parallel Studio XE (any version) do not support Microsoft Visual Studio 2022. On systems with Microsoft Visual Studio 2022 installed, Intel® oneAPI and Intel® Parallel Studio XE installers may fail during installation, upgrade, modification, or uninstallation. Refer to this article for more information.
  • The oneapi::tbb::info namespace interfaces might unexpectedly change the process affinity mask on Windows* OS systems (see https://github.com/open-mpi/hwloc/issues/366 for details) when using hwloc version lower than 2.5.
  • Using a hwloc version other than 1.11, 2.0, or 2.5 may cause an undefined behavior on Windows OS. See https://github.com/open-mpi/hwloc/issues/477 for details.
  • The NUMA topology may be detected incorrectly on Windows OS machines where the number of NUMA node threads exceeds the size of 1 processor group.
  • On Windows OS on ARM64*, when compiling an application using oneTBB with the Microsoft* Compiler, the compiler issues a warning C4324 that a structure was padded due to the alignment specifier. Consider suppressing the warning by specifying /wd4324 to the compiler command line.
  • C++ exception handling mechanism on Windows* OS on ARM64* might corrupt memory if an exception is thrown from any oneTBB parallel algorithm (see Windows* OS on ARM64* compiler issue: https://developercommunity.visualstudio.com/t/ARM64-incorrect-stack-unwinding-for-alig/1544293).
  • When CPU resource coordination is enabled, tasks from a lower-priority task_arena might be executed before tasks from a higher-priority task_arena.
  • Using TBBConfig.cmake in 32-bit environment may cause incorrect linkage with 64-bit oneTBB library. As a workaround, set CMAKE_PREFIX_PATH:
    • On Linux* OS: to TBBROOT/lib32/
    • On Windows* OS: to TBBROOT/lib32/;TBBROOT/bin32/
  • Note: To see known limitations that impact all versions of oneTBB, refer to oneTBB Developer Guide and Reference.

Fixed Issues

  • Fixed tbb::this_task_arena() behavior for specific tbb::task_arena{1,0}.
  • Restored performance on systems with a high number of CPU cores that support _tpause.

New in 2021.10 Release

New Features

  • Since C++17, parallel algorithms and Flow Graph nodes are allowed to accept pointers to the member functions and member objects as the user-provided callables.
  • Added missed member functions, such as assignment operators and swap function, to the concurrent_queue and concurrent_bounded_queue containers.

Known Limitations

  • Intel® oneAPI Toolkits 2022.1.3 and earlier and Intel® Parallel Studio XE (any version) do not support Microsoft Visual Studio 2022. On systems with Microsoft Visual Studio 2022 installed, Intel® oneAPI and Intel® Parallel Studio XE installers may fail during installation, upgrade, modification, or uninstallation. Refer to this article for more information.
  • A static assert will cause compilation failures in oneTBB headers when compiling with clang 12.0.0 or newer if using the LLVM standard library with -ffreestanding and C++11/14 compiler options. 
  • An application using Parallel STL algorithms in libstdc++ versions 9 and 10 may fail to compile due to incompatible interface changes between earlier versions of Threading Building Blocks (TBB) and oneAPI Threading Building Blocks (oneTBB). Disable support for Parallel STL algorithms by defining PSTL_USE_PARALLEL_POLICIES (in libstdc++ 9) or _GLIBCXX_USE_TBB_PAR_BACKEND (in libstdc++ 10) macro to zero before inclusion of the first standard header file in each translation unit.
  • On Linux* OS, if oneAPI Threading Building Blocks (oneTBB) or Threading Building Blocks (TBB) are installed in a system folder like /usr/lib64, the application may fail to link due to the order in which the linker searches for libraries. Use the -L linker option to specify the correct location of oneTBB library. This issue does not affect the program execution.
  • The oneapi::tbb::info namespace interfaces might unexpectedly change the process affinity mask on Windows* OS systems (see https://github.com/open-mpi/hwloc/issues/366 for details) when using hwloc version lower than 2.5.
  • Using a hwloc version other than 1.11, 2.0, or 2.5 may cause an undefined behavior on Windows OS. See https://github.com/open-mpi/hwloc/issues/477 for details.
  • The NUMA topology may be detected incorrectly on Windows OS machines where the number of NUMA node threads exceeds the size of 1 processor group.
  • On Windows OS on ARM64*, when compiling an application using oneTBB with the Microsoft* Compiler, the compiler issues a warning C4324 that a structure was padded due to the alignment specifier. Consider suppressing the warning by specifying /wd4324 to the compiler command line.
  • oneTBB does not support fork(), to work-around the issue, consider using task_scheduler_handle to join oneTBB worker threads before using fork().
  • C++ exception handling mechanism on Windows* OS on ARM64* might corrupt memory if an exception is thrown from any oneTBB parallel algorithm (see Windows* OS on ARM64* compiler issue: https://developercommunity.visualstudio.com/t/ARM64-incorrect-stack-unwinding-for-alig/1544293).

Fixed Issues

  • Fixed the hang in the reserve method of concurrent unordered containers (GitHub* #1056).
  • Fixed the C++20 three-way comparison feature detection (GitHub* #1093).
  • Fixed oneTBB integration with CMake* in the Conda* environment.

New in 2021.9 Release

New Features

  • Hybrid CPU support is now a fully supported feature.

Known Limitations

  • Intel® oneAPI Toolkits 2022.1.3 and earlier and Intel® Parallel Studio XE (any version) do not support Microsoft Visual Studio 2022. On systems with Microsoft Visual Studio 2022 installed, Intel® oneAPI and Intel® Parallel Studio XE installers may fail during installation, upgrade, modification, or uninstallation. Refer to this article for more information.
  • A static assert will cause compilation failures in oneTBB headers when compiling with clang 12.0.0 or newer if using the LLVM standard library with -ffreestanding and C++11/14 compiler options. 
  • An application using Parallel STL algorithms in libstdc++ versions 9 and 10 may fail to compile due to incompatible interface changes between earlier versions of Threading Building Blocks (TBB) and oneAPI Threading Building Blocks (oneTBB). Disable support for Parallel STL algorithms by defining PSTL_USE_PARALLEL_POLICIES (in libstdc++ 9) or _GLIBCXX_USE_TBB_PAR_BACKEND (in libstdc++ 10) macro to zero before inclusion of the first standard header file in each translation unit.
  • On Linux* OS, if oneAPI Threading Building Blocks (oneTBB) or Threading Building Blocks (TBB) are installed in a system folder like /usr/lib64, the application may fail to link due to the order in which the linker searches for libraries. Use the -L linker option to specify the correct location of oneTBB library. This issue does not affect the program execution.
  • The oneapi::tbb::info namespace interfaces might unexpectedly change the process affinity mask on Windows* OS systems (see https://github.com/open-mpi/hwloc/issues/366 for details) when using hwloc version lower than 2.5.
  • Using a hwloc version other than 1.11, 2.0, or 2.5 may cause an undefined behavior on Windows OS. See https://github.com/open-mpi/hwloc/issues/477 for details.
  • The NUMA topology may be detected incorrectly on Windows OS machines where the number of NUMA node threads exceeds the size of 1 processor group.
  • On Windows OS on ARM64*, when compiling an application using oneTBB with the Microsoft* Compiler, the compiler issues a warning C4324 that a structure was padded due to the alignment specifier. Consider suppressing the warning by specifying /wd4324 to the compiler command line.
  • oneTBB does not support fork(), to work-around the issue, consider using task_scheduler_handle to join oneTBB worker threads before using fork().
  • C++ exception handling mechanism on Windows* OS on ARM64* might corrupt memory if an exception is thrown from any oneTBB parallel algorithm (see Windows* OS on ARM64* compiler issue: https://developercommunity.visualstudio.com/t/ARM64-incorrect-stack-unwinding-for-alig/1544293).

Fixed Issues

  • Improved robustness of thread creation algorithm on Linux* OS.
  • Enabled full support of Thread Sanitizer on macOS*
  • Fixed the issue with destructor calls for uninitialized objects in oneapi::tbb::parallel_for_each algorithm (GitHub* #691)
  • Fixed the issue with tbb::concurrent_lru_cache when items history capacity is zero (GitHub* #265)
  • Fixed compilation issues on modern GCC* versions

Open-source Contributions Integrated

New in 2021.8 Release

Known Limitations

  • Intel® oneAPI Toolkits 2022.1.3 and earlier and Intel® Parallel Studio XE (any version) do not support Microsoft Visual Studio 2022. On systems with Microsoft Visual Studio 2022 installed, Intel® oneAPI and Intel® Parallel Studio XE installers may fail during installation, upgrade, modification, or uninstallation. Refer to this article for more information.
  • A static assert will cause compilation failures in oneTBB headers when compiling with clang 12.0.0 or newer if using the LLVM standard library with -ffreestanding and C++11/14 compiler options. 
  • An application using Parallel STL algorithms in libstdc++ versions 9 and 10 may fail to compile due to incompatible interface changes between earlier versions of Threading Building Blocks (TBB) and oneAPI Threading Building Blocks (oneTBB). Disable support for Parallel STL algorithms by defining PSTL_USE_PARALLEL_POLICIES (in libstdc++ 9) or _GLIBCXX_USE_TBB_PAR_BACKEND (in libstdc++ 10) macro to zero before inclusion of the first standard header file in each translation unit.
  • On Linux* OS, if oneAPI Threading Building Blocks (oneTBB) or Threading Building Blocks (TBB) are installed in a system folder like /usr/lib64, the application may fail to link due to the order in which the linker searches for libraries. Use the -L linker option to specify the correct location of oneTBB library. This issue does not affect the program execution.
  • The oneapi::tbb::info namespace interfaces might unexpectedly change the process affinity mask on Windows* OS systems (see https://github.com/open-mpi/hwloc/issues/366 for details) when using hwloc version lower than 2.5.
  • Using a hwloc version other than 1.11, 2.0, or 2.5 may cause an undefined behavior on Windows OS. See https://github.com/open-mpi/hwloc/issues/477 for details.
  • The NUMA topology may be detected incorrectly on Windows OS machines where the number of NUMA node threads exceeds the size of 1 processor group.
  • On Windows OS on ARM64*, when compiling an application using oneTBB with the Microsoft* Compiler, the compiler issues a warning C4324 that a structure was padded due to the alignment specifier. Consider suppressing the warning by specifying /wd4324 to the compiler command line.
  • oneTBB does not support fork(), to work-around the issue, consider using task_scheduler_handle to join oneTBB worker threads before using fork().
  • C++ exception handling mechanism on Windows* OS on ARM64* might corrupt memory if an exception is thrown from any oneTBB parallel algorithm (see Windows* OS on ARM64* compiler issue: https://developercommunity.visualstudio.com/t/ARM64-incorrect-stack-unwinding-for-alig/1544293).

Fixed Issues

  • Fixed oneapi::tbb::concurrent_bounded_queue::pop return type (GitHub* #807).
  • Fixed oneapi::tbb::concurrent_queue and oneapi::tbb::concurrent_bounded_queue with non-default constructible value types (GitHub* #885).
  • Fixed incorrect splitting of iteration space in case there is no support for proportional splitting in custom ranges.

New in 2021.7 Release

Known Limitations

  • Intel® oneAPI Toolkits 2022.1.3 and earlier and Intel® Parallel Studio XE (any version) do not support Microsoft Visual Studio 2022. On systems with Microsoft Visual Studio 2022 installed, Intel® oneAPI and Intel® Parallel Studio XE installers may fail during installation, upgrade, modification, or uninstallation. Refer to this article for more information.
  • A static assert will cause compilation failures in oneTBB headers when compiling with clang 12.0.0 or newer if using the LLVM standard library with -ffreestanding and C++11/14 compiler options. 
  • An application using Parallel STL algorithms in libstdc++ versions 9 and 10 may fail to compile due to incompatible interface changes between earlier versions of Threading Building Blocks (TBB) and oneAPI Threading Building Blocks (oneTBB). Disable support for Parallel STL algorithms by defining PSTL_USE_PARALLEL_POLICIES (in libstdc++ 9) or _GLIBCXX_USE_TBB_PAR_BACKEND (in libstdc++ 10) macro to zero before inclusion of the first standard header file in each translation unit.
  • On Linux* OS, if oneAPI Threading Building Blocks (oneTBB) or Threading Building Blocks (TBB) are installed in a system folder like /usr/lib64, the application may fail to link due to the order in which the linker searches for libraries. Use the -L linker option to specify the correct location of oneTBB library. This issue does not affect the program execution.
  • The oneapi::tbb::info namespace interfaces might unexpectedly change the process affinity mask on Windows* OS systems (see https://github.com/open-mpi/hwloc/issues/366 for details) when using hwloc version lower than 2.5.
  • Using a hwloc version other than 1.11, 2.0, or 2.5 may cause an undefined behavior on Windows OS. See https://github.com/open-mpi/hwloc/issues/477 for details.
  • The NUMA topology may be detected incorrectly on Windows OS machines where the number of NUMA node threads exceeds the size of 1 processor group.
  • On Windows OS on ARM64*, when compiling an application using oneTBB with the Microsoft* Compiler, the compiler issues a warning C4324 that a structure was padded due to the alignment specifier. Consider suppressing the warning by specifying /wd4324 to the compiler command line.
  • oneTBB does not support fork(), to work-around the issue, consider using task_scheduler_handle to join oneTBB worker threads before using fork().
  • C++ exception handling mechanism on Windows* OS on ARM64* might corrupt memory if an exception is thrown from any oneTBB parallel algorithm (see Windows* OS on ARM64* compiler issue: https://developercommunity.visualstudio.com/t/ARM64-incorrect-stack-unwinding-for-alig/1544293).

Fixed Issues

  • Memory allocator crash when allocating ~1TB on 64-bit systems (GitHub* #838).
  • Thread Distribution over NUMA Nodes on Windows OS systems.
  • For oneapi::tbb::suspend it is now guaranteed that the user-specified callable object is executed by the calling thread.

New in 2021.6 Release

New Features

  • Improved support and use of the latest C++ standards for parallel_sort that allows using this algorithm with user-defined and standard library-defined objects with modern semantics.
  • The following features are now fully functional: task_arena extensions, collaborative_call_once, adaptive mutexes, heterogeneous overloads for concurrent_hash_map, and task_scheduler_handle.
  • Added support for Windows* Server 2022 and Python 3.10.

Known Limitations

  • An application using Parallel STL algorithms in libstdc++ versions 9 and 10 may fail to compile due to incompatible interface changes between earlier versions of Threading Building Blocks (TBB) and oneAPI Threading Building Blocks (oneTBB). Disable support for Parallel STL algorithms by defining PSTL_USE_PARALLEL_POLICIES (in libstdc++ 9) or _GLIBCXX_USE_TBB_PAR_BACKEND (in libstdc++ 10) macro to zero before inclusion of the first standard header file in each translation unit.
  • On Linux* OS, if oneAPI Threading Building Blocks (oneTBB) or Threading Building Blocks (TBB) are installed in a system folder like /usr/lib64, the application may fail to link due to the order in which the linker searches for libraries. Use the -L linker option to specify the correct location of oneTBB library. This issue does not affect the program execution.
  • The oneapi::tbb::info namespace interfaces might unexpectedly change the process affinity mask on Windows* OS systems (see https://github.com/open-mpi/hwloc/issues/366 for details) when using hwloc version lower than 2.5.
  • Using a hwloc version other than 1.11, 2.0, or 2.5 may cause an undefined behavior on Windows OS. See https://github.com/open-mpi/hwloc/issues/477 for details.
  • The NUMA topology may be detected incorrectly on Windows OS machines where the number of NUMA node threads exceeds the size of 1 processor group.
  • On Windows OS on ARM64*, when compiling an application using oneTBB with the Microsoft* Compiler, the compiler issues a warning C4324 that a structure was padded due to the alignment specifier. Consider suppressing the warning by specifying /wd4324 to the compiler command line.
  • oneTBB does not support fork(), to work-around the issue, consider using task_scheduler_handle to join oneTBB worker threads before using fork().
  • C++ exception handling mechanism on Windows* OS on ARM64* might corrupt memory if an exception is thrown from any oneTBB parallel algorithm (see Windows* OS on ARM64* compiler issue: https://developercommunity.visualstudio.com/t/ARM64-incorrect-stack-unwinding-for-alig/1544293).

Fixed Issues

  • Memory allocator crash on a system with an incomplete /proc/meminfo (GitHub* #584).
  • Incorrect blocking of task stealing (GitHub* #478).
  • Hang due to incorrect decrement of a limiter_node (GitHub* #634).
  • Memory corruption in some rare cases when passing big messages in a flow graph (GitHub* #639).
  • Possible deadlock in a throwable flow graph node with a lightweight policy. The lightweight policy is now ignored for functors that can throw exceptions (GitHub* #420).
  • Crash when obtaining a range from empty ordered and unordered containers (GitHub* #641).
  • Deadlock in a concurrent_vector resize() that could happen when the new size is less than the previous size (GitHub* #733).

Open-source Contributions Integrated

New in 2021.5 Release

Preview Features

  • Extended task_group interface with a new run_and_wait overload to accept task_handle.

New Features

  • Enabled Microsoft Visual Studio* 2022 and Python 3.9 support.

Known Limitations

  • An application using Parallel STL algorithms in libstdc++ versions 9 and 10 may fail to compile due to incompatible interface changes between earlier versions of Threading Building Blocks (TBB) and oneAPI Threading Building Blocks (oneTBB). Disable support for Parallel STL algorithms by defining PSTL_USE_PARALLEL_POLICIES (in libstdc++ 9) or _GLIBCXX_USE_TBB_PAR_BACKEND (in libstdc++ 10) macro to zero before inclusion of the first standard header file in each translation unit.
  • On Linux* OS, if oneAPI Threading Building Blocks (oneTBB) or Threading Building Blocks (TBB) are installed in a system folder like /usr/lib64, the application may fail to link due to the order in which the linker searches for libraries. Use the -L linker option to specify the correct location of oneTBB library. This issue does not affect the program execution.
  • The oneapi::tbb::info namespace interfaces might unexpectedly change the process affinity mask on Windows* OS systems (see https://github.com/open-mpi/hwloc/issues/366 for details) when using hwloc version lower than 2.5.
  • Using a hwloc version other than 1.11, 2.0, or 2.5 may cause an undefined behavior on Windows OS. See https://github.com/open-mpi/hwloc/issues/477 for details.
  • The NUMA topology may be detected incorrectly on Windows OS machines where the number of NUMA node threads exceeds the size of 1 processor group.
  • On Windows OS on ARM64*, when compiling an application using oneTBB with the Microsoft* Compiler, the compiler issues a warning C4324 that a structure was padded due to the alignment specifier. Consider suppressing the warning by specifying /wd4324 to the compiler command line.
  • oneTBB does not support fork(), to work-around the issue, consider using task_scheduler_handle to join oneTBB worker threads before using fork().
  • C++ exception handling mechanism on Windows* OS on ARM64* might corrupt memory if an exception is thrown from any oneTBB parallel algorithm (see Windows* OS on ARM64* compiler issue: https://developercommunity.visualstudio.com/t/ARM64-incorrect-stack-unwinding-for-alig/1544293).

Fixed Issues

  • Reworked synchronization mechanism to reduce contention when multiple task_arena's are used concurrently.
  • Fixed possible correctness issue in queuing_rw_mutex on non-Intel platforms.
  • Fixed GCC* 11 warnings.
  • Fixed sporadic memory corruption.

New in 2021.4 Release

Preview Features

  • Introduced the collaborative_call_once algorithm that executes the callable object exactly once, but allows other threads to join oneTBB parallel construction used inside this callable object. Inspired by Ben FrantzDale and Henry Heffan.

Known Limitations

  • An application using Parallel STL algorithms in libstdc++ versions 9 and 10 may fail to compile due to incompatible interface changes between earlier versions of Threading Building Blocks (TBB) and oneAPI Threading Building Blocks (oneTBB). Disable support for Parallel STL algorithms by defining PSTL_USE_PARALLEL_POLICIES (in libstdc++ 9) or _GLIBCXX_USE_TBB_PAR_BACKEND (in libstdc++ 10) macro to zero before inclusion of the first standard header file in each translation unit.
  • On Linux* OS, if oneAPI Threading Building Blocks (oneTBB) or Threading Building Blocks (TBB) are installed in a system folder like /usr/lib64, the application may fail to link due to the order in which the linker searches for libraries. Use the -L linker option to specify the correct location of oneTBB library. This issue does not affect the program execution.
  • The oneapi::tbb::info namespace interfaces might unexpectedly change the process affinity mask on Windows* OS systems (see https://github.com/open-mpi/hwloc/issues/366 for details) when using hwloc version lower than 2.5.
  • Using a hwloc version other than 1.11, 2.0, or 2.5 may cause an undefined behavior on Windows OS. See https://github.com/open-mpi/hwloc/issues/477 for details.
  • The NUMA topology may be detected incorrectly on Windows OS machines where the number of NUMA node threads exceeds the size of 1 processor group.
  • On Windows OS on ARM64*, when compiling an application using oneTBB with the Microsoft* Compiler, the compiler issues a warning C4324 that a structure was padded due to the alignment specifier. Consider suppressing the warning by specifying /wd4324 to the compiler command line.
  • oneTBB does not support fork(), to work-around the issue, consider using task_scheduler_handle to join oneTBB worker threads before using fork().

Fixed Issues

  • Enabled full support of Address Sanitizer and Thread Sanitizer.
  • Fixed a race condition in tbbmalloc that may cause a crash in realloc() when using tbbmalloc_proxy.
  • Enabled GCC* 11 support.
  • Fixed limiter_node behavior when an integral type is used as an argument for the DecrementType template parameter.
  • Fixed a possible memory leak when the static or affinity partitioners are used.
  • Fixed possible system oversubscription when using a process mask and an explicit number of threads in the task arena.

Open-source Contributions Integrated

New in 2021.3 Release

New Features

  • Since C++20 multiple interfaces are constrained to enforce requirements on argument types.

Preview Features

  • Extended the high-level task API to simplify migration from TBB to oneTBB.
  • Added mutex and rw_mutex that are suitable for long critical sections and resistant to high contention.
  • Added ability to customize the concurrent_hash_map mutex type.
  • Added heterogeneous lookup, erase, and insert operations to concurrent_hash_map.

Known Limitations

  • An application using Parallel STL algorithms in libstdc++ versions 9 and 10 may fail to compile due to incompatible interface changes between earlier versions of Threading Building Blocks (TBB) and oneAPI Threading Building Blocks (oneTBB). Disable support for Parallel STL algorithms by defining PSTL_USE_PARALLEL_POLICIES (in libstdc++ 9) or _GLIBCXX_USE_TBB_PAR_BACKEND (in libstdc++  10) macro to zero before inclusion of the first standard header file in each translation unit.
  • On Linux, if oneAPI Threading Building Blocks (oneTBB) or Threading Building Blocks (TBB) is installed in a system folder like /usr/lib64, the application may fail to link due to the linker search order for libraries. Use the -L linker option to specify the correct location of oneTBB libraries. This issue does not affect program execution.
  • The oneapi::tbb::info namespace interfaces might unexpectedly change the process affinity mask on Windows systems (see https://github.com/open-mpi/hwloc/issues/366 for details).

Fixed Issues

  • Fixed several issues in parallel algorithms and concurrent containers on ARM.
  • Improved ThreadSanitizer support for the oneTBB Scalable Memory Allocator.
  • Improved scheduler to reduce the impact of thread priority inversion.
  • Fixed the behavior of affinity_partitioner and static_partitioner to resolve possible performance issues.
  • Fixed crash when finalize is called with null scheduler_handler.
  • Fixed the oneTBB assertion mechanism to avoid possible leaking of user directory paths.
  • Fixed crash in resumable tasks on ARM-based macOS.
  • Fixed compilation failures:

Open-source Contributions Integrated

New in 2021.2 Release

New Features

  • Added three-way comparison operators for concurrent ordered containers and concurrent_vector.

Preview Features

  • Extended task_arena constraints to support Intel Hybrid Technology and Intel Hyper-Threading Technology. To enable the feature set TBB_PREVIEW_TASK_ARENA_CONSTRAINTS_EXTENSION to 1.

Known Limitations

  • An application using Parallel STL algorithms in libstdc++ versions 9 and 10 may fail to compile due to incompatible interface changes between earlier versions of Threading Building Blocks (TBB) and oneAPI Threading Building Blocks (oneTBB). Disable support for Parallel STL algorithms by defining PSTL_USE_PARALLEL_POLICIES (in libstdc++ 9) or _GLIBCXX_USE_TBB_PAR_BACKEND (in libstdc++  10) macro to zero before inclusion of the first standard header file in each translation unit.
  • On Linux, if oneAPI Threading Building Blocks (oneTBB) or Threading Building Blocks (TBB) has been installed to a system folder like /usr/lib64, the application may fail to link due to the linker search order for libraries. Use the -L linker option to specify the correct location of oneTBB libraries. This issue does not affect program execution.
  • The oneapi::tbb::info namespace interfaces might unexpectedly change the process affinity mask on Windows systems (see https://github.com/open-mpi/hwloc/issues/366 for details).

Fixed Issues

New in 2021.1 Release

Changes affecting backward compatibility

New Features

  • Concurrent ordered containers, task_arena interface extension for NUMA, flow graph API to support relative priorities for functional nodes and resumable tasks are fully supported now.
  • Added the terminate_on_exception property for global_control to prevent exceptions from the oneTBB library and terminate the library instead of throwing an exception.
  • Reworked error handling for thread creation API to throw an exception to report an error. Inspired by Andrey Semashev (https://github.com/oneapi-src/oneTBB/issues/255).
  • Upgraded the oneTBB Python module from Python2 to Python3. Inspired by Eisuke Kawashima (https://github.com/oneapi-src/oneTBB/pull/240).
  • Implemented task_arena interface extension to specify priority of the arena.

Preview Features

  • Introduced the task_scheduler_handler class as a replacement for blocking terminate extension of the task_scheduler_init class.

Known Limitations

  • An application using Parallel STL algorithms in libstdc++ versions 9 and 10 may fail to compile due to incompatible interface changes between earlier versions of Threading Building Blocks (TBB) and oneAPI Threading Building Blocks (oneTBB). Disable support for Parallel STL algorithms by defining PSTL_USE_PARALLEL_POLICIES (in libstdc++ 9) or _GLIBCXX_USE_TBB_PAR_BACKEND (in libstdc++  10) macro to zero before inclusion of the first standard header file in each translation unit.
  • On Linux, if oneAPI Threading Building Blocks (oneTBB) or Threading Building Blocks (TBB) has been installed to a system folder like /usr/lib64, the application may fail to link due to the linker search order for libraries. Use the -L linker option to specify the correct location of oneTBB libraries. This issue does not affect program execution.

Fixed Issues

 

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.

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.

 

Product and Performance Information

1

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