New doc

2021-08-31 11:13:53 +05:00
315 changed files with 5071 additions and 6251 deletions
@@ -16,4 +16,4 @@
 # use Bazel internally. The Bazel build can have security risks or 
 # optimization gaps.

-build --symlink_prefix=/ # Out of source build
+build --symlink_prefix=/ # Out of source build
@@ -1 +1 @@
-5.0.0
+4.1.0
@@ -1,40 +0,0 @@
-### Description 
-_Add a comprehensive description of proposed changes_
-
-
-Fixes # - _issue number(s) if exists_
-
- [ ] - git commit message contains an appropriate signed-off-by string _(see [CONTRIBUTING.md](https://github.com/oneapi-src/oneTBB/blob/master/CONTRIBUTING.md#pull-requests) for details)_
-
-### Type of change
-
-_Choose one or multiple, leave empty if none of the other choices apply_
-
-_Add a respective label(s) to PR if you have permissions_
-
- [ ] bug fix - _change that fixes an issue_
- [ ] new feature - _change that adds functionality_
- [ ] tests - _change in tests_
- [ ] infrastructure - _change in infrastructure and CI_
- [ ] documentation - _documentation update_
-
-### Tests
-
- [ ] added - _required for new features and some bug fixes_
- [ ] not needed
-
-### Documentation
-
- [ ] updated in # - _add PR number_
- [ ] needs to be updated
- [ ] not needed
-
-### Breaks backward compatibility
- [ ] Yes
- [ ] No
- [ ] Unknown
-
-### Notify the following users
-_List users with `@` to send notifications_
-
-### Other information
@@ -1,4 +1,4 @@
-# Copyright (c) 2021-2022 Intel Corporation
+# Copyright (c) 2021 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -48,9 +48,8 @@ jobs:
      - uses: actions/checkout@v2
      - name: Run scan
        run: |
-          command -v clang-format-10
          cp -r examples examples_formatted
-          find examples_formatted -regex '.*\.\(cpp\|hpp\)' -exec clang-format-10 -style=file -i {} \;
+          find examples_formatted -regex '.*\.\(cpp\|hpp\)' -exec clang-format-9 -style=file -i {} \;
          diff -r examples examples_formatted

  documentation:
@@ -63,13 +62,12 @@ jobs:
      - uses: actions/checkout@v2
      - name: Install prerequisites
        run: |
-          pip3 install -U Jinja2
          pip3 install git+https://github.com/executablebooks/sphinx-book-theme.git
          echo GITHUB_SHA_SHORT=${GITHUB_SHA::8} >> $GITHUB_ENV
          mkdir html
      - name: Build documentation
        run: |
-          export BUILD_TYPE=${BUILD_TYPE} && sphinx-build doc html
+          export BUILD_TYPE=${BUILD_TYPE} && sphinx-build doc/main html
          tar -czvf html.tar.gz html/
      - name: Save docs
        uses: actions/upload-artifact@v2.2.1
@@ -106,26 +104,6 @@ jobs:
          git commit --reset-author --amend -m "Update from GitHub Actions"
          git push --force origin gh-pages

-  copyright_check:
-    if: ${{ github.ref != 'refs/heads/master' }}
-    runs-on: [ubuntu-20.04]
-    steps:
-      - uses: actions/checkout@v2
-        with:
-          fetch-depth: 0
-      - name: Run check
-        run: |
-          sed -i \
-            -e "/Copyright (c) .* Intel Corporation/s/ \([0-9]\+\)[-0-9]*/ \\1-$(date +%Y)/" \
-            -e "/Copyright (c) .* Intel Corporation/s/$(date +%Y)-$(date +%Y)/$(date +%Y)/" \
-            $(git diff --diff-filter=d --name-only ${{ github.event.pull_request.base.sha }})
-          git checkout -- third-party-programs.txt
-          git diff > years.diff
-          if [[ -s years.diff ]]; then
-            echo "Wrong copyright years"
-            cat years.diff
-            exit 1
-          fi
  python_module_test_ubuntu18-04:
    runs-on: [ubuntu-18.04]
    timeout-minutes: 15
@@ -210,22 +188,22 @@ jobs:
      fail-fast: false
      matrix:
        include:
-          - os: windows-2019
-            generator: Visual Studio 16 2019
+          - os: windows-2016
+            generator: Visual Studio 15 2017
            c_compiler: cl
            cxx_compiler: cl
            std: 14
            build_type: relwithdebinfo
            preview: 'ON'
-            job_name: windows_cl2019_cxx14_relwithdebinfo_preview=ON
-          - os: windows-2022
-            generator: Visual Studio 17 2022
+            job_name: windows_cl2017_cxx14_relwithdebinfo_preview=ON
+          - os: windows-2019
+            generator: Visual Studio 16 2019
            c_compiler: cl
            cxx_compiler: cl
            std: 17
            build_type: relwithdebinfo
            preview: 'OFF'
-            job_name: windows_cl2022_cxx17_relwithdebinfo_preview=OFF
+            job_name: windows_cl2019_cxx17_relwithdebinfo_preview=OFF
    steps:
      - uses: actions/checkout@v2
      - name: Run testing
@@ -310,22 +288,22 @@ jobs:
      fail-fast: false
      matrix:
        include:
-          - os: windows-2019
-            generator: Visual Studio 16 2019
+          - os: windows-2016
+            generator: Visual Studio 15 2017
            c_compiler: cl
            cxx_compiler: cl
            std: 14
            build_type: relwithdebinfo
            preview: 'ON'
-            job_name: examples_windows_cl2019_cxx14_relwithdebinfo_preview=ON
-          - os: windows-2022
-            generator: Visual Studio 17 2022
+            job_name: examples_windows_cl2017_cxx14_relwithdebinfo_preview=ON
+          - os: windows-2019
+            generator: Visual Studio 16 2019
            c_compiler: cl
            cxx_compiler: cl
            std: 17
            build_type: relwithdebinfo
            preview: 'OFF'
-            job_name: examples_windows_cl2022_cxx17_relwithdebinfo_preview=OFF
+            job_name: examples_windows_cl2019_cxx17_relwithdebinfo_preview=OFF
    steps:
      - uses: actions/checkout@v2
      - name: Run testing
@@ -1,4 +1,4 @@
-# Copyright (c) 2021-2022 Intel Corporation
+# Copyright (c) 2021 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -35,20 +35,15 @@ cc_library(
        "include/oneapi/tbb/*.h",
        "include/oneapi/tbb/detail/*.h",
    ]),
-    copts = ["-w"] + select({
-        "@bazel_tools//platforms:windows": [""],
-        "//conditions:default": ["-mwaitpkg"],
-    }),
+    copts = [
+        "-w",
+    ],
    defines =
        select({
            "@platforms//cpu:x86_64": ["__TBB_NO_IMPLICIT_LINKAGE"],
            "//conditions:default": [
                "USE_PTHREAD",
            ],
-        }) +
-        select({
-            "@bazel_tools//platforms:osx": ["_XOPEN_SOURCE"],
-            "//conditions:default": [],
        }),
    includes = [
        "include",
@@ -56,12 +51,11 @@ cc_library(
    linkopts =
        select({
            "@bazel_tools//platforms:windows": [],
-            "@bazel_tools//platforms:linux": [
+            "//conditions:default": [
                "-ldl",
                "-pthread",
                "-lrt",
            ],
-            "//conditions:default": ["-pthread"],
        }),
    local_defines = select({
        "@platforms//cpu:x86_64": [
@@ -1,38 +1,24 @@
-# Bazel* build support
+# Bazel build support

-The main build system of oneTBB is CMake*.
-[Bazel*](https://bazel.build/) support is community-based.
-The Bazel configuration may not include recommended compiler and/or linker flags used in the official CMake configuration.
+The main build system of oneTBB is CMake.
+Bazel support is community-based.
+The maintainers do not use Bazel internally.
+The Bazel configuration may not include recommended compiler and linker flags used in official CMake configuration.

---
-**NOTE**
+The Bazel build of oneTBB currently only aims for a subset of oneTBB that suffices restricted use cases of the usage of oneTBB.
+Pull requests to improve the Bazel build experience are welcomed.

-Bazel is not recommended for use by oneTBB maintainers. Thus, it is not used internally. 
+The standard approach of how Bazel handles third-party libraries is static linking. 
+Even this is not recommended by the oneTBB maintainers this is chosen since this is considered as the best practice in the Bazel ecosystem.

---
+## Example usage

+1. [Install Bazel](https://docs.bazel.build/versions/main/install.html).

-The Bazel oneTBB build is currently only intended for a subset of oneTBB that suffices restricted use cases.
-Pull requests to improve the Bazel build experience are welcome.
-
-The standard Bazel approach to handling third-party libraries is static linking. It is the best practice within the Bazel ecosystem.
-
-## Using oneTBB as a dependency
-
-This example demonstrates how to use oneTBB as a dependency within a Bazel project.
-
-The following file structure is assumed:
-
-```
-example
-├── .bazelrc
-├── BUILD.bazel
-├── main.cpp
-└── WORKSPACE.bazel
-```
+2. Create the following files in one folder (this folder will be considered as the workspace folder):

 _WORKSPACE.bazel_:
-```python
+```
 load("@bazel_tools//tools/build_defs/repo:git.bzl", "git_repository")

 git_repository(
@@ -42,11 +28,8 @@ git_repository(
 )
 ```

-In the *WORKSPACE* file, the oneTBB GitHub* repository is fetched. 
-
-_BUILD.bazel_:
-
-```python
+_BUILD_:
+```
 cc_binary(
    name = "Demo",
    srcs = ["main.cpp"],
@@ -54,11 +37,8 @@ cc_binary(
 )
 ```

-The *BUILD* file defines a binary named `Demo` that has a dependency to oneTBB.
-
 _main.cpp_:
-
-```c++
+```
 #include "oneapi/tbb/version.h"

 #include <iostream>
@@ -74,23 +54,7 @@ int main() {
 }
 ```

-The expected output of this program is the current version of oneTBB.
+3. Switch to the folder where you create the files.

-Switch to the folder with the files created earlier and run the binary with `bazel run //:Demo`.
-
-## Build oneTBB using Bazel
-
-Run ```bazel build //...``` in the oneTBB root directory.
-
-## Compiler support
-
-The Bazel build uses the compiler flag `-mwaitpkg` in non-Windows* builds.
-This flag is supported by the GNU* Compiler Collection (GCC) version 9.3, Clang* 12, and newer versions of those tools.
-
-
---
-**NOTE**
-
-To use the Bazel build with earlier versions of GCC, remove `-mwaitpkg` flag as it leads to errors during compilation.
-
---
+4. Execute the command `bazel run //:Demo`.
+As an expected output, you should see the oneTBB version.
@@ -1,4 +1,4 @@
-# Copyright (c) 2020-2022 Intel Corporation
+# Copyright (c) 2020-2021 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -60,7 +60,6 @@ unset(_tbb_ver_minor)

 include(CheckCXXCompilerFlag)
 include(GNUInstallDirs)
-include(CMakeDependentOption)

 # ---------------------------------------------------------------------------------------------------------
 # Handle C++ standard version.
@@ -101,11 +100,9 @@ option(TBB_NO_APPCONTAINER "Apply /APPCONTAINER:NO (for testing binaries for Win
 option(TBB4PY_BUILD "Enable tbb4py build" OFF)
 option(TBB_BUILD "Enable tbb build" ON)
 option(TBBMALLOC_BUILD "Enable tbbmalloc build" ON)
-cmake_dependent_option(TBBMALLOC_PROXY_BUILD "Enable tbbmalloc_proxy build" ON "TBBMALLOC_BUILD" OFF)
 option(TBB_CPF "Enable preview features of the library" OFF)
 option(TBB_FIND_PACKAGE "Enable search for external oneTBB using find_package instead of build from sources" OFF)
 option(TBB_DISABLE_HWLOC_AUTOMATIC_SEARCH "Disable HWLOC automatic search by pkg-config tool" OFF)
-option(TBB_ENABLE_IPO "Enable Interprocedural Optimization (IPO) during the compilation" ON)

 if (NOT DEFINED BUILD_SHARED_LIBS)
    set(BUILD_SHARED_LIBS ON)
@@ -184,22 +181,6 @@ foreach(FILE_WITH_EXTRA_TARGETS ${FILES_WITH_EXTRA_TARGETS})
    include(${FILE_WITH_EXTRA_TARGETS})
 endforeach()

-# - Enabling LTO on Android causes the NDK bug.
-#   NDK throws the warning: "argument unused during compilation: '-Wa,--noexecstack'"
-# - For some reason GCC does not instrument code with Thread Sanitizer when lto is enabled and C linker is used.
-if (TBB_ENABLE_IPO AND BUILD_SHARED_LIBS AND NOT ANDROID_PLATFORM AND NOT TBB_SANITIZE MATCHES "thread")
-    if (NOT CMAKE_VERSION VERSION_LESS 3.9)
-        cmake_policy(SET CMP0069 NEW)
-        include(CheckIPOSupported)
-        check_ipo_supported(RESULT TBB_IPO_PROPERTY)
-    else()
-        set(TBB_IPO_FLAGS TRUE)
-    endif()
-    if (TBB_IPO_PROPERTY OR TBB_IPO_FLAGS)
-        message(STATUS "IPO enabled")
-    endif()
-endif()
-
 set(TBB_COMPILER_SETTINGS_FILE ${CMAKE_CURRENT_SOURCE_DIR}/cmake/compilers/${CMAKE_CXX_COMPILER_ID}.cmake)
 if (EXISTS ${TBB_COMPILER_SETTINGS_FILE})
    include(${TBB_COMPILER_SETTINGS_FILE})
@@ -219,11 +200,9 @@ else()
    if (NOT "${CMAKE_SYSTEM_PROCESSOR}" MATCHES "mips")
        if (TBBMALLOC_BUILD)
            add_subdirectory(src/tbbmalloc)
-            if(TBBMALLOC_PROXY_BUILD AND NOT "${MSVC_CXX_ARCHITECTURE_ID}" MATCHES "ARM64")
-                add_subdirectory(src/tbbmalloc_proxy)
-            endif()
+            add_subdirectory(src/tbbmalloc_proxy)
        endif()
-        if (APPLE OR NOT BUILD_SHARED_LIBS)
+        if (APPLE)
            message(STATUS "TBBBind build targets are disabled due to unsupported environment")
        else()
            add_subdirectory(src/tbbbind)
@@ -278,7 +257,7 @@ if (TBB_BENCH)
 endif()

 if (ANDROID_PLATFORM)
-    if ("${ANDROID_STL}" STREQUAL "c++_shared")
+    if (${ANDROID_STL} STREQUAL "c++_shared")
        configure_file(
        "${ANDROID_NDK}/sources/cxx-stl/llvm-libc++/libs/${ANDROID_ABI}/libc++_shared.so"
        "${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/libc++_shared.so"
@@ -38,21 +38,18 @@ You can use issues to report a problem, make a feature request, or add comments

 You can find all [open oneTBB pull requests](https://github.com/oneapi-src/oneTBB/pulls) on GitHub. 

-No anonymous contributions are accepted. The name in the commit message Signed-off-by line and your email must match the change authorship information.  Make sure your .gitconfig is set up correctly so you can use `git commit -s` for signing your patches: 
+No anonymous contributions are accepted. The name in the commit message Signed-of-by line and your email must match the change authorship information.  Make sure your .gitconfig is set up correctly so you can use `git commit -s` for signing your patches: 

 `git config --global user.name "Taylor Developer"`

 `git config --global user.email taylor.developer@company.com`
 
-### Before contributing changes directly to the oneTBB repository
+
+Before contributing changes directly to the oneTBB repository: 

 * Make sure you can build the product and run all the tests with your patch. 
 * For a larger feature, provide a relevant test. 
 * Document your code. The oneTBB project uses reStructuredText for documentation.  
-* Update the copyright year in the first line of the changing file(s). 
-  For example, if you commit your changes in 2022:
-  * the copyright year should be `2005-2022` for existing files
-  * the copyright year should be `2022` for new files
 * Submit a pull request into the master branch. You can submit changes with a pull request (preferred) or by sending an email patch.  

 Continuous Integration (CI) testing is enabled for the repository. Your pull request must pass all checks before it can be merged. We will review your contribution and may provide feedback to guide you if any additional fixes or modifications are necessary. When reviewed and accepted, your pull request will be merged into our GitHub repository. 
@@ -1,122 +1,34 @@
 # Installation from Sources

+Required Software:
+* DPC++/C++ Compiler
+* Microsoft* Visual Studio* (Windows* OS only)
+* GNU Compilers (gcc) 4.8.5–10
+* GNU C Library (glibc) version 2.17–2.32
+* Clang* 4.2–11.0

-## Prerequisites 
-   
-   - Make sure you have installed CMake version 3.1 (or newer) on your system. oneTBB uses CMake build configuration.
-   - Configure and build oneTBB. To work with build configurations, see [Build System Description](cmake/README.md). 
+The project uses CMake build configuration. Make sure that you have CMake version 3.1 or higher. 

+Before installing the library, learn how to [configure, build, and test](cmake\README.md) the project. 

-## Configure oneTBB
+NOTE: Be careful about installation. Avoid commands like `make install` unless you fully understand the consequences.

-At the command prompt, type:
-```
-cmake <options> <repo_root>
-```
+The following installation components are supported:

-You may want to use some additional options for configuration:
+`runtime` - oneTBB runtime package (core shared libraries and .dll files on Windows).
+`devel` - oneTBB development package (header files, CMake integration files, library symbolic links, and .lib files on Windows).
+`tbb4py` - oneTBB Module for Python.

-| Option                    | Purpose                   | Description                                                                        |
-| ------                    |------                     | ------                                                                             |
-| `-G <generator>`          | Specify project generator | For more information, run cmake `–help`.                                           |
-|`-DCMAKE_BUILD_TYPE=Debug` | Specify for Debug build   | Not applicable for multi-configuration generators such as Visual Studio generator. |
-
-
-## Build oneTBB
- 
-To build the system, run:
-```
-cmake --build . <options>
-```
-
-Some useful build options:
- `--target <target>` - specific target, "all" is default.
-	`--config <Release|Debug>` - build configuration, applicable only for multi-config generators such as Visual Studio generator.
-
-
-## Install and Pack oneTBB
-
---
-**NOTE**
-
-Be careful about installing prefix. It defaults to `/usr/local` on UNIX* and `c:/Program Files/${PROJECT_NAME}` on Windows* OS.
-You can define custom `CMAKE_INSTALL_PREFIX` during configuration:
-
-```
-cmake -DCMAKE_INSTALL_PREFIX=/my/install/prefix ..
-```
-
---
-
-Installation can also be done using:
-
-```
-cmake --install <project-binary-dir>
-```
-
-Special ``--install`` target can alternatively be used for installation, e.g. ``make install``.
-
-You can use the ``install`` components for partial installation.
-
-The following install components are supported:
- `runtime` - oneTBB runtime package (core shared libraries and `.dll` files on Windows* OS).
- `devel` - oneTBB development package (header files, CMake integration files, library symbolic links, and `.lib` files on Windows* OS).
- `tbb4py` - [oneTBB Module for Python](#onetbb-python-module-support).
-
-If you want to install specific components after configuration and build, run:
+To install the specific components after configuration and build, run:

 ```bash
 cmake -DCOMPONENT=<component> [-DBUILD_TYPE=<build-type>] -P cmake_install.cmake
 ```

 Simple packaging using CPack is supported.
-The following commands allow you to create a simple portable package that includes header files, libraries, and integration files for CMake:
+The following commands allow to create a simple portable package that includes header files, libraries, and integration files for CMake:

 ```bash
 cmake <options> ..
 cpack
 ```
-
-## Example of Installation
-
-### Single-configuration generators
-
-The following example demonstrates how to install oneTBB for single-configuration generators (e.g. GNU Make, Ninja, etc.).
-```bash
-# Do our experiments in /tmp
-cd /tmp
-# Clone oneTBB repository
-git clone https://github.com/oneapi-src/oneTBB.git
-cd oneTBB
-# Create binary directory for out-of-source build
-mkdir build && cd build
-# Configure: customize CMAKE_INSTALL_PREFIX and disable TBB_TEST to avoid tests build
-cmake -DCMAKE_INSTALL_PREFIX=/tmp/my_installed_onetbb -DTBB_TEST=OFF ..
-# Build
-cmake --build .
-# Install
-cmake --install .
-# Well done! Your installed oneTBB is in /tmp/my_installed_onetbb
-```
-
-### Multi-configuration generators
-
-The following example demonstrates how to install oneTBB for multi-configuration generators such as Visual Studio*. 
-
-Choose the configuration during the build and install steps:
-```batch
-REM Do our experiments in %TMP%
-cd %TMP%
-REM Clone oneTBB repository
-git clone https://github.com/oneapi-src/oneTBB.git
-cd oneTBB
-REM Create binary directory for out-of-source build
-mkdir build && cd build
-REM Configure: customize CMAKE_INSTALL_PREFIX and disable TBB_TEST to avoid tests build
-cmake -DCMAKE_INSTALL_PREFIX=%TMP%\my_installed_onetbb -DTBB_TEST=OFF ..
-REM Build "release with debug information" configuration 
-cmake --build . --config relwithdebinfo
-REM Install "release with debug information" configuration 
-cmake --install . --config relwithdebinfo
-REM Well done! Your installed oneTBB is in %TMP%\my_installed_onetbb
-```
@@ -1,53 +1,34 @@
 # oneAPI Threading Building Blocks
 [![Apache License Version 2.0](https://img.shields.io/badge/license-Apache_2.0-green.svg)](LICENSE.txt) [![oneTBB CI](https://github.com/oneapi-src/oneTBB/actions/workflows/ci.yml/badge.svg)](https://github.com/oneapi-src/oneTBB/actions/workflows/ci.yml?query=branch%3Amaster)

-oneTBB is a flexible C++ library that simplifies the work of adding parallelism
-to complex applications, even if you are not a threading expert.  
+oneAPI Threading Building Blocks (oneTBB) lets you easily write parallel C++ programs that take
+full advantage of multicore performance that are portable, composable, and have future-proof scalability.

-The library lets you easily write parallel programs that take full advantage of the multi-core performance. Such programs are portable, 
-composable and have a future-proof scalability. oneTBB provides you with functions, interfaces, and classes to parallelize and scale the code.
-All you have to do is to use the templates. 
-
-The library differs from typical threading packages in the following ways:
-* oneTBB enables you to specify logical parallelism instead of threads.
-* oneTBB targets threading for performance.
-* oneTBB is compatible with other threading packages.
-* oneTBB emphasizes scalable, data parallel programming.
-* oneTBB relies on generic programming.
-
-
-Refer to oneTBB [examples](examples) and [samples](https://github.com/oneapi-src/oneAPI-samples/tree/master/Libraries/oneTBB) to see how you can use the library.
-
-oneTBB is a part of [oneAPI](https://oneapi.io). The current branch implements version 1.1 of oneAPI Specification.
-
-## Release Information
-Here are [Release Notes](RELEASE_NOTES.md) and [System Requirements](SYSTEM_REQUIREMENTS.md).
+## Installation
+You can install oneTBB from [GitHub*](https://github.com/oneapi-src/oneTBB/releases).
+See [Installation from Sources](INSTALL.md) for details.

 ## Documentation
 * [oneTBB Specification](https://spec.oneapi.com/versions/latest/elements/oneTBB/source/nested-index.html)
-* [oneTBB Developer Guide and Reference](https://oneapi-src.github.io/oneTBB)
-* [Migrating from TBB to oneTBB](https://oneapi-src.github.io/oneTBB/main/tbb_userguide/Migration_Guide.html)
-* [README for the CMake build system](cmake/README.md)
+* [oneTBB Developer Guide and Reference](https://oneapi-src.github.io/oneTBB/)
+* [Migrating from TBB to oneTBB](https://oneapi-src.github.io/oneTBB/tbb_userguide/Migration_Guide.html)
+* [README for build system](cmake/README.md)
 * [Basic support for the Bazel build system](Bazel.md)
-* [oneTBB Discussions](https://github.com/oneapi-src/oneTBB/discussions)
-
-## Installation 
-See [Installation from Sources](INSTALL.md) to learn how to install oneTBB. 

 ## Support
-Please report issues and suggestions via [GitHub issues](https://github.com/oneapi-src/oneTBB/issues). See our [documentation](./CONTRIBUTING.md##Issues) to learn how to work with them.
+Please report issues and suggestions via
+[GitHub issues](https://github.com/oneapi-src/oneTBB/issues).

 ## How to Contribute
-We welcome community contributions, so check our [Contributing Guidelines](CONTRIBUTING.md)
+We welcome community contributions, so check our [contributing guidelines](CONTRIBUTING.md)
 to learn more.

 ## License
 oneAPI Threading Building Blocks is licensed under [Apache License, Version 2.0](LICENSE.txt).
 By its terms, contributions submitted to the project are also done under that license.

-
 ## Engineering team contacts
-* [Email us.](mailto:inteltbbdevelopers@intel.com)
+* [E-mail us.](mailto:inteltbbdevelopers@intel.com)

 ------------------------------------------------------------------------
 \* All names and brands may be claimed as the property of others.
@@ -1,53 +0,0 @@
-<!--
-******************************************************************************
-* 
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*******************************************************************************/-->
-
-# Release Notes <!-- omit in toc -->
-This document contains changes of oneTBB compared to the last release.
-
-## Table of Contents <!-- omit in toc -->
- [New Features](#new_features)
- [Known Limitations](#known-limitations)
- [Fixed Issues](#fixed-issues)
- [Open-source Contributions Integrated](#open-source-contributions-integrated)
-
-## :white_check_mark: 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.
-
-## :rotating_light: 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).
-
-## :hammer: Fixed Issues
- Memory allocator crash on a system with an incomplete /proc/meminfo (GitHub* [#584](https://github.com/oneapi-src/oneTBB/issues/584)).
- Incorrect blocking of task stealing (GitHub* #[478](https://github.com/oneapi-src/oneTBB/issues/478)).
- Hang due to incorrect decrement of a limiter_node (GitHub* [#634](https://github.com/oneapi-src/oneTBB/issues/634)).
- Memory corruption in some rare cases when passing big messages in a flow graph (GitHub* [#639](https://github.com/oneapi-src/oneTBB/issues/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](https://github.com/oneapi-src/oneTBB/issues/420)).
- Crash when obtaining a range from empty ordered and unordered containers (GitHub* [#641](https://github.com/oneapi-src/oneTBB/issues/641)).
- Deadlock in a concurrent_vector resize() that could happen when the new size is less than the previous size (GitHub* [#733](https://github.com/oneapi-src/oneTBB/issues/733)).
-
-## :octocat: Open-source Contributions Integrated
- Improved aligned memory allocation. Contributed by Andrey Semashev (https://github.com/oneapi-src/oneTBB/pull/671).
- Optimized usage of atomic_fence on IA-32 and Intel(R) 64 architectures. Contributed by Andrey Semashev (https://github.com/oneapi-src/oneTBB/pull/328).
- Fixed incorrect definition of the assignment operator in containers. Contributed by Andrey Semashev (https://github.com/oneapi-src/oneTBB/issues/372).
@@ -1,65 +0,0 @@
-<!--
-******************************************************************************
-* 
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*******************************************************************************/-->
-
-# System Requirements <!-- omit in toc -->
-This document provides details about hardware, operating system, and software prerequisites for the oneAPI Threading Building Blocks (oneTBB). 
-
-## Table of Contents <!-- omit in toc -->
- [Supported Hardware](#supported-hardware)
- [Software](#software)
-  - [Supported Operating Systems](#supported-operating-systems)
-  - [Supported Compilers](#supported-compilers)
-
-
-## Supported Hardware
- Intel(R) Celeron(R) processor family
- Intel(R) Core* processor family
- Intel(R) Xeon(R) processor family
- Intel(R) Xeon Phi* processor family
- Intel(R) Atom* processor family
- Non-Intel(R) processors compatible with the processors listed above
-
-
-## Software
-
-### Supported Operating Systems
- Systems with Microsoft* Windows* operating systems
-  - Microsoft* Windows* 10
-  - Microsoft* Windows* Server 2016
-  - Microsoft* Windows* Server 2019
- Systems with Linux* operating systems
-  - Clear Linux*
-  - Amazon* Linux 2
-  - CentOS* 8
-  - Debian* 10
-  - Fedora* 34
-  - Red Hat* Enterprise Linux* 7, 8
-  - SuSE* Linux* Enterprise Server 15
-  - Ubuntu* 18.04 LTS, 20.04, 21.04, 22.04
- Systems with macOS* operating systems
-  - macOS* 10.15, 11.x
- Systems with Android* operating systems
-  - Android* 9
-
-### Supported Compilers
- Intel* oneAPI DPC++/C++ Compiler
- Intel* C++ Compiler 19.0 and 19.1 version
- Microsoft* Visual C++ 14.1 (Microsoft* Visual Studio* 2017, Windows* OS only)
- Microsoft* Visual C++ 14.2 (Microsoft* Visual Studio* 2019, Windows* OS only)
- For each supported Linux* operating system, the standard gcc version provided with that operating system is supported
-  - GNU Compilers (gcc) 4.8.5 - 11.1.1
-  - GNU C Library (glibc) version 2.17 - 2.33
-  - Clang* 6.0.0 - 12.0.0
@@ -16,4 +16,4 @@
 # use Bazel internally. The Bazel build can have security risks or 
 # optimization gaps.

-workspace(name = "oneTBB")
+workspace(name = "oneTBB")
@@ -11,20 +11,22 @@ TBB_SIGNTOOL:FILEPATH - Tool for digital signing, used in post install step for
 TBB_SIGNTOOL_ARGS:STRING - Additional arguments for TBB_SIGNTOOL, used if TBB_SIGNTOOL is set.
 TBB_BUILD:BOOL - Enable Intel(R) oneAPI Threading Building Blocks (oneTBB) build (ON by default)
 TBBMALLOC_BUILD:BOOL - Enable Intel(R) oneAPI Threading Building Blocks (oneTBB) memory allocator build (ON by default)
-TBBMALLOC_PROXY_BUILD:BOOL - Enable Intel(R) oneAPI Threading Building Blocks (oneTBB) memory allocator proxy build (requires TBBMALLOC_BUILD. ON by default)
 TBB4PY_BUILD:BOOL - Enable Intel(R) oneAPI Threading Building Blocks (oneTBB) Python module build (OFF by default)
 TBB_CPF:BOOL - Enable preview features of the library (OFF by default)
 TBB_INSTALL_VARS:BOOL - Enable auto-generated vars installation(packages generated by `cpack` and `make install` will also include the vars script)(OFF by default)
 TBB_VALGRIND_MEMCHECK:BOOL - Enable scan for memory leaks using Valgrind (OFF by default)
 TBB_DISABLE_HWLOC_AUTOMATIC_SEARCH - Disable HWLOC automatic search by pkg-config tool (OFF by default)
-TBB_ENABLE_IPO - Enable Interprocedural Optimization (IPO) during the compilation (ON by default)
 ```

-## Configure, build, and test
+## Configure, build and test
+
+### Prerequisites
+
+*  CMake >= 3.1

 ### Preparation

-To perform out-of-source build, create a build directory and go there:
+In order to perform out-of-source build you have to create a build directory and go there:

 ```bash
 mkdir /tmp/my-build
@@ -38,46 +40,29 @@ cmake <options> <repo_root>
 ```

 Some useful options:
- `-G <generator>` - specify particular project generator. See `cmake --help` for details.
- `-DCMAKE_BUILD_TYPE=Debug` - specify for Debug build. It is not applicable for multiconfig generators, e.g. for Visual Studio* generator.
+- `-G <generator>` - specify particular project generator, see `cmake --help` for details.
+- `-DCMAKE_BUILD_TYPE=Debug` - specify for Debug build, it isn't applicable for multi-config generators, e.g. for Visual Studio generator).

 #### TBBBind library configuration

-The TBBbind library has three versions: `tbbbind`, `tbbbind_2_0`, and `tbbbind_2_5`. Each of these versions is linked with corresponding HWLOC library version: 
- `tbbbind` links with HWLOC 1.11.x 
- `tbbbind_2_0` links with HWLOC 2.1–2.4
- `tbbbind_2_5` links with HWLOC 2.5 and later
+The TBBbind library has three versions: `tbbbind`, `tbbbind_2_0` and `tbbbind_2_5`. Each of these versions is linked with corresponding HWLOC library version: `tbbbind` links with HWLOC 1.11.x , `tbbbind_2_0` links with HWLOC 2.1-2.4, `tbbbind_2_5` links with HWLOC 2.5 and later.

-The search for a suitable version of the HWLOC library is enabled by default. If you want to use a specific version of the library, you can specify the path to it manually using the following CMake variables:
+The search for a suitable version of the HWLOC library is enabled by default, but if you want to use a specific version of the library, you can specify the path to it manually using the following CMake variables:

- - `CMAKE_HWLOC_<HWLOC_VER>_LIBRARY_PATH` - path to the corresponding HWLOC version shared library on Linux* OS or path to `.lib` file on Windows* OS
- - `CMAKE_HWLOC_<HWLOC_VER>_INCLUDE_PATH` - path to the corresponding HWLOC version including directory
+ - `CMAKE_HWLOC_<HWLOC_VER>_LIBRARY_PATH` - path to the corresponding HWLOC version shared library on Linux or path to `.lib` file on Windows.
+ - `CMAKE_HWLOC_<HWLOC_VER>_INCLUDE_PATH` - path to the corresponding HWLOC version includes directory.

+Automatic HWLOC searching requires CMake >= 3.6.

---
-**NOTE:** Automatic HWLOC searching requires CMake version 3.6 or higher.
-
---
-
-
-Windows* OS requires an additional variable for correct TBBBind library building:
+Windows requires one additional variable for correct TBBBind library building:
 - `CMAKE_HWLOC_<HWLOC_VER>_DLL_PATH` - path to the corresponding HWLOC version `.dll` file.

-`HWLOC_VER` substring used earlier can be replaced with one of the three values:
- `1_11` for the `tbbbind` library configuration
- `2` for the `tbbbind_2_0` library configuration
- `2_5` for the `tbbbind_2_5` library configuration
+`HWLOC_VER` substring used above can be replaced with one of the three values: `1_11` for the `tbbbind` library configuration, `2` for the `tbbbind_2_0`, and `2_5` for the `tbbbind_2_5` library configuration.

-If you specify variables for several TBBBind versions, the building process for all of these versions is performed during single build session.
-
---
-**TIP**
+If you specify variables for several TBBBind versions, then building process for all of these versions will be performed during single build session.

 Specify the `TBB_DISABLE_HWLOC_AUTOMATIC_SEARCH` to disable HWLOC libraries automatic search.

---
-
-
 ### Build

 ```bash
@@ -86,27 +71,20 @@ cmake --build . <options>

 Some useful options:
 - `--target <target>` - specific target, "all" is default.
- `--config <Release|Debug>` - build configuration, applicable only for multiconfig generators, e.g. Visual Studio* generator.
+- `--config <Release|Debug>` - build configuration, applicable only for multi-config generators, e.g. Visual Studio generator.

-The binaries are placed to `./<compiler-id>_<compiler-ver>_cxx<stdver>_<build-type>`. For example, `./gnu_4.8_cxx11_release`.
+Binaries are placed to `./<compiler-id>_<compiler-ver>_cxx<stdver>_<build-type>` (for example, `./gnu_4.8_cxx11_release`)

 #### Build for 32-bit

-* **Intel(R) Compiler**. Source Intel(R) C++ Compiler with `ia32` and build as usual.
-* **MSVC**. Use switch for [generator](https://cmake.org/cmake/help/latest/manual/cmake-generators.7.html) (e.g. `-A Win32` for [VS2019](https://cmake.org/cmake/help/latest/generator/Visual%20Studio%2016%202019.html)) during the configuration stage and then build as usual.
-* **GCC/Clang**. Specify `-m32` during the configuration. It can be `CXXFLAGS=-m32 cmake ..` or `cmake -DCMAKE_CXX_FLAGS=-m32 ..`
-* For any other compiler, which builds for 64-bit by default, specify 32-bit compiler key during the configuration as above.
+* Intel Compiler: just source Intel(R) C++ Compiler with `ia32` and build as usual.
+* MSVC: use switch for [generator](https://cmake.org/cmake/help/latest/manual/cmake-generators.7.html) (e.g. `-A Win32` for [VS2019](https://cmake.org/cmake/help/latest/generator/Visual%20Studio%2016%202019.html)) during the configuration stage and then build as usual.
+* GCC/Clang: specify `-m32` during the configuration: `CXXFLAGS=-m32 cmake ..` or `cmake -DCMAKE_CXX_FLAGS=-m32 ..`
+* Any other compiler which builds for 64-bit by default: specify 32-bit compiler key during the configuration as above.

-#### Windows* OS specific builds
+#### Windows specific builds (CMake 3.15 or newer is required)

---
-**NOTE**
-
-Following builds require CMake version 3.15 or higher. 
-
---
-
-* **Dynamic linkage with C Runtime Library (CRT)**. The default behavior can be explicitly specified by setting `CMAKE_MSVC_RUNTIME_LIBRARY` to `MultiThreadedDLL` or `MultiThreadedDebugDLL`.
+* Dynamic linkage with CRT: default behavior, can be explicitly specified by setting `CMAKE_MSVC_RUNTIME_LIBRARY` to `MultiThreadedDLL` or `MultiThreadedDebugDLL`.
 ```bash
 cmake ..  # dynamic linkage is used by default
 ```
@@ -116,27 +94,20 @@ cmake -DCMAKE_MSVC_RUNTIME_LIBRARY=MultiThreadedDLL ..
 ```bash
 cmake -DCMAKE_MSVC_RUNTIME_LIBRARY=MultiThreadedDebugDLL -DCMAKE_BUILD_TYPE=Debug ..
 ```
-* **Static linkage with CRT**. Set `CMAKE_MSVC_RUNTIME_LIBRARY` to `MultiThreaded` or `MultiThreadedDebug`.
+* Static linkage with CRT: set `CMAKE_MSVC_RUNTIME_LIBRARY` to `MultiThreaded` or `MultiThreadedDebug`.
 ```bash
 cmake -DCMAKE_MSVC_RUNTIME_LIBRARY=MultiThreaded ..
 ```
 ```bash
 cmake -DCMAKE_MSVC_RUNTIME_LIBRARY=MultiThreadedDebug -DCMAKE_BUILD_TYPE=Debug ..
 ```
-* **Windows* OS 10 Universal Windows application build**. Set `CMAKE_SYSTEM_NAME` to `WindowsStore` and `CMAKE_SYSTEM_VERSION` to `10.0`.
-
---
-**NOTE**
-
-Set `TBB_NO_APPCONTAINER` to `ON` in order to apply `/APPCONTAINER:NO` option during the compilation (used for testing).
-
---
+* Windows 10 Universal Windows application build: set `CMAKE_SYSTEM_NAME` to `WindowsStore` and `CMAKE_SYSTEM_VERSION` to `10.0`.

+_Note: set `TBB_NO_APPCONTAINER` to `ON` in order to apply `/APPCONTAINER:NO` option during the compilation (used for testing)._
 ```bash
 cmake -DCMAKE_SYSTEM_NAME:STRING=WindowsStore -DCMAKE_SYSTEM_VERSION:STRING=10.0 ..
 ```
-
-* **Universal Windows* OS Driver build**. Set `TBB_WINDOWS_DRIVER` to `ON` and use static linkage with CRT.
+* Universal Windows Driver build: set `TBB_WINDOWS_DRIVER` to `ON` and use static linkage with CRT (see above).

 ```bash
 cmake -DTBB_WINDOWS_DRIVER=ON -DCMAKE_MSVC_RUNTIME_LIBRARY=MultiThreaded ..
@@ -145,32 +116,29 @@ cmake -DTBB_WINDOWS_DRIVER=ON -DCMAKE_MSVC_RUNTIME_LIBRARY=MultiThreaded ..
 ### Test

 #### Build test
-To build a test, use the default target 'all':
+Using default ('all') target:
 ```
 cmake --build .
 ```

-Or use a specific test target:
+or using specific test target:
 ```
 cmake --build . --target <test> # e.g. test_version
 ```

 #### Run test

-You can run a test by using CTest:
+Using CTest:
 ```bash
 ctest
 ```

-Or by using 'test' target:
+or using 'test' target:
 ```bash
-cmake --build . --target test # currently does not work on Windows* OS
+cmake --build . --target test # currently doesn't work on Windows
 ```

-## Installation
-See [Installation from Sources](../INSTALL.md) to learn how to install oneTBB. 
-
-## Sanitizers - сonfigure, build, and run
+## Sanitizers - сonfigure, build and run

 ```bash
 mkdir build
@@ -180,7 +148,7 @@ make -j
 ctest -V
 ```

-## Valgrind memcheck - configure, build, and run
+## Valgrind memcheck - configure, build and run

 ### Prerequisites
 * Valgrind tool executable
@@ -192,9 +160,7 @@ cmake -DTBB_VALGRIND_MEMCHECK=ON ..
 make -j memcheck-<test name> # or memcheck-all to scan all tests 
 ```

-## Test specification
-
-Use Doxygen to generate oneTBB test specification:
+## Test specification (Doxygen)

 ```bash
 mkdir build
@@ -203,6 +169,29 @@ cmake -DTBB_TEST_SPEC=ON ..
 make test_spec
 ```

+## Intallation and packaging
+
+**NOTE: be careful about installation: avoid commands like `make install` unless you fully understand the consequences.**
+
+The following install components are supported:
+- `runtime` - oneTBB runtime package (core shared libraries and `.dll` files on Windows).
+- `devel` - oneTBB development package (header files, CMake integration files, library symbolic links and `.lib` files on Windows).
+- `tbb4py` - [oneTBB Module for Python](#onetbb-python-module-support).
+
+How to install specific components after configuration and build:
+
+```bash
+cmake -DCOMPONENT=<component> [-DBUILD_TYPE=<build-type>] -P cmake_install.cmake
+```
+
+Simple packaging using CPack is supported.
+The following commands allow to create a simple portable package which includes header files, libraries and integration files for CMake:
+
+```bash
+cmake <options> ..
+cpack
+```
+
 ## TBBConfig - integration of binary packages

 It is a configuration module that is used for integration of prebuilt oneTBB. It consists of two files (TBBConfig.cmake and TBBConfigVersion.cmake) and can be used via [find_package](https://cmake.org/cmake/help/latest/command/find_package.html) function.
@@ -31,9 +31,9 @@ if (NOT TBB_STRICT AND COMMAND tbb_remove_compile_flag)
    tbb_remove_compile_flag(-Werror)
 endif()

-# Enable Intel(R) Transactional Synchronization Extensions (-mrtm) and WAITPKG instructions support (-mwaitpkg) on relevant processors
-if (NOT "${CMAKE_OSX_ARCHITECTURES}" MATCHES "^arm64$" AND CMAKE_SYSTEM_PROCESSOR MATCHES "(x86_64|amd64|AMD64)") # OSX systems are 64-bit only
-    set(TBB_COMMON_COMPILE_FLAGS ${TBB_COMMON_COMPILE_FLAGS} -mrtm $<$<NOT:$<VERSION_LESS:${CMAKE_CXX_COMPILER_VERSION},12.0>>:-mwaitpkg>)
+# Enable Intel(R) Transactional Synchronization Extensions (-mrtm) on relevant processors
+if (NOT "${CMAKE_OSX_ARCHITECTURES}" MATCHES "^arm64$" AND CMAKE_SYSTEM_PROCESSOR MATCHES "(x86_64|AMD64)") # OSX systems are 64-bit only
+    set(TBB_COMMON_COMPILE_FLAGS ${TBB_COMMON_COMPILE_FLAGS} -mrtm)
 endif()

 # TBB malloc settings
@@ -44,7 +44,7 @@ if (NOT TBB_STRICT AND COMMAND tbb_remove_compile_flag)
 endif()

 # Enable Intel(R) Transactional Synchronization Extensions (-mrtm) and WAITPKG instructions support (-mwaitpkg) on relevant processors
-if (CMAKE_SYSTEM_PROCESSOR MATCHES "(AMD64|amd64|i.86|x86)")
+if (CMAKE_SYSTEM_PROCESSOR MATCHES "(x86|AMD64)")
    set(TBB_COMMON_COMPILE_FLAGS ${TBB_COMMON_COMPILE_FLAGS} -mrtm $<$<NOT:$<VERSION_LESS:${CMAKE_CXX_COMPILER_VERSION},12.0>>:-mwaitpkg>)
 endif()

@@ -58,8 +58,12 @@ if (MINGW)
    list(APPEND TBB_COMMON_COMPILE_FLAGS -U__STRICT_ANSI__)
 endif()

-set(TBB_IPO_COMPILE_FLAGS $<$<NOT:$<CONFIG:Debug>>:-flto>)
-set(TBB_IPO_LINK_FLAGS $<$<NOT:$<CONFIG:Debug>>:-flto>)
+# Enabling LTO on Android causes the NDK bug.
+# NDK throws the warning: "argument unused during compilation: '-Wa,--noexecstack'"
+if (NOT ANDROID_PLATFORM AND BUILD_SHARED_LIBS)
+    set(TBB_IPO_COMPILE_FLAGS $<$<NOT:$<CONFIG:Debug>>:-flto>)
+    set(TBB_IPO_LINK_FLAGS $<$<NOT:$<CONFIG:Debug>>:-flto>)
+endif()

 # TBB malloc settings
 set(TBBMALLOC_LIB_COMPILE_FLAGS -fno-rtti -fno-exceptions)
@@ -1,4 +1,4 @@
-# Copyright (c) 2020-2022 Intel Corporation
+# Copyright (c) 2020-2021 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -36,7 +36,7 @@ if (NOT CMAKE_GENERATOR MATCHES "Ninja" AND NOT CMAKE_CXX_DEPENDS_USE_COMPILER)
 endif()

 # Enable Intel(R) Transactional Synchronization Extensions (-mrtm) and WAITPKG instructions support (-mwaitpkg) on relevant processors
-if (CMAKE_SYSTEM_PROCESSOR MATCHES "(AMD64|amd64|i.86|x86)")
+if (CMAKE_SYSTEM_PROCESSOR MATCHES "(x86|AMD64)")
    set(TBB_COMMON_COMPILE_FLAGS ${TBB_COMMON_COMPILE_FLAGS} -mrtm $<$<AND:$<NOT:$<CXX_COMPILER_ID:Intel>>,$<NOT:$<VERSION_LESS:${CMAKE_CXX_COMPILER_VERSION},11.0>>>:-mwaitpkg>)
 endif()

@@ -56,17 +56,18 @@ endif()

 # Workaround for heavy tests and too many symbols in debug (rellocation truncated to fit: R_MIPS_CALL16)
 if ("${CMAKE_SYSTEM_PROCESSOR}" MATCHES "mips")
-    set(TBB_TEST_COMPILE_FLAGS ${TBB_TEST_COMPILE_FLAGS} -DTBB_TEST_LOW_WORKLOAD $<$<CONFIG:DEBUG>:-fPIE -mxgot>)
-    set(TBB_TEST_LINK_FLAGS ${TBB_TEST_LINK_FLAGS} $<$<CONFIG:DEBUG>:-pie>)
+    set(TBB_TEST_COMPILE_FLAGS ${TBB_TEST_COMPILE_FLAGS} -DTBB_TEST_LOW_WORKLOAD $<$<CONFIG:DEBUG>:-mxgot>)
 endif()

-set(TBB_IPO_COMPILE_FLAGS $<$<NOT:$<CONFIG:Debug>>:-flto>)
-set(TBB_IPO_LINK_FLAGS $<$<NOT:$<CONFIG:Debug>>:-flto>)
+if (MINGW)
+    list(APPEND TBB_COMMON_COMPILE_FLAGS -U__STRICT_ANSI__)
+endif()

-
-if (MINGW AND CMAKE_SYSTEM_PROCESSOR MATCHES "i.86")
-    list (APPEND TBB_COMMON_COMPILE_FLAGS -msse2)
-endif ()
+# For some reason GCC does not instrument code with Thread Sanitizer when lto is enabled and C linker is used.
+if (NOT TBB_SANITIZE MATCHES "thread")
+    set(TBB_IPO_COMPILE_FLAGS $<$<NOT:$<CONFIG:Debug>>:-flto>)
+    set(TBB_IPO_LINK_FLAGS $<$<NOT:$<CONFIG:Debug>>:-flto>)
+endif()

 # TBB malloc settings
 set(TBBMALLOC_LIB_COMPILE_FLAGS -fno-rtti -fno-exceptions)
@@ -24,7 +24,7 @@ set(TBB_WARNING_LEVEL $<$<NOT:$<CXX_COMPILER_ID:Intel>>:/W4> $<$<BOOL:${TBB_STRI
 # Warning suppression C4324: structure was padded due to alignment specifier
 set(TBB_WARNING_SUPPRESS /wd4324)

-set(TBB_TEST_COMPILE_FLAGS ${TBB_TEST_COMPILE_FLAGS} /bigobj)
+set(TBB_TEST_COMPILE_FLAGS /bigobj)
 if (MSVC_VERSION LESS_EQUAL 1900)
    # Warning suppression C4503 for VS2015 and earlier:
    # decorated name length exceeded, name was truncated.
@@ -33,7 +33,7 @@ if (MSVC_VERSION LESS_EQUAL 1900)
    set(TBB_TEST_COMPILE_FLAGS ${TBB_TEST_COMPILE_FLAGS} /wd4503)
 endif()
 set(TBB_LIB_COMPILE_FLAGS -D_CRT_SECURE_NO_WARNINGS /GS)
-set(TBB_COMMON_COMPILE_FLAGS /volatile:iso /FS /EHsc)
+set(TBB_COMMON_COMPILE_FLAGS /volatile:iso /FS)

 # Ignore /WX set through add_compile_options() or added to CMAKE_CXX_FLAGS if TBB_STRICT is disabled.
 if (NOT TBB_STRICT AND COMMAND tbb_remove_compile_flag)
@@ -72,15 +72,14 @@ if (TBB_WINDOWS_DRIVER)
 endif()

 if (CMAKE_CXX_COMPILER_ID MATCHES "(Clang|IntelLLVM)")
-    if (CMAKE_SYSTEM_PROCESSOR MATCHES "(x86|AMD64|i.86)")
+    if (CMAKE_SYSTEM_PROCESSOR MATCHES "(x86|AMD64)")
        set(TBB_COMMON_COMPILE_FLAGS ${TBB_COMMON_COMPILE_FLAGS} -mrtm -mwaitpkg)
    endif()
+    set(TBB_OPENMP_NO_LINK_FLAG TRUE)
    set(TBB_IPO_COMPILE_FLAGS $<$<NOT:$<CONFIG:Debug>>:-flto>)
-    set(TBB_IPO_LINK_FLAGS $<$<NOT:$<CONFIG:Debug>>:-flto>)
 else()
    set(TBB_IPO_COMPILE_FLAGS $<$<NOT:$<CONFIG:Debug>>:/GL>)
    set(TBB_IPO_LINK_FLAGS $<$<NOT:$<CONFIG:Debug>>:-LTCG> $<$<NOT:$<CONFIG:Debug>>:-INCREMENTAL:NO>)
 endif()

 set(TBB_OPENMP_FLAG /openmp)
-set(TBB_OPENMP_NO_LINK_FLAG TRUE) # TBB_OPENMP_FLAG will be used only on compilation but not on linkage
@@ -14,7 +14,6 @@

 # Add code signing as post-install step.
 if (DEFINED TBB_SIGNTOOL)
-    file(TO_CMAKE_PATH "${TBB_SIGNTOOL}" TBB_SIGNTOOL)
    install(CODE "
    file(GLOB_RECURSE FILES_TO_SIGN \${CMAKE_INSTALL_PREFIX}/*${CMAKE_SHARED_LIBRARY_SUFFIX})
    execute_process(COMMAND ${TBB_SIGNTOOL} \${FILES_TO_SIGN} ${TBB_SIGNTOOL_ARGS})
@@ -34,9 +34,7 @@ if (NOT ${FLAG_DISPLAY_NAME})
    "please try another compiler or omit TBB_SANITIZE variable")
 endif()

-set(TBB_TESTS_ENVIRONMENT ${TBB_TESTS_ENVIRONMENT}
-    "TSAN_OPTIONS=suppressions=${CMAKE_CURRENT_SOURCE_DIR}/cmake/suppressions/tsan.suppressions"
-    "LSAN_OPTIONS=suppressions=${CMAKE_CURRENT_SOURCE_DIR}/cmake/suppressions/lsan.suppressions")
+set(TBB_TESTS_ENVIRONMENT ${TBB_TESTS_ENVIRONMENT} "LSAN_OPTIONS=suppressions=${CMAKE_CURRENT_SOURCE_DIR}/cmake/suppressions/lsan.suppressions")

 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${TBB_SANITIZE_OPTION}")
 set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${TBB_SANITIZE_OPTION}")
@@ -1,3 +0,0 @@
-# TSAN suppression for known issues.
-# Possible data race during ittnotify initialization. Low impact.
-race:__itt_nullify_all_pointers
@@ -1,4 +1,4 @@
-# Copyright (c) 2020-2022 Intel Corporation
+# Copyright (c) 2020-2021 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -18,7 +18,7 @@ macro(tbb_remove_compile_flag flag)
    set_property(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} PROPERTY COMPILE_OPTIONS ${_tbb_compile_options})
    unset(_tbb_compile_options)
    if (CMAKE_CXX_FLAGS)
-        string(REGEX REPLACE "(^|[ \t\r\n]+)${flag}($|[ \t\r\n]+)" " " CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})
+        string(REGEX REPLACE ${flag} "" CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})
    endif()
 endmacro()

@@ -44,16 +44,3 @@ macro(tbb_install_target target)
                COMPONENT devel)
    endif()
 endmacro()
-
-macro(tbb_handle_ipo target)
-    if (TBB_IPO_PROPERTY)
-        set_target_properties(${target} PROPERTIES INTERPROCEDURAL_OPTIMIZATION TRUE)
-    elseif (TBB_IPO_FLAGS)
-        target_compile_options(${target} PRIVATE ${TBB_IPO_COMPILE_FLAGS})
-        if (COMMAND target_link_options)
-            target_link_options(${target} PRIVATE ${TBB_IPO_LINK_FLAGS})
-        else()
-            target_link_libraries(${target} PRIVATE ${TBB_IPO_LINK_FLAGS})
-        endif()
-    endif()
-endmacro()
@@ -1,48 +0,0 @@
-.. _Before_You_Begin:
-
-Before You Begin
-****************
-
-After installing |short_name|, you need to set the environment variables:
-  
-#. Go to the oneTBB installation directory (``<install_dir>``). By default, ``<install_dir>`` is the following:
-     
-   * On Linux* OS:
-	 
-     * For superusers (root): ``/opt/intel/oneapi``
-     * For ordinary users (non-root): ``$HOME/intel/oneapi``
-     
-   * On Windows* OS:
-
-     * ``<Program Files>\Intel\oneAPI``
-
-#. Set the environment variables, using the script in <install_dir>, by running
-     
-   * On Linux* OS:
-	 
-     ``vars.{sh|csh} in <install_dir>/tbb/latest/env``
-	   
-   * On Windows* OS:
-	 
-     ``vars.bat in <install_dir>/tbb/latest/env``
-
-
-Example
-*******
-
-Below you can find a typical example for a |short_name| algorithm. 
-The sample calculates a sum of all integer numbers from 1 to 100. 
-
-.. code:: cpp
-
-   int sum = oneapi::tbb::parallel_reduce(oneapi::tbb::blocked_range<int>(1,101), 0,
-      [](oneapi::tbb::blocked_range<int> const& r, int init) -> int {
-         for (int v = r.begin(); v != r.end(); v++  ) {
-            init += v;
-         }
-         return init;
-      },
-      [](int lhs, int rhs) -> int {
-         return lhs + rhs;
-      }
-   );
@@ -0,0 +1,262 @@
+# -*- coding: utf-8 -*-
+#
+# Configuration file for the Sphinx documentation builder.
+#
+# This file does only contain a selection of the most common options. For a
+# full list see the documentation:
+# http://www.sphinx-doc.org/en/master/config
+
+# -- Path setup --------------------------------------------------------------
+
+# If extensions (or modules to document with autodoc) are in another directory,
+# add these directories to sys.path here. If the directory is relative to the
+# documentation root, use os.path.abspath to make it absolute, like shown here.
+#
+import os
+# import sys
+# sys.path.insert(0, os.path.abspath('.'))
+
+SOURCE_DIR = os.path.dirname(__file__)
+LATEX_DIR = os.path.join(SOURCE_DIR, '_latex')
+PREAMBLE_FILE = os.path.join(LATEX_DIR, 'preamble.tex')
+TITLE_PAGE_FILE = os.path.join(LATEX_DIR, 'title_page.tex')
+
+BUILD_TYPE = os.getenv("BUILD_TYPE")
+
+# -- Project information -----------------------------------------------------
+
+
+project = u'Intel® oneAPI Threading Building Blocks (oneTBB)'
+copyright = u'2021, Intel Corporation'
+author = u'Intel'
+
+# The short X.Y version
+version = u''
+# The full version, including alpha/beta/rc tags
+release = u''
+
+
+# -- General configuration ---------------------------------------------------
+
+# If your documentation needs a minimal Sphinx version, state it here.
+#
+# needs_sphinx = '1.0'
+
+# Add any Sphinx extension module names here, as strings. They can be
+# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
+# ones.
+extensions = [
+    'sphinx.ext.autodoc',
+    'sphinx.ext.doctest',
+    'sphinx.ext.intersphinx',
+    'sphinx.ext.todo',
+    'sphinx.ext.coverage',
+    'sphinx.ext.imgmath',
+    'sphinx.ext.ifconfig',
+    'sphinx.ext.viewcode',
+    'sphinx.ext.githubpages',
+]
+
+
+# Add any paths that contain templates here, relative to this directory.
+templates_path = ['_templates']
+
+# The suffix(es) of source filenames.
+# You can specify multiple suffix as a list of string:
+#
+# source_suffix = ['.rst', '.md']
+source_suffix = '.rst'
+
+# The master toctree document.
+#master_doc = 'main/title_main'
+master_doc = 'index'
+
+# The language for content autogenerated by Sphinx. Refer to documentation
+# for a list of supported languages.
+#
+# This is also used if you do content translation via gettext catalogs.
+# Usually you set "language" from the command line for these cases.
+language = None
+
+# List of patterns, relative to source directory, that match files and
+# directories to ignore when looking for source files.
+# This pattern also affects html_static_path and html_extra_path.
+exclude_patterns = []
+
+# The name of the Pygments (syntax highlighting) style to use.
+pygments_style = None
+
+# Syntax highlighting for the :: directive
+highlight_language = 'cpp' 
+
+
+rst_prolog = """
+.. |full_name| replace:: Intel\ |reg|\  oneAPI Threading Building Blocks (oneTBB)
+.. |short_name| replace:: oneTBB
+.. |product| replace:: oneTBB
+.. |reg| unicode:: U+000AE
+.. |copy| unicode:: U+000A9
+.. |base_tk| replace:: Intel\ |reg|\  oneAPI Base Toolkit
+.. |dpcpp| replace:: Intel\ |reg|\  oneAPI DPC++/C++ Compiler
+    """
+
+
+# -- Options for HTML output -------------------------------------------------
+
+# The theme to use for HTML and HTML Help pages.  See the documentation for
+# a list of builtin themes.
+#
+# Theme options are theme-specific and customize the look and feel of a theme
+# further.  For a list of options available for each theme, see the
+# documentation.
+#
+html_theme = 'sphinx_book_theme'
+
+# Add any paths that contain custom static files (such as style sheets) here,
+# relative to this directory. They are copied after the builtin static files,
+# so a file named "default.css" will overwrite the builtin "default.css".
+html_static_path = ['_static']
+
+
+
+# Custom sidebar templates, must be a dictionary that maps document names
+# to template names.
+#
+# The default sidebars (for documents that don't match any pattern) are
+# defined by theme itself.  Builtin themes are using these templates by
+# default: ``['localtoc.html', 'relations.html', 'sourcelink.html',
+# 'searchbox.html']``.
+#
+# html_sidebars = {}
+
+
+# -- Options for HTMLHelp output ---------------------------------------------
+
+# Output file base name for HTML help builder.
+htmlhelp_basename = 'sphinx-infodevdoc'
+
+
+# -- Options for LaTeX output ------------------------------------------------
+
+#latex_engine = 'xelatex'
+#PDF_TITLE = 'Information Development Template'
+#
+#with open(PREAMBLE_FILE, 'r', encoding='utf-8') as f:
+#    PREAMBLE = f.read()
+#
+#with open(TITLE_PAGE_FILE, 'r', encoding='utf-8') as f:
+#    TITLE_PAGE = f.read().replace('<PDF_TITLE>', PDF_TITLE)
+#
+#
+#latex_elements = {
+#    # The paper size ('letterpaper' or 'a4paper').
+#    #
+#    'extraclassoptions': 'openany,oneside',
+#    'babel' : '\\usepackage[english]{babel}',
+#    'papersize': 'a4paper',
+#    'releasename':" ",
+#    # Sonny, Lenny, Glenn, Conny, Rejne, Bjarne and Bjornstrup
+#    # 'fncychap': '\\usepackage[Lenny]{fncychap}',
+#    'fncychap':  '',
+#    #'fontpkg': '\\usepackage{amsmath,amsfonts,amssymb,amsthm}',
+#
+#    'figure_align':'htbp',
+#    # The font size ('10pt', '11pt' or '12pt').
+#    #
+#    'pointsize': '12pt',
+#
+#    # Additional stuff for the LaTeX preamble.
+#    #
+#    'preamble': PREAMBLE,
+#
+#    'maketitle': TITLE_PAGE,
+#    # Latex figure (float) alignment
+#    #
+#    # 'figure_align': 'htbp',
+#    'sphinxsetup': \
+#        'hmargin={0.7in,0.7in}, vmargin={1in,1in}, \
+#        verbatimwithframe=true, \
+#        TitleColor={rgb}{0,0.686,0.941}, \
+#        HeaderFamily=\\rmfamily\\bfseries, \
+#        InnerLinkColor={rgb}{0,0.686,0.941}, \
+#        OuterLinkColor={rgb}{0,0.686,0.941}',
+#
+#    'tableofcontents':' '
+#}
+#
+#latex_logo = '_latex/intel_logo.png'
+## Grouping the document tree into LaTeX files. List of tuples
+## (source start file, target name, title,
+##  author, documentclass [howto, manual, or own class]).
+#latex_documents = [
+#    (master_doc, 'sphinx-infodev.tex', u'sphinx-infodev Documentation',
+#     u'Intel', 'manual'),
+#]
+
+#breathe_projects = {                                       #todd-mod
+#    project: "../doxygen/xml"
+#}
+#breathe_default_project = project
+
+# Setup the exhale extension
+#exhale_args = {                                            #todd-mod
+#    # These arguments are required
+#    "containmentFolder":     "./api",
+#    "rootFileName":          "library_root.rst",
+#    "rootFileTitle":         "Library API",
+#    "doxygenStripFromPath":  "..",
+#    "fullApiSubSectionTitle": 'Full API'
+#}
+
+
+# -- Options for manual page output ------------------------------------------
+
+# One entry per manual page. List of tuples
+# (source start file, name, description, authors, manual section).
+man_pages = [
+    (master_doc, 'sphinx-infodev', u'sphinx-infodev Documentation',
+     [author], 1)
+]
+
+
+# -- Options for Texinfo output ----------------------------------------------
+
+# Grouping the document tree into Texinfo files. List of tuples
+# (source start file, target name, title, author,
+#  dir menu entry, description, category)
+texinfo_documents = [
+    (master_doc, 'sphinx-infodev', u'sphinx-infodev Documentation',
+     author, 'sphinx-infodev', 'One line description of project.',
+     'Miscellaneous'),
+]
+
+
+# -- Options for Epub output -------------------------------------------------
+
+# Bibliographic Dublin Core info.
+epub_title = project
+
+# The unique identifier of the text. This can be a ISBN number
+# or the project homepage.
+#
+# epub_identifier = ''
+
+# A unique identification for the text.
+#
+# epub_uid = ''
+
+# A list of files that should not be packed into the epub file.
+epub_exclude_files = ['search.html']
+
+
+# -- Extension configuration -------------------------------------------------
+
+# -- Options for intersphinx extension ---------------------------------------
+
+# Example configuration for intersphinx: refer to the Python standard library.
+intersphinx_mapping = {'https://docs.python.org/': None}
+
+# -- Options for todo extension ----------------------------------------------
+
+# If true, `todo` and `todoList` produce output, else they produce nothing.
+todo_include_todos = True
@@ -1,45 +0,0 @@
-.. _examples:
-
-oneTBB Samples
-==============
-
-Refer to the following examples to see how |short_name| works. 
-
-* **Containers** 
-
-  * `concurrent_hash_map <https://github.com/oneapi-src/oneTBB/tree/master/examples/concurrent_hash_map>`_ 
-  * `concurrent_priority_queue <https://github.com/oneapi-src/oneTBB/tree/master/examples/concurrent_priority_queue>`_ 
-
-* `Flow Graph <https://github.com/oneapi-src/oneTBB/tree/master/examples/graph>`_ 
-   * `A solution to the binpacking problem using a queue_node, a buffer_node, and function_node. <https://github.com/oneapi-src/oneTBB/tree/master/examples/graph/binpack>`_ 
-   * `Cholesky Factorization algorithm <https://github.com/oneapi-src/oneTBB/tree/master/examples/graph/cholesky>`_
-   * `An implementation of dining philosophers in graph using the reserving join_node <https://github.com/oneapi-src/oneTBB/tree/master/examples/graph/dining_philosophers>`_
-   * `A parallel implementation of bzip2 block-sorting file compressor <https://github.com/oneapi-src/oneTBB/tree/master/examples/graph/fgbzip2>`_
-   * `An example of a collection of digital logic gates that can be easily composed into larger circuits <https://github.com/oneapi-src/oneTBB/tree/master/examples/graph/logic_sim>`_
-   * `An example of a Kohonen Self-Organizing Map using cancellation <https://github.com/oneapi-src/oneTBB/tree/master/examples/graph/som>`_
-   * `Split computational kernel for execution between CPU and GPU <https://github.com/oneapi-src/oneAPI-samples/tree/master/Libraries/oneTBB/tbb-async-sycl>`_
-
-* **Algorithms**
-
-  * `parallel_for <https://github.com/oneapi-src/oneTBB/tree/master/examples/parallel_for>`_
-     * `Game of life overlay <https://github.com/oneapi-src/oneTBB/tree/master/examples/parallel_for/game_of_life>`_
-     * `Polygon overlay <https://github.com/oneapi-src/oneTBB/tree/master/examples/parallel_for/polygon_overlay>`_
-     * `Parallel seismic wave simulation <https://github.com/oneapi-src/oneTBB/tree/master/examples/parallel_for/seismic>`_
-     * `Parallel 2-D raytracer/renderer <https://github.com/oneapi-src/oneTBB/tree/master/examples/parallel_for/tachyon>`_
-     * `Find largest matching substrings <https://github.com/oneapi-src/oneTBB/tree/master/examples/getting_started>`_
-     * `Resumable task: Split computational kernel for execution between CPU and GPU <https://github.com/oneapi-src/oneAPI-samples/tree/master/Libraries/oneTBB/tbb-resumable-tasks-sycl>`_
-  * `parallel_for_each <https://github.com/oneapi-src/oneTBB/tree/master/examples/parallel_for_each>`_
-  * `parallel_pipeline <https://github.com/oneapi-src/oneTBB/tree/master/examples/parallel_pipeline>`_
-  * `parallel_reduce <https://github.com/oneapi-src/oneTBB/tree/master/examples/parallel_reduce>`_
-
-* **Task Scheduler**
-
-  * `task_arena <https://github.com/oneapi-src/oneTBB/tree/master/examples/task_arena>`_
-  * `task_group <https://github.com/oneapi-src/oneTBB/tree/master/examples/task_group>`_
-  * `Execute similar computational kernels, with one task executing the SYCL* code and the other task executing the oneTBB code <https://github.com/oneapi-src/oneAPI-samples/tree/master/Libraries/oneTBB/tbb-task-sycl>`_
-
-* **Other**
-
-  * `Compute Fibonacci numbers in different ways <https://github.com/oneapi-src/oneTBB/tree/master/examples/test_all>`_
-
-
@@ -1,15 +0,0 @@
-.. _Get_Started_Guide:
-
-Get Started with |short_name|
-==============================
-
-.. include:: intro_gsg.rst
-
-.. include:: system_requirements.rst
-
-.. include:: before_beginning_and_example.rst
-
-Find more
-*********
-
-See our `documentation <https://oneapi-src.github.io/oneTBB/>`_ to learn more about |short_name|.
@@ -0,0 +1,97 @@
+.. _Get_Started_Guide
+
+Get Started with |full_name|
+============================
+
+
+|full_name| enables you to simplify parallel programming by breaking 
+computation into parallel running tasks. oneTBB is available as a stand-alone
+product and as part of the |base_tk|.
+
+|short_name| is a runtime-based parallel programming model for C++ code that uses threads.
+It consists of a template-based runtime library to help you harness the latent performance
+of multi-core processors. Use |short_name| to write scalable applications that:
+
+- Specify logical parallel structure instead of threads
+- Emphasize data parallel programming
+- Take advantage of concurrent collections and parallel algorithms
+
+Before You Begin
+****************
+
+After installing |short_name|, you need to set the environment variables:
+  
+#. Go to the oneTBB installation directory (``<install_dir>``). By default, ``<install_dir>`` is the following:
+     
+   * On Linux* OS:
+	 
+     * For superusers (root): ``/opt/intel/oneapi``
+     * For ordinary users (non-root): ``$HOME/intel/oneapi``
+     
+   * On Windows* OS:
+
+     * ``<Program Files>\Intel\oneAPI``
+
+#. Set the environment variables, using the script in <install_dir>, by running
+     
+   * On Linux* OS:
+	 
+     ``vars.{sh|csh} in <install_dir>/tbb/latest/env``
+	   
+   * On Windows* OS:
+	 
+     ``vars.bat in <install_dir>/tbb/latest/env``
+
+
+System Requirements
+*******************
+
+Refer to the `oneTBB System Requirements <https://software.intel.com/content/www/us/en/develop/articles/intel-oneapi-threading-building-blocks-system-requirements.html>`_.
+
+Find more
+*********
+
+.. list-table:: 
+   :widths: 40 60
+   :header-rows: 0
+
+
+   * - 
+	   - `oneTBB Community Forum <https://community.intel.com/>`_
+	   - `Product FAQs <https://software.intel.com/content/www/us/en/develop/support/faq-product.html>`_
+	   - `Support requests <https://software.intel.com/content/www/us/en/develop/articles/how-to-create-a-support-request-at-online-service-center.html>`_
+     - Use these resources if you need support with oneTBB.
+   
+   * - `Release Notes <https://software.intel.com/content/www/us/en/develop/articles/intel-oneapi-threading-building-blocks-release-notes.html>`_
+     - Find up-to-date information about the product, including detailed notes, known issues, and changes.
+   
+   * - `Documentation <https://software.intel.com/content/www/us/en/develop/documentation/onetbb-documentation/top.html>`_: `Developer Guide <https://software.intel.com/content/www/us/en/develop/documentation/onetbb-documentation/top/onetbb-developer-guide.html>`_ and `API Reference <https://software.intel.com/content/www/us/en/develop/documentation/onetbb-documentation/top/onetbb-api-reference.html>`_
+     - Learn to use oneTBB.   
+   * - `GitHub* <https://github.com/oneapi-src/oneTBB>`_
+     - Find oneTBB implementation in open source.
+   
+
+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
+ay 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.
@@ -1,7 +0,0 @@
-.. _installation:
-
-Installation
-============
-
-See the `installation instructions <https://github.com/oneapi-src/oneTBB/blob/master/INSTALL.md>`_ 
-that will help you to install |short_name| successfully.  
@@ -1,23 +0,0 @@
-.. _Intro_gsg:
-
-
-|full_name| is a runtime-based parallel programming model for C++ code that uses threads. 
-It consists of a template-based runtime library to help you harness the latent performance of multi-core processors.
-
-oneTBB enables you to simplify parallel programming by breaking computation into parallel running tasks. Within a single process, 
-parallelism is carried out through threads, an operating system mechanism that allows the same or different sets of instructions 
-to be executed simultaneously.
-
-Here you can see one of the possible executions of tasks by threads.
-
-.. figure:: /GSG/Images/how-oneTBB-works.png
-   :scale: 70%
-   :align: center
-
-Use oneTBB to write scalable applications that:
-
-* Specify logical parallel structure instead of threads
-* Emphasize data-parallel programming
-* Take advantage of concurrent collections and parallel algorithms
-
-oneTBB supports nested parallelism and load balancing. It means that you can use the library without being worried about oversubscribing a system.
@@ -1,6 +0,0 @@
-.. _System_Requirements:
-
-System Requirements
-*******************
-
-Refer to the `oneTBB System Requirements <https://github.com/oneapi-src/oneTBB/blob/master/SYSTEM_REQUIREMENTS.md>`_.
@@ -1,36 +0,0 @@
-#===============================================================================
-# Copyright (C) 2022 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#===============================================================================
-
-# Minimal makefile for Sphinx documentation
-#
-
-# You can set these variables from the command line, and also
-# from the environment for the first two.
-SPHINXOPTS    ?=
-SPHINXBUILD   ?= sphinx-build
-SOURCEDIR     = doc
-BUILDDIR      = build
-
-# Put it first so that "make" without argument is like "make help".
-help:
-	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
-
-.PHONY: help Makefile
-
-# Catch-all target: route all unknown targets to Sphinx using the new
-# "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
-%: Makefile
-	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
@@ -1,34 +0,0 @@
-# How to build oneTBB documentation
-
-Our documentation is written in restructured text markup (.rst) and built using [Sphinx](http://www.sphinx-doc.org/en/master/). 
-
-This document explains how to build oneTBB documentation locally. 
-
-## Prerequisites
- Python 3.7.0 or higher
- Sphinx 
-
-## Build documentation
-
-Do the following to generate HTML output of the documentation: 
-
-1. Clone oneTBB repository:
-
-```
-git clone https://github.com/oneapi-src/oneTBB.git
-```
-
-2. Go to the `doc` folder:
-
-```
-cd oneTBB/doc
-```
-
-3. Run in the command line:
-
-```
-make html
-```
-
-
-That's it! Your built documentation is located in the ``build/html`` folder. 
@@ -1,15 +0,0 @@
-|full_name|
-===========
-
-.. include:: index/index_intro.rst
-
-
-The following are some important topics for the ``novice user``:
-
-* :ref:`Get_Started_Guide` gives you a brief explanation of what oneTBB is. 
-* :ref:`Benefits` describes how |short_name| differs from typical threading packages.
-* :ref:`Package_Contents` describes dynamic library files and header files for Windows*, Linux*, and macOS* operating systems used in |short_name|.
-
-.. include:: index/useful_topics.rst
-
-.. include:: index/toctree.rst
@@ -1,5 +0,0 @@
-.. _index_intro:
-
-This document contains information about |short_name|. 
-It is a flexible performance library that let you break computation into parallel running tasks. 
-
@@ -1,33 +0,0 @@
-.. _toctree:
-
-.. toctree::
-   :caption: About
-   :maxdepth: 1
-
-   /main/intro/help_support
-   /main/intro/notation
-   /main/intro/intro_os
-   /main/intro/Benefits
-
-
-.. toctree::
-   :caption: Get Started
-   :maxdepth: 2
-
-   /GSG/get_started
-   /GSG/installation
-   /GSG/examples
-
-
-.. toctree::
-   :maxdepth: 3
-   :caption: Developer Guide
-
-   /main/tbb_userguide/title
-
-
-.. toctree::
-   :maxdepth: 3
-   :caption: Developer Reference
-
-   /main/reference/reference
@@ -1,5 +0,0 @@
-.. _Usefull_Topics:
-
-The following is an important topic for the ``experienced user``:
-
-:ref:`Migration_Guide` describes how to migrate from TBB to oneTBB.
@@ -1,3 +1,19 @@
+//configure tms    
+var wapLocalCode = 'us-en'; 
+//dynamically set per localized site, see mapping table for values    
+var wapSection = "oneapi-docs";     
+//load tms    
+(function() {                 
+    var host = (window.document.location.protocol == 'http:') ? "http://www.intel.com" : "https://www.intel.com";
+    var url = host+"/content/dam/www/global/wap/tms-loader.js"; //wap file url
+    var po = document.createElement('script'); 
+    po.type = 'text/javascript'; 
+    po.async = true;  
+    po.src = url;                 
+    var s = document.getElementsByTagName('script')[0]; 
+    s.parentNode.insertBefore(po, s);     
+})(); 
+
 window.MathJax = {
    TeX: {
    Macros: {
@@ -1,16 +0,0 @@
-{% extends "!layout.html" %}
-{% block extrahead %}
-    <script defer type="text/javascript" src="https://www.intel.com/content/dam/www/global/wap/performance-config.js" ></script>
-    <script type="text/javascript">
-        // Configure TMS settings
-        var wapLocalCode = 'us-en'; // Dynamically set per localized site, see mapping table for values
-        var wapSection = "oneapi-tbb"; // WAP team will give you a unique section for your site
-        // Load TMS
-            (function () {
-              var url = 'https://www.intel.com/content/dam/www/global/wap/tms-loader.js'; // WAP file URL
-              var po = document.createElement('script'); po.type = 'text/javascript'; po.async = true; po.src = url;
-              var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(po, s);
-        })();
-      </script>
-      <link href="{{ pathto("_static/style.css", True) }}" rel="stylesheet" type="text/css">
-{% endblock %}
@@ -25,11 +25,11 @@ BUILD_TYPE = os.getenv("BUILD_TYPE")

 # -- Project information -----------------------------------------------------

-if BUILD_TYPE == 'oneapi' or BUILD_TYPE == 'dita':
+if BUILD_TYPE == 'oneapi':
    project = u'Intel® oneAPI Threading Building Blocks (oneTBB)'
 else:
-    project = u'oneTBB'
-copyright = u'2022, Intel Corporation'
+    project = u'oneAPI Threading Building Blocks (oneTBB)'
+copyright = u'2021, Intel Corporation'
 author = u'Intel'

 # The short X.Y version
@@ -60,7 +60,7 @@ extensions = [
 ]

 # Add any paths that contain templates here, relative to this directory.
-templates_path = ['main/_templates']
+templates_path = ['_templates']

 # The suffix(es) of source filenames.
 # You can specify multiple suffix as a list of string:
@@ -90,7 +90,7 @@ pygments_style = None
 # Syntax highlighting for the :: directive
 highlight_language = 'cpp' 

-if BUILD_TYPE == 'oneapi' or BUILD_TYPE == 'dita':
+if BUILD_TYPE == 'oneapi':
    rst_prolog = """
 .. |full_name| replace:: Intel\ |reg|\  oneAPI Threading Building Blocks (oneTBB)
 .. |short_name| replace:: oneTBB
@@ -120,32 +120,27 @@ else:
 # further.  For a list of options available for each theme, see the
 # documentation.
 #
-
-html_theme = 'sphinx_book_theme'
-
-if BUILD_TYPE == 'dita':
-    html_theme_options = {
-        'repository_url': 'https://github.com/oneapi-src/oneTBB',
-        'path_to_docs': 'doc',
-        'repository_branch': 'master'
-    }
+if BUILD_TYPE == 'oneapi':
+    html_theme = 'sphinx_rtd_theme'
 else:
+    html_theme = 'sphinx_book_theme'
    html_theme_options = {
-        'repository_url': 'https://github.com/oneapi-src/oneTBB',
-        'path_to_docs': 'doc/main',
-        'use_issues_button': True,
-        'use_edit_page_button': True,
-        'repository_branch': 'master',
-        'extra_footer': '<p align="right"><a href="https://www.intel.com/content/www/us/en/privacy/intel-cookie-notice.html">Cookies</a></p>'
+    'repository_url': 'https://github.com/oneapi-src/oneTBB',
+    'path_to_docs': 'doc/main',
+    'use_issues_button': True,
+    'use_edit_page_button': True,
+    'repository_branch': 'master',
+    'extra_footer': '<p align="right"><a href="https://www.intel.com/content/www/us/en/privacy/intel-cookie-notice.html">Cookies</a></p>'
    }


+
 # Add any paths that contain custom static files (such as style sheets) here,
 # relative to this directory. They are copied after the builtin static files,
 # so a file named "default.css" will overwrite the builtin "default.css".
 html_static_path = ['_static']

-if BUILD_TYPE == 'oneapi'  or BUILD_TYPE == 'dita':
+if BUILD_TYPE == 'oneapi':
    html_context = {
        'css_files': [
            '_static/theme_overrides.css',  # override wide tables in RTD theme
@@ -153,10 +148,8 @@ if BUILD_TYPE == 'oneapi'  or BUILD_TYPE == 'dita':
    }
 else:
    html_js_files = ['custom.js']
-
-    
-html_logo = '_static/oneAPI-rgb-rev-100.png'
-html_favicon = '_static/favicons.png'
+    html_logo = '_static/oneAPI-rgb-rev-100.png'
+    html_favicon = '_static/favicons.png'

 # Custom sidebar templates, must be a dictionary that maps document names
 # to template names.
@@ -0,0 +1,13 @@
+|full_name|
+===========
+
+.. toctree::
+   :maxdepth: 2
+
+   intro/help_support
+   intro/notation
+   intro/intro
+   intro/Benefits
+   tbb_userguide/title
+   reference/reference
+   intro/notices_and_disclaimers
@@ -4,12 +4,23 @@ Getting Help and Support
 ========================


+
+
+
 .. container:: section


   .. rubric:: Getting Technical Support
      :class: sectiontitle

-   For general information about oneTBB technical support, product
+   If you did not register your Intel® software product during
+   installation, please do so now at the Intel® Software Development
+   Products Registration Center. Registration entitles you to free
+   technical support, product updates and upgrades for the duration of
+   the support term.
+
+
+   For general information about Intel technical support, product
   updates, user forums, FAQs, tips and tricks and other support
-   questions, go to `GitHub issues <https://github.com/oneapi-src/oneTBB/issues>`_.
+   questions, go to: http://www.intel.com/software/products/support/.
+
@@ -30,6 +30,10 @@ more conveniently than using raw threads, and at the same time can
 improve performance.


+.. admonition:: Product and Performance Information 
+
+   Performance varies by use, configuration and other factors. Learn more at `www.intel.com/PerformanceIndex <https://www.intel.com/PerformanceIndex>`_.
+   Notice revision #20201201 



@@ -0,0 +1,39 @@
+.. _introducing_main:
+
+Introduction
+============
+
+
+|full_name| is a library that supports scalable parallel programming using
+standard ISO C++ code. It does not require special languages or
+compilers. It is designed to promote scalable data parallel programming.
+Additionally, it fully supports nested parallelism, so you can build
+larger parallel components from smaller parallel components. To use the
+library, you specify tasks, not threads, and let the library map tasks
+onto threads in an efficient manner.
+
+
+Many of the library interfaces employ generic programming, in which
+interfaces are defined by requirements on types and not specific types.
+The C++ Standard Template Library (STL) is an example of generic
+programming. Generic programming enables oneTBB to be flexible yet
+efficient. The generic interfaces enable you to customize components to
+your specific needs.
+
+
+.. note:: 
+   |full_name| requires C++11 standard compiler support.
+
+
+The net result is that oneTBB enables you to specify parallelism far
+more conveniently than using raw threads, and at the same time can
+improve performance.
+
+
+.. admonition:: Product and Performance Information 
+
+   Performance varies by use, configuration and other factors. Learn more at `www.intel.com/PerformanceIndex <https://www.intel.com/PerformanceIndex>`_.
+   Notice revision #20201201 
+
+
+
@@ -0,0 +1,49 @@
+.. _notices_and_disclaimers:
+
+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.
+
@@ -0,0 +1,165 @@
+.. _task_scheduler_handle_reference:
+
+task_scheduler_handle Class
+===========================
+
+.. note::
+    To enable this feature, set the ``TBB_PREVIEW_WAITING_FOR_WORKERS`` macro to 1.
+
+.. contents::
+    :local:
+    :depth: 1
+
+Description
+***********
+
+The ``oneapi::tbb::task_scheduler_handle`` class and the ``oneapi::tbb::finalize`` function allow to wait for completion of worker threads.
+
+When the ``oneapi::tbb::finalize`` function is called with an ``oneapi::tbb::task_scheduler_handle`` instance, it blocks the calling
+thread until the completion of all worker threads that were implicitly created by the library.
+
+API
+***
+
+Header
+------
+
+.. code:: cpp
+
+    #include <oneapi/tbb/global_control.h>
+
+Synopsis
+--------
+
+.. code:: cpp
+
+    namespace oneapi {
+        namespace tbb {
+
+            class task_scheduler_handle {
+            public:
+                task_scheduler_handle() = default;
+                ~task_scheduler_handle();
+
+                task_scheduler_handle(const task_scheduler_handle& other) = delete;
+                task_scheduler_handle(task_scheduler_handle&& other) noexcept;
+                task_scheduler_handle& operator=(const task_scheduler_handle& other) = delete;
+                task_scheduler_handle& operator=(task_scheduler_handle&& other) noexcept;
+
+                explicit operator bool() const noexcept;
+
+                static task_scheduler_handle get();
+
+                static void release(task_scheduler_handle& handle);
+            };
+
+            void finalize(task_scheduler_handle& handle);
+            bool finalize(task_scheduler_handle& handle, const std::nothrow_t&) noexcept;
+
+        } // namespace tbb
+    } // namespace oneapi
+
+Member Functions
+----------------
+
+.. cpp:function:: task_scheduler_handle()
+
+    **Effects**: Creates an instance of the ``task_scheduler_handle`` class that does not contain any reference to the task scheduler.
+
+-------------------------------------------------------
+
+.. cpp:function:: ~task_scheduler_handle()
+
+    **Effects**: Destroys an instance of the ``task_scheduler_handle`` class.
+    Releases a reference to the task scheduler and deactivates an instance of the ``task_scheduler_handle`` class.
+
+-------------------------------------------------------
+
+.. cpp:function:: task_scheduler_handle(task_scheduler_handle&& other) noexcept
+
+    **Effects**: Creates an instance of the ``task_scheduler_handle`` class that references the task scheduler referenced by ``other``. In turn, ``other`` releases its reference to the task scheduler.
+
+-------------------------------------------------------
+
+.. cpp:function:: task_scheduler_handle& operator=(task_scheduler_handle&& other) noexcept
+
+    **Effects**: Releases a reference to the task scheduler referenced by ``this``. Adds a reference to the task scheduler referenced by ``other``.
+In turn, ``other`` releases its reference to the task scheduler.
+
+-------------------------------------------------------
+
+.. cpp:function:: explicit operator bool() const noexcept
+
+    **Returns**: ``true`` if ``this`` references any task scheduler; ``false`` otherwise.
+
+-------------------------------------------------------
+
+.. cpp:function:: task_scheduler_handle get()
+
+    **Returns**: An instance of the ``task_scheduler_handle`` class that holds a reference to the task scheduler preventing
+    its premature destruction.
+
+-------------------------------------------------------
+
+.. cpp:function:: void release(task_scheduler_handle& handle)
+
+    **Effects**: Releases a reference to the task scheduler and deactivates an instance of the ``task_scheduler_handle``
+    class. Non-blocking method.
+
+Non-member Functions
+--------------------
+
+.. cpp:function:: void finalize(task_scheduler_handle& handle)
+
+    **Effects**: Blocks the program execution until all worker threads have been completed. Throws the ``oneapi::tbb::unsafe_wait``
+    exception if it is not safe to wait for the completion of the worker threads.
+
+The following conditions should be met for finalization to succeed:
+
+- No active (not yet terminated) instances of class ``task_arena`` exist in the whole program;
+- ``task_scheduler_handle::release`` is called for each other active instance of class ``task_scheduler_handle``, possibly by different application threads.
+
+Under these conditions, it is guaranteed that at least one ``finalize`` call succeeds,
+at which point all worker threads have been completed.
+If calls are performed simultaneously, more than one call might succeed.
+
+.. note::
+
+    If you know how many active ``task_scheduler_handle`` instances exist in the program,
+    it is necessary to ``release`` all but the last one, then call ``finalize`` for
+    the last instance.
+
+.. caution::
+
+  The method always fails if called within a task, a parallel algorithm, or a flow graph node.
+
+-------------------------------------------------------
+
+.. cpp:function:: bool finalize(task_scheduler_handle& handle, const std::nothrow_t&) noexcept
+
+    **Effects**: Blocks the program execution until all worker threads have been completed. Same as above, but returns ``true`` if all worker
+    threads have been completed successfully, or ``false`` if it is not safe to wait for the completion of the worker threads.
+
+Examples
+********
+
+.. code:: cpp
+
+    #define TBB_PREVIEW_WAITING_FOR_WORKERS 1
+    #include <oneapi/tbb/global_control.h>
+    #include <oneapi/tbb/parallel_for.h>
+
+    #include <iostream>
+
+    int main() {
+        oneapi::tbb::task_scheduler_handle handle = oneapi::tbb::task_scheduler_handle::get();
+        // Do some parallel work here, e.g.
+        oneapi::tbb::parallel_for(0, 10000, [](int){});
+        try {
+            oneapi::tbb::finalize(handle);
+            // oneTBB worker threads are terminated at this point.
+        } catch (const oneapi::tbb::unsafe_wait&) {
+            std::cerr << "Failed to terminate the worker threads." << std::endl;
+        }
+        return 0;
+    }
@@ -0,0 +1,241 @@
+.. _heterogeneous_extensions_chmap:
+
+Heterogeneous overloads for ``concurrent_hash_map`` member functions
+====================================================================
+
+.. note::
+    To enable this feature, define the ``TBB_PREVIEW_CONCURRENT_HASH_MAP_EXTENSIONS`` macro to 1.
+
+A set of overloads for ``concurrent_hash_map`` member functions that allow to search, erase, and insert
+elements into the container without creating a temporary ``key_type`` object.
+
+.. contents::
+    :local:
+    :depth: 1
+
+Description
+***********
+
+Heterogeneous overloads allow you to perform insert, lookup, and erasure operations on ``concurrent_hash_map`` object
+using an object of the type that is different from ``key_type`` but comparable with it.
+
+All member functions described below only participate in overload resolution if ``HashCompareType::is_transparent``
+is valid and denotes a type.``HashCompareType`` is a type of the ``HashCompare`` passed as a template argument
+for ``concurrent_hash_map``. It means that the ``HashCompare`` object calculates a hash and compares keys for
+equality without creating a temporary ``key_type`` object.
+
+API
+***
+
+Header
+------
+
+.. code:: cpp
+
+    #include "oneapi/tbb/concurrent_hash_map.h"
+
+Synopsis
+--------
+
+.. code:: cpp
+
+    namespace oneapi {
+        namespace tbb {
+            template <typename Key, typename Mapped,
+                      typename HashCompare = tbb_hash_compare<Key>,
+                      typename Allocator = tbb_allocator<std::pair<const Key, Mapped>>>
+            class concurrent_hash_map {
+            public:
+                // Insertion
+                template <typename K>
+                bool insert( accessor& result, const K& k );
+
+                template <typename K>
+                bool insert( const_accessor& result, const K& k );
+
+                // Lookup
+                template <typename K>
+                bool find( accessor& result, const K& k );
+
+                template <typename K>
+                bool find( const_accessor& result, const K& k ) const;
+
+                template <typename K>
+                size_type count( const K& k ) const;
+
+                template <typename K>
+                std::pair<iterator, iterator> equal_range( const K& k );
+
+                template <typename K>
+                std::pair<const_iterator, const_iterator> equal_range( const K& k ) const;
+
+                // Erasure
+                template <typename K>
+                bool erase( const K& k );
+            };
+        } // namespace tbb
+    } // namespace oneapi
+
+Member functions
+----------------
+
+Insertion
+^^^^^^^^^
+
+.. code:: cpp
+
+    template <typename K>
+    bool insert( accessor& result, const K& k );
+
+    template <typename K>
+    bool insert( const_accessor& result, const K& k );
+
+If the accessor ``result`` is not empty, releases the ``result`` and tries to
+insert the value constructed from ``{k, mapped_type()}`` into the container.
+
+Sets the ``result`` to provide access to the inserted element or to the element with the key that
+compares `equivalent` to the value ``k``.
+
+This overload only participates in overload resolution if ``std::is_constructible<key_type, const K&>`` is ``true``.
+
+**Returns**: ``true`` if the insertion was applied, ``false`` otherwise.
+
+Lookup
+^^^^^^
+
+.. code:: cpp
+
+    template <typename K>
+    bool find( accessor& result, const K& k );
+
+    template <typename K>
+    bool find( const_accessor& result, const K& k ) const;
+
+If the accessor ``result`` is not empty, releases the ``result``.
+
+If an element with the key that compares `equivalent` to the value ``k`` exists,
+sets the ``result`` to provide access to this element.
+
+**Returns**: ``true`` if an element with the key that compares `equivalent` to the value ``k`` is found,
+``false`` otherwise.
+
+------------------------------------------------
+
+.. code:: cpp
+
+    template <typename K>
+    size_type count( const K& k ) const;
+
+**Returns**: ``1`` if an element with the key that compares `equivalent` to the value ``k`` exists, ``0`` otherwise.
+
+------------------------------------------------
+
+.. code:: cpp
+
+    template <typename K>
+    std::pair<iterator, iterator> equal_range( const K& k );
+
+    template <typename K>
+    std::pair<const_iterator, const_iterator> equal_range( const K& k ) const;
+
+**Returns**:
+
+- A pair of iterators ``{f, l}`` if an element with the key that compares `equivalent` to the value ``k`` exists in the container.
+  Here ``f`` is an iterator to this element, ``l`` is ``std::next(f)``.
+- ``{end(), end()}`` otherwise.
+
+.. rubric:: Example
+
+The example below demonstrates how to use heterogeneous lookup feature to find an object with the key of type ``std::string``
+using an object of type ``const char*`` without conversions.
+
+.. code:: cpp
+
+    #define TBB_PREVIEW_CONCURRENT_HASH_MAP_EXTENSIONS 1
+    #include "oneapi/tbb/concurrent_hash_map.h"
+    #include <string>
+    #include <cstring>
+
+    // HashCompare an object that can calculate the hash code for
+    // std::string only and compare strings for equality
+    class RegularHashCompare {
+    private:
+        std::hash<std::string> my_hasher;
+    public:
+        std::size_t hash( const std::string& key ) const {
+            return my_hasher(key);
+        }
+
+        bool equal( const std::string& key1, const std::string& key2 ) const {
+            return key1 == key2;
+        }
+    };
+
+    // HashCompare an object that can calculate the hash code for
+    // std::string and const char*, and compare them for equality
+    class TransparentHashCompare {
+    private:
+        std::hash<char> my_hasher;
+
+        // Calculates a hash for the array of chars
+        std::size_t calculate_hash( const char* ptr ) const {
+            std::size_t h = 0;
+            for (auto c = ptr; *c; ++c) {
+                h = h ^ my_hasher(*c);
+            }
+            return h;
+        }
+    public:
+        using is_transparent = void;
+
+        std::size_t hash( const char* key ) const {
+            return calculate_hash(key);
+        }
+
+        std::size_t hash( const std::string& key ) const {
+            return calculate_hash(key.c_str());
+        }
+
+        bool equal( const char* key1, const char* key2 ) const {
+            return std::strcmp(key1, key2) == 0;
+        }
+
+        bool equal( const char* key1, const std::string& key2 ) const {
+            return std::strcmp(key1, key2.c_str()) == 0;
+        }
+
+        bool equal( const std::string& key1, const char* key2 ) const {
+            return std::strcmp(key1.c_str(), key2) == 0;
+        }
+
+        bool equal( const std::string& key1, const std::string& key2 ) const {
+            return std::strcmp(key1.c_str(), key2.c_str()) == 0;
+        }
+    };
+
+    int main() {
+        using regular_hash_map =
+            oneapi::tbb::concurrent_hash_map<std::string, int, RegularHashCompare>;
+        using transparent_hash_map =
+            oneapi::tbb::concurrent_hash_map<std::string, int, TransparentHashCompare>;
+
+        using regular_accessor = typename regular_hash_map::accessor;
+        using transparent_accessor = typename transparent_hash_map::accessor;
+
+        // Accessors
+        regular_accessor reg_accessor;
+        transparent_accessor tran_accessor;
+
+        // Maps
+        regular_hash_map regular_map;
+        transparent_hash_map tran_map;
+
+        // Heterogeneous overloads do not participate in overload resolution
+        // Such a call matches on the find overload, which accepts key_type (std::string)
+        // Creates a temporary key_type (std::string) object because of implicit conversion
+        bool result = regular_map.find(reg_accessor, "abc");
+
+        // Heterogeneous overloads participate in overload resolution
+        // No implicit conversion from const char* to std::string takes place
+        result = tran_map.find(tran_accessor, "abc");
+    }
@@ -0,0 +1,93 @@
+.. _mutex:
+
+mutex
+==========
+
+.. note::
+   To enable this feature, define the ``TBB_PREVIEW_MUTEXES`` macro to 1.
+
+Description
+***********
+
+A ``mutex`` is a class that models the `Mutex requirement <https://spec.oneapi.com/versions/latest/elements/oneTBB/source/named_requirements/mutexes/mutex.html>`_,
+using adaptive approach: the combination of spinlock and waiting on system primitives.
+The ``mutex`` class satisfies all of the mutex requirements described in the [thread.mutex.requirements] section of the ISO C++ standard.
+The ``mutex`` class is not fair or recursive.
+
+API
+***
+
+Header
+------
+
+.. code:: cpp
+
+    #include <oneapi/tbb/mutex.h>
+
+Synopsis
+--------
+
+.. code:: cpp
+
+    namespace oneapi {
+        namespace tbb {
+            class mutex {
+            public:
+                mutex() noexcept;
+                ~mutex();
+
+                mutex(const mutex&) = delete;
+                mutex& operator=(const mutex&) = delete;
+
+                class scoped_lock;
+
+                void lock();
+                bool try_lock();
+                void unlock();
+
+                static constexpr bool is_rw_mutex = false;
+                static constexpr bool is_recursive_mutex = false;
+                static constexpr bool is_fair_mutex = false;
+            };
+        }
+    }
+
+Member classes
+--------------
+
+.. namespace:: tbb::mutex
+	       
+.. cpp:class:: scoped_lock
+
+    The corresponding ``scoped_lock`` class. See the `Mutex requirement <https://spec.oneapi.com/versions/latest/elements/oneTBB/source/named_requirements/mutexes/mutex.html>`_.
+
+Member functions
+----------------
+
+.. cpp:function:: mutex()
+
+    Constructs ``mutex`` with unlocked state.
+
+--------------------------------------------------
+
+.. cpp:function:: ~mutex()
+
+    Destroys an unlocked ``mutex``.
+
+--------------------------------------------------
+
+.. cpp:function:: void lock()
+
+    Acquires a lock. It uses adaptive logic for waiting: it blocks after particular time period of busy wait.
+
+--------------------------------------------------
+
+.. cpp:function:: bool try_lock()
+
+    Tries to acquire a lock (non-blocking). Returns **true** if succeeded; **false** otherwise.
+
+--------------------------------------------------
+
+.. cpp:function:: void unlock()
+
+    Releases the lock held by a current thread.
@@ -1,72 +0,0 @@
-.. _parallel_sort_ranges_extension:
-
-parallel_sort ranges interface extension
-========================================
-
-.. contents::
-    :local:
-    :depth: 1
-
-Description
-***********
-
-|full_name| implementation extends the `oneapi::tbb::parallel_sort specification <https://spec.oneapi.io/versions/latest/elements/oneTBB/source/algorithms/functions/parallel_sort_func.html>`_
-with overloads that takes the container by forwarding reference.
-
-
-API
-***
-
-Header
------
-
-.. code:: cpp
-
-    #include <oneapi/tbb/parallel_sort.h>
-
-Syntax
------
-
-.. code:: cpp
-
-    namespace oneapi {
-        namespace tbb {
-
-            template <typename Container>
-            void parallel_sort( Container&& c );
-            template <typename Container, typename Compare>
-            void parallel_sort( Container&& c, const Compare& comp );
-
-        } // namespace tbb
-    } // namespace oneapi
-
-Functions
---------
-
-.. cpp:function:: template <typename Container> void parallel_sort( Container&& c );
-
-    Equivalent to ``parallel_sort( std::begin(c), std::end(c), comp )``, where `comp` uses `operator<` to determine relative orderings.
-
-.. cpp:function:: template <typename Container, typename Compare> void parallel_sort( Container&& c, const Compare& comp );
-
-    Equivalent to ``parallel_sort( std::begin(c), std::end(c), comp )``.
-
-Example
-------
-
-This interface may be used for sorting rvalue or constant views:
-
-.. code:: cpp
-
-    #include <array>
-    #include <span> // requires C++20
-    #include <oneapi/tbb/parallel_sort.h>
-
-    std::span<int> get_span() {
-        static std::array<int, 3> arr = {3, 2, 1};
-        return std::span<int>(arr);
-    }
-
-    int main() {
-        tbb::parallel_sort(get_span());
-    }
@@ -18,7 +18,6 @@ It also describes features that are not included in the oneTBB specification.

    info_namespace
    parallel_for_each_semantics
-    parallel_sort_ranges_extension

 Preview features
 ****************
@@ -44,10 +43,16 @@ The key properties of a preview feature are:
    :titlesonly:

    type_specified_message_keys
+    blocking_terminate
    scalable_memory_pools
    helpers_for_expressing_graphs
    concurrent_lru_cache_cls
    constraints_extensions
    info_namespace_extensions
    task_group_extensions
+    task_arena_extensions 
+    this_task_arena_extensions
+    mutex_cls
+    rw_mutex_cls
+    heterogeneous_extensions_chmap
    custom_mutex_chmap
@@ -0,0 +1,116 @@
+.. _rw_mutex:
+
+rw_mutex
+=============
+
+.. note::
+   To enable this feature, define the ``TBB_PREVIEW_MUTEXES`` macro to 1.
+
+Description
+***********
+
+A ``rw_mutex`` is a class that models the `ReaderWriterMutex requirement <https://spec.oneapi.com/versions/latest/elements/oneTBB/source/named_requirements/mutexes/rw_mutex.html>`_,
+using adaptive approach: the combination of spinlock and waiting on system primitives.
+The ``rw_mutex`` class satisfies all of the shared mutex requirements described in the [thread.sharedmutex.requirements] section of the ISO C++ standard.
+The ``rw_mutex`` class is unfair reader-writer lock with writer-preference.
+
+API
+***
+
+Header
+------
+
+.. code:: cpp
+
+    #include <oneapi/tbb/rw_mutex.h>
+
+Synopsis
+--------
+.. code:: cpp
+
+    namespace oneapi {
+        namespace tbb {
+            class rw_mutex {
+            public:
+                rw_mutex() noexcept;
+                ~rw_mutex();
+
+                rw_mutex(const rw_mutex&) = delete;
+                rw_mutex& operator=(const rw_mutex&) = delete;
+
+                class scoped_lock;
+
+                // exclusive ownership
+                void lock();
+                bool try_lock();
+                void unlock();
+
+                // shared ownership
+                void lock_shared();
+                bool try_lock_shared();
+                void unlock_shared();
+
+                static constexpr bool is_rw_mutex = true;
+                static constexpr bool is_recursive_mutex = false;
+                static constexpr bool is_fair_mutex = false;
+            };
+        }
+    }
+
+Member classes
+--------------
+
+.. namespace:: tbb::rw_mutex
+	       
+.. cpp:class:: scoped_lock
+
+    The corresponding scoped-lock class. See the `ReaderWriterMutex requirement <https://spec.oneapi.com/versions/latest/elements/oneTBB/source/named_requirements/mutexes/rw_mutex.html>`_.
+
+Member functions
+----------------
+
+.. cpp:function:: rw_mutex()
+
+    Constructs unlocked ``rw_mutex``.
+
+--------------------------------------------------
+
+.. cpp:function:: ~rw_mutex()
+
+    Destroys unlocked ``rw_mutex``.
+
+--------------------------------------------------
+
+.. cpp:function:: void lock()
+
+    Acquires a lock. It uses adaptive logic for waiting: it blocks after particular time period of busy wait.
+
+--------------------------------------------------
+
+.. cpp:function:: bool try_lock()
+
+    Tries to acquire a lock (non-blocking) on write. Returns **true** if succeeded; **false** otherwise.
+
+--------------------------------------------------
+
+.. cpp:function:: void unlock()
+
+    Releases the write lock held by the current thread.
+
+--------------------------------------------------
+
+.. cpp:function:: void lock_shared()
+
+    Acquires a lock on read. It uses adaptive logic for waiting: it blocks after particular time period of busy wait.
+
+--------------------------------------------------
+
+.. cpp:function:: bool try_lock_shared()
+
+    Tries to acquire the lock (non-blocking) on read. Returns **true** if succeeded; **false** otherwise.
+
+--------------------------------------------------
+
+.. cpp:function:: void unlock_shared()
+
+    Releases the read lock held by the current thread.
@@ -0,0 +1,61 @@
+.. _task_arena_extensions:
+
+task_arena extensions
+=====================
+
+.. note::
+    To enable these extensions, set the ``TBB_PREVIEW_TASK_GROUP_EXTENSIONS`` macro to 1.
+
+.. contents::
+    :local:
+    :depth: 1
+
+Description
+***********
+
+|full_name| implementation extends the `tbb::task_arena specification <https://spec.oneapi.com/versions/latest/elements/oneTBB/source/task_scheduler/task_arena/task_arena_cls.html>`_ 
+with an overload of ``enqueue`` method accepting ``task_handle``. 
+   
+
+API
+***
+
+Header
+------
+
+.. code:: cpp
+
+    #include <oneapi/tbb/task_arena.h>
+
+Synopsis
+--------
+
+.. code:: cpp
+
+    namespace oneapi {
+        namespace tbb {
+   
+           class task_arena {
+           public:
+               void enqueue(task_handle&& h);        
+           }; 
+
+        } // namespace tbb
+    } // namespace oneapi
+
+Member Functions
+----------------
+
+.. cpp:function:: void enqueue(task_handle&& h)   
+     
+Enqueues a task owned by ``h`` into the ``task_arena`` for procession.
+ 
+Behavior of this function is identical to generic version (``template<typename F> void task_arena::enqueue(F&& f)``) except parameter type. 
+
+.. note:: 
+   ``h`` should not be empty to avoid undefined behavior.
+             
+.. rubric:: See also
+
+* `oneapi::tbb::task_arena specification <https://spec.oneapi.com/versions/latest/elements/oneTBB/source/task_scheduler/task_arena/task_arena_cls.html>`_
+* :ref:`task_handle` 
@@ -15,7 +15,9 @@ Description

 |full_name| implementation extends the `tbb::task_group specification <https://spec.oneapi.com/versions/latest/elements/oneTBB/source/task_scheduler/task_group/task_group_cls.html>`_ with the following members:

-  - requirements for a user-provided function object
+  - Constructor that takes a custom ``tbb::task_group_context`` object as an argument.
+  - Methods to create and run deferred tasks with ``task_handle``. 
+  - Requirements for a user-provided function object.
   

 API
@@ -38,16 +40,14 @@ Synopsis
   
           class task_group {
           public:
-
-               //only the requirements for the return type of function F are changed              
+               task_group(task_group_context& context);
+               
               template<typename F>
               task_handle defer(F&& f);
                   
-               //only the requirements for the return type of function F are changed
-               template<typename F>
-               task_group_status run_and_wait(const F& f);
-    
-               //only the requirements for the return type of function F are changed              
+               void run(task_handle&& h);
+
+               //only F return type requirements have changed              
               template<typename F>
               void run(F&& f);
           }; 
@@ -55,26 +55,38 @@ Synopsis
        } // namespace tbb
    } // namespace oneapi

-
-
 Member Functions
 ----------------

+.. cpp:function:: task_group(task_group_context& context)
+
+Constructs an empty ``task_group``, which tasks are associated with the ``context``.
+
 .. cpp:function:: template<typename F> task_handle  defer(F&& f)

-As an optimization hint, ``F`` might return a ``task_handle``, which task object can be executed next.
+Creates a deferred task to compute ``f()`` and returns ``task_handle`` pointing to it.

-.. note::
-   The ``task_handle`` returned by the function must be created using ``*this`` ``task_group``. That is, the one for which the run method is called, otherwise it is undefined behavior. 
+The task is not scheduled for execution until explicitly requested. For example, with the ``task_group::run`` method.
+However, the task is still added into the ``task_group``, thus the ``task_group::wait`` method waits until the ``task_handle`` is either scheduled or destroyed.

-.. cpp:function:: template<typename F> task_group_status run_and_wait(const F& f)
+The ``F`` type must meet the `Function Objects` requirements described in the [function.objects] section of the ISO C++ Standard.

 As an optimization hint, ``F`` might return a ``task_handle``, which task object can be executed next.

 .. note::
-   The ``task_handle`` returned by the function must be created using ``*this`` ``task_group``. That is, the one for which the run method is called, otherwise it is undefined behavior. 
+   The ``task_handle`` returned by the function must be created with ``*this`` ``task_group``. It means, with the one for which run method is called, otherwise it is an undefined behavior. 
+
+**Returns:** ``task_handle`` object pointing to task to compute ``f()``.
+
+.. cpp:function:: void run(task_handle&& h)
+   
+Schedules the task object pointed by the ``h`` for execution.
+
+.. note::
+   The failure to satisfy the following conditions leads to undefined behavior:
+      * ``h`` is not empty.
+      * ``*this`` is the same ``task_group`` that ``h`` is created with.    

- 
 .. cpp:function:: template<typename F> void  run(F&& f)

 As an optimization hint, ``F`` might return a ``task_handle``, which task object can be executed next.
@@ -87,5 +99,4 @@ As an optimization hint, ``F`` might return a ``task_handle``, which task object

 * `oneapi::tbb::task_group specification <https://spec.oneapi.com/versions/latest/elements/oneTBB/source/task_scheduler/task_group/task_group_cls.html>`_
 * `oneapi::tbb::task_group_context specification <https://spec.oneapi.com/versions/latest/elements/oneTBB/source/task_scheduler/scheduling_controls/task_group_context_cls.html>`_
-* `oneapi::tbb::task_group_status specification <https://spec.oneapi.com/versions/latest/elements/oneTBB/source/task_scheduler/task_group/task_group_status_enum.html>`_ 
 * :doc:`oneapi::tbb::task_handle class <task_group_extensions/task_handle>`
@@ -0,0 +1,101 @@
+.. _task_handle:
+
+task_handle
+===========
+
+.. note::    To enable these extensions, set the ``TBB_PREVIEW_TASK_GROUP_EXTENSIONS`` macro to 1.
+
+
+.. contents::
+    :local:
+    :depth: 1
+
+Description
+***********
+
+This class owns a deferred task object. 
+
+API
+***
+
+Header
+------
+
+.. code:: cpp
+
+    #include <oneapi/tbb/task_group.h>
+
+Synopsis
+--------
+
+.. code:: cpp
+
+    namespace oneapi {
+        namespace tbb {
+      
+            class task_handle {
+            public:
+                task_handle();
+                task_handle(task_handle&& src);
+                
+                ~task_handle();
+                
+                task_handle& operator=(task_handle&& src);
+            
+                explicit operator bool() const noexcept;
+            }; 
+            
+            bool operator==(task_handle const& h, std::nullptr_t) noexcept;
+            bool operator==(std::nullptr_t, task_handle const& h) noexcept;
+            
+            bool operator!=(task_handle const& h, std::nullptr_t) noexcept;
+            bool operator!=(std::nullptr_t, task_handle const& h) noexcept;
+                      
+        } // namespace tbb
+    } // namespace oneapi
+
+Member Functions
+----------------
+
+.. cpp:function:: task_handle()
+
+Creates an empty ``task_handle`` object.
+
+.. cpp:function:: task_handle(task_handle&& src)
+
+Constructs ``task_handle`` object with the content of ``src`` using move semantics. ``src`` is left in an empty state.
+
+.. cpp:function:: ~task_handle()
+
+Destroys the ``task_handle`` object and associated task if it exists. 
+
+.. cpp:function:: task_handle& operator=(task_handle&& src)
+
+Replaces the content of ``task_handle`` object with the content of ``src`` using move semantics. ``src`` is left in an empty state.
+The previously associated task object, if any, is destroyed before the assignment. 
+
+**Returns:** Reference to ``*this``.
+
+.. cpp:function:: explicit operator bool() const noexcept
+
+Checks if ``*this`` has an associated task object.
+
+**Returns:** ``true`` if ``*this`` is not empty, ``false`` otherwise.
+
+Non-Member Functions
+--------------------
+
+.. code:: cpp
+
+    bool operator==(task_handle const& h, std::nullptr_t) noexcept
+    bool operator==(std::nullptr_t, task_handle const& h) noexcept
+
+**Returns**: ``true`` if ``h`` is empty, ``false`` otherwise.
+
+.. code:: cpp
+
+    bool operator!=(task_handle const& h, std::nullptr_t) noexcept
+    bool operator!=(std::nullptr_t, task_handle const& h) noexcept
+
+**Returns**: ``true`` if ``h`` is not empty, ``false`` otherwise.
+   
@@ -0,0 +1,71 @@
+.. _this_task_arena_extensions:
+
+this_task_arena extensions
+==========================
+
+.. note::
+    To enable these extensions, set the ``TBB_PREVIEW_TASK_GROUP_EXTENSIONS`` macro to 1.
+
+.. contents::
+    :local:
+    :depth: 1
+
+Description
+***********
+
+|full_name| implementation extends the `tbb::this_task_arena specification <https://spec.oneapi.com/versions/latest/elements/oneTBB/source/task_scheduler/task_arena/this_task_arena_ns.html>`_
+with an overloaded ``enqueue`` function. 
+   
+
+API
+***
+
+Header
+------
+
+.. code:: cpp
+
+    #include <oneapi/tbb/task_arena.h>
+
+Synopsis
+--------
+
+.. code:: cpp
+
+    namespace oneapi {
+        namespace tbb {
+            namespace this_task_arena {
+                void enqueue(task_handle&& h);
+      
+                template<typename F>
+                void enqueue(F&& f) ;
+            } // namespace this_task_arena
+        } // namespace tbb
+    } // namespace oneapi
+
+Member Functions
+----------------
+
+   
+.. cpp:function:: template<typename F> void enqueue(F&& f)
+  
+Enqueues a task into the ``task_arena`` currently used by the calling thread to process the specified functor, then immediately returns.
+The ``F`` type must meet the `Function Objects` requirements described in the [function.objects] section of the ISO C++ Standard.
+
+Behavior of this function is identical to ``template<typename F> void task_arena::enqueue(F&& f)`` applied to ``task_arena`` object constructed with ``attach`` parameter.     
+
+.. cpp:function:: void enqueue(task_handle&& h)   
+     
+Enqueues a task owned by ``h`` into the ``task_arena`` that is currently used by the calling thread.
+
+Behavior of this function is identical to generic version (``template<typename F> void enqueue(F&& f)``) except the parameter type. 
+
+.. note:: 
+   ``h`` should not be empty to avoid undefined behavior.
+ 
+        
+.. rubric:: See also:
+
+* `oneapi::tbb::this_task_arena specification <https://spec.oneapi.com/versions/latest/elements/oneTBB/source/task_scheduler/task_arena/this_task_arena_ns.html>`_
+* `oneapi::tbb::task_arena specification <https://spec.oneapi.com/versions/latest/elements/oneTBB/source/task_scheduler/task_arena/task_arena_cls.html>`_
+* :ref:`task_handle` 
@@ -4,13 +4,15 @@ Advanced Topic: Other Kinds of Iteration Spaces
 ===============================================


-The examples so far have used the class ``blocked_range<T>`` to specify ranges.
-This class is useful in many situations, but it does not fit every situation.
-You can use |full_name| to define your own iteration space objects. The object
-must specify how it can be split into subspaces by providing a basic splitting
-constructor, an optional proportional splitting constructor, and two predicate
-methods. If your class is called ``R``, the methods and constructors should be
-as follows:
+The examples so far have used the class ``blocked_range<T>`` to specify
+ranges. This class is useful in many situations, but it does not fit
+every situation. You can use |full_name|
+to define your own iteration space objects. The object must specify how
+it can be split into subspaces by providing a basic splitting
+constructor, an optional proportional splitting constructor (accompanied
+with a trait value that enables its usage), and two predicate methods.
+If your class is called ``R``, the methods and constructors should be as
+follows:


 ::
@@ -23,8 +25,10 @@ as follows:
       bool is_divisible() const;
       // Splits r into subranges r and *this
       R( R& r, split );
-       // (optional) Splits r into subranges r and *this in proportion p
+       // Splits r into subranges r and *this in proportion p
       R( R& r, proportional_split p );
+       // Allows usage of proportional splitting constructor
+       static const bool is_splittable_in_proportion = true;
       ...
   };
       
@@ -56,7 +60,9 @@ constructor is optional and takes the second argument of type
 that return the values of the proportion. These values should be used to
 split ``r`` accordingly, so that the updated ``r`` corresponds to the
 left part of the proportion, and the constructed object corresponds to
-the right part.
+the right part. The proportional splitting constructor will be used only
+if the static constant ``is_splittable_in_proportion`` is defined in the
+class and assigned the value of ``true``.


 Both splitting constructors should guarantee that the updated ``r`` part
@@ -96,6 +96,12 @@ of computations to memory accesses.
   |image1|


+.. admonition:: Product and Performance Information 
+
+   Performance varies by use, configuration and other factors. Learn more at `www.Intel.com/PerformanceIndex <https://www.intel.com/PerformanceIndex>`_.
+   Notice revision #20201201
+
+


 .. |image0| image:: Images/image007.jpg
@@ -157,6 +157,11 @@ quite well.
   work than an iteration of an inner loop.


+.. admonition:: Product and Performance Information 
+
+   Performance varies by use, configuration and other factors. Learn more at `www.intel.com/PerformanceIndex <https://www.intel.com/PerformanceIndex>`_.
+   Notice revision #20201201
+

 .. |image0| image:: Images/image002.jpg
   :width: 161px
@@ -191,7 +191,8 @@ This final implementation has all of the nodes and edges from the
 much advantage in using an ``input_node`` over an explicit loop. But,
 because an ``input_node`` is able to react to the behavior of downstream
 nodes, it can limit memory use in more complex graphs. For more
-information, see:ref:`create_token_based_system` .
+information, see `Creating a Token-Based
+System <create_token_based_system.html#create_token_based_system>`__


 .. |image0| image:: Images/flow_graph.jpg
@@ -14,5 +14,4 @@ in a flow graph.

   ../tbb_userguide/use_limiter_node
   ../tbb_userguide/use_concurrency_limits
-   ../tbb_userguide/create_token_based_system
-   ../tbb_userguide/attach_flow_graph_to_arena
+   ../tbb_userguide/create_token_based_system
@@ -1,50 +0,0 @@
-.. _How_Task_Scheduler_Works.rst:
-
-How Task Scheduler Works
-========================
-
-
-While the task scheduler is not bound to any particular type of parallelism, 
-it was designed to work efficiently for fork-join parallelism with lots of forks.
-This type of parallelism is typical for parallel algorithms such as `oneapi::tbb::parallel_for
-<https://spec.oneapi.io/versions/latest/elements/oneTBB/source/algorithms/functions/parallel_for_func.html>`_.
-
-Let's consider the mapping of fork-join parallelism on the task scheduler in more detail. 
-
-The scheduler runs tasks in a way that tries to achieve several targets simultaneously: 
- - Enable as many threads as possible, by creating enough job, to achieve actual parallelism
- - Preserve data locality to make a single thread execution more efficient  
- - Minimize both memory demands and cross-thread communication to reduce an overhead 
-
-To achieve this, a balance between depth-first and breadth-first execution strategies 
-must be reached. Assuming that the task graph is finite, depth-first is better for 
-a sequential execution because:
-
- **Strike when the cache is hot**. The deepest tasks are the most recently created tasks and therefore are the hottest in the cache.
-  Also, if they can be completed, tasks that depend on it can continue executing, and though not the hottest in a cache, 
-  they are still warmer than the older tasks deeper in the dequeue.
- 
- **Minimize space**. Execution of the shallowest task leads to the breadth-first unfolding of a graph. It creates an exponential
-  number of nodes that co-exist simultaneously. In contrast, depth-first execution creates the same number 
-  of nodes, but only a linear number can exists at the same time, since it creates a stack of other ready 
-  tasks.
-  
-Each thread has its deque of tasks that are ready to run. When a 
-thread spawns a task, it pushes it onto the bottom of its deque.
-
-When a thread participates in the evaluation of tasks, it constantly executes 
-a task obtained by the first rule that applies from the roughly equivalent ruleset:
-
- Get the task returned by the previous one, if any.
-
- Take a task from the bottom of its deque, if any.
-
- Steal a task from the top of another randomly chosen deque. If the 
-  selected deque is empty, the thread tries again to execute this rule until it succeeds.
-
-Rule 1 is described in :doc:`Task Scheduler Bypass <Task_Scheduler_Bypass>`. 
-The overall effect of rule 2 is to execute the *youngest* task spawned by the thread, 
-which causes the depth-first execution until the thread runs out of work. 
-Then rule 3 applies. It steals the *oldest* task spawned by another thread, 
-which causes temporary breadth-first execution that converts potential parallelism 
-into actual parallelism.
@@ -325,129 +325,3 @@ task:
        }
        tg.wait();
    }
-
-
-Scheduler Bypass
----------------
-
-TBB ``task::execute()`` method can return a pointer to a task that can be executed next by the current thread.
-This might reduce scheduling overheads compared to direct ``spawn``. Similar to ``spawn``, the returned task 
-is not guaranteed to be executed next by the current thread.
-
-.. code:: cpp
-    
-    #include <tbb/task.h>
-    
-    // Assuming OtherTask is defined.
-    
-    struct Task : tbb::task {
-        task* execute(){
-            // some work to do ...
-            
-            auto* other_p = new(this->parent().allocate_child()) OtherTask{};
-            this->parent().add_ref_count();
-            
-            return other_p;
-        }
-    };
-    
-    int main(){
-        // Assuming RootTask is  defined.
-        RootTask& root = *new(tbb::task::allocate_root()) RootTask{};
-    
-        Task& child = *new(root.allocate_child()) Task{/*params*/};
-        
-        root.add_ref_count();
-        
-        tbb::task_spawn(child);
-        
-        root.wait_for_all();;
-    }
-
-In oneTBB, this can be done using ``oneapi::tbb::task_group``. 
-
-.. code:: cpp
-   
-    #include <oneapi/tbb/task_group.h>
-    
-    // Assuming OtherTask is defined.
-    
-    int main(){
-        oneapi::tbb::task_group tg;
-        
-        tg.run([&tg](){
-            //some work to do ...
-            
-            return tg.defer(OtherTask{});
-        });
-        
-        tg.wait();
-    }
-
-Here ``oneapi::tbb::task_group::defer`` adds a new task into the ``tg``. However, the task is not put into a 
-queue of tasks ready for execution via ``oneapi::tbb::task_group::run``, but bypassed to the executing thread directly 
-via function return value. 
-
-Deferred task creation
----------------------
-The TBB low-level task API separates the task creation from the actual spawning. This separation allows to
-postpone the task spawning, while the parent task and final result production are blocked from premature leave. 
-For example, ``RootTask``, ``ChildTask``, and ``CallBackTask`` are the user-side functors that
-inherit ``tbb::task`` and implement its interface. Then, blocking the ``RootTask`` from leaving prematurely
-and waiting on it is implemented as follows: 
-
-.. code:: cpp
-
-    #include <tbb/task.h>
-
-    int main() {
-        // Assuming RootTask, ChildTask, and CallBackTask are defined.
-        RootTask& root = *new(tbb::task::allocate_root()) RootTask{};
-
-        ChildTask&    child    = *new(root.allocate_child()) ChildTask{/*params*/};
-        CallBackTask& cb_task  = *new(root.allocate_child()) CallBackTask{/*params*/};
-
-        root.set_ref_count(3);
-        
-        tbb::task::spawn(child);
-        
-        register_callback([cb_task&](){
-            tbb::task::enqueue(cb_task);
-        });
-
-        root.wait_for_all();
-        // Control flow will reach here only after both ChildTask and CallBackTask are executed,
-        // i.e. after the callback is called  
-    }
-
-In oneTBB, this can be done using ``oneapi::tbb::task_group``.
-
-.. code:: cpp
-
-    #include <oneapi/tbb/task_group.h>
-
-    int main(){
-        oneapi::tbb::task_group tg;
-        oneapi::tbb::task_arena arena;
-        // Assuming ChildTask and CallBackTask are defined.
-        
-        auto cb = tg.defer(CallBackTask{/*params*/});
-        
-        register_callback([&tg, c = std::move(cb), &arena]{
-            arena.enqueue(c);
-        });        
-
-        tg.run(ChildTask{/*params*/});
-
- 
-        tg.wait();
-        // Control flow gets here once both ChildTask and CallBackTask are executed
-        // i.e. after the callback is called  
-    }
-
-Here ``oneapi::tbb::task_group::defer`` adds a new task into the ``tg``. However, the task is not spawned until 
-``oneapi::tbb::task_arena::enqueue`` is called. 
-
-.. note::
-   The call to ``oneapi::tbb::task_group::wait`` will not return control until both ``ChildTask`` and 
-   ``CallBackTask`` are executed.
@@ -145,11 +145,12 @@ allows waiting for oneTBB worker threads completion:

 .. code:: cpp

+    #define TBB_PREVIEW_WAITING_FOR_WORKERS 1
    #include <oneapi/tbb/global_control.h>
    #include <oneapi/tbb/parallel_for.h>

    int main() {
-        oneapi::tbb::task_scheduler_handle handle{tbb::attach{}};
+        oneapi::tbb::task_scheduler_handle handle = oneapi::tbb::task_scheduler_handle::get();
        // Do some parallel work here
        oneapi::tbb::parallel_for(/* ... */);
        oneapi::tbb::finalize(handle);
@@ -37,4 +37,12 @@ of the library.
        -      ``icc example.cpp -ltbb_debug``     


-.. include:: Parallelizing_Simple_Loops_toctree.rst
+
+.. toctree::
+   :maxdepth: 4
+
+   ../tbb_userguide/Initializing_and_Terminating_the_Library
+   ../tbb_userguide/parallel_for
+   ../tbb_userguide/parallel_reduce
+   ../tbb_userguide/Advanced_Example
+   ../tbb_userguide/Advanced_Topic_Other_Kinds_of_Iteration_Spaces
@@ -1,11 +0,0 @@
-.. _Parallelizing_Simple_Loops_toctree:
-
-
-.. toctree::
-   :maxdepth: 4
-
-   ../tbb_userguide/Initializing_and_Terminating_the_Library
-   ../tbb_userguide/parallel_for_os
-   ../tbb_userguide/parallel_reduce
-   ../tbb_userguide/Advanced_Example
-   ../tbb_userguide/Advanced_Topic_Other_Kinds_of_Iteration_Spaces
@@ -1,20 +0,0 @@
-.. _Task_Scheduler_Bypass:
-
-Task Scheduler Bypass
-=====================
-
-Scheduler bypass is an optimization where you directly specify the next task to run. 
-According to the rules of execution described in :doc:`How Task Scheduler Works <How_Task_Scheduler_Works>`, 
-the spawning of the new task to be executed by the current thread involves the next steps:
-
- -  Push a new task onto the thread's deque.
- -  Continue to execute the current task until it is completed.
- -  Take a task from the thread's deque, unless it is stolen by another thread.
-
-Steps 1 and 3 introduce unnecessary deque operations or, even worse, allow stealing that can hurt 
-locality without adding significant parallelism. These problems can be avoided by using "Task Scheduler Bypass" technique to directly point the preferable task to be executed next 
-instead of spawning it. When, as described in :doc:`How Task Scheduler Works <How_Task_Scheduler_Works>`,
-the returned task becomes the first candidate for the next task to be executed by the thread. Furthermore, this approach almost guarantees that 
-the task is executed by the current thread and not by any other thread.
-
-Please note that at the moment the only way to use this optimization is to use `preview feature of ``onepai::tbb::task_group`` 
@@ -0,0 +1,11 @@
+.. _Task_Scheduler_Summary:
+
+Task Scheduler Summary
+======================
+
+
+The task scheduler works most efficiently for fork-join parallelism with
+lots of forks, so that the task-stealing can cause sufficient
+breadth-first behavior to occupy threads, which then conduct themselves
+in a depth-first manner until they need to steal more work.
+
@@ -16,6 +16,5 @@ onto one of the high-level templates, use the task scheduler.

   ../tbb_userguide/Task-Based_Programming
   ../tbb_userguide/When_Task-Based_Programming_Is_Inappropriate
-   ../tbb_userguide/How_Task_Scheduler_Works
-   ../tbb_userguide/Task_Scheduler_Bypass
+   ../tbb_userguide/Task_Scheduler_Summary
   ../tbb_userguide/Guiding_Task_Scheduler_Execution
@@ -1,47 +0,0 @@
-.. _attach_flow_graph_to_arena:
-
-Attach Flow Graph to an Arbitrary Task Arena
-======================
-
-
-|short_name| ``task_arena`` interface provides mechanisms to guide tasks
-execution within the arena by setting the preferred computation units,
-restricting part of computation units, or limiting arena concurrency. In some
-cases, you may want to apply such mechanisms when a flow graph executes.
-
-During its construction, a ``graph`` object attaches to the arena, in which the constructing
-thread occupies a slot.
-
-This example shows how to set the most performant core type as the preferred one
-for a graph execution:
-
-
-.. literalinclude:: ./snippets/flow_graph_examples.cpp
-   :language: c++
-   :start-after: /*begin_attach_to_arena_1*/
-   :end-before: /*end_attach_to_arena_1*/
-
-
-A ``graph`` object can be reattached to a different ``task_arena`` by calling
-the ``graph::reset()`` function. It reinitializes and reattaches the ``graph`` to
-the task arena instance, inside which the ``graph::reset()`` method is executed.
-
-This example shows how to reattach existing graph to an arena with the most performant
-core type as the preferred one for a work execution. Whenever a task is spawned on behalf
-of the graph, it is spawned in the arena of a graph it is attached to, disregarding
-the arena of the thread that the task is spawned from:
-
-
-.. literalinclude:: ./snippets/flow_graph_examples.cpp
-   :language: c++
-   :start-after: /*begin_attach_to_arena_2*/
-   :end-before: /*end_attach_to_arena_2*/
-
-See the following topics to learn more:
-
-.. toctree::
-   :maxdepth: 4
-
-   ../tbb_userguide/Guiding_Task_Scheduler_Execution
-   ../tbb_userguide/work_isolation
-
@@ -51,7 +51,6 @@ expressions into equivalent C++03 code.
   ../../tbb_userguide/design_patterns/Divide_and_Conquer
   ../../tbb_userguide/design_patterns/GUI_Thread
   ../../tbb_userguide/design_patterns/Non-Preemptive_Priorities
-   ../../tbb_userguide/design_patterns/Lazy_Initialization
   ../../tbb_userguide/design_patterns/Local_Serializer
   ../../tbb_userguide/design_patterns/Fenced_Data_Transfer
   ../../tbb_userguide/design_patterns/Reference_Counting
@@ -1,109 +0,0 @@
-.. _Lazy_Initialization:
-
-Lazy Initialization
-==================
-
-
-.. container:: section
-
-
-   .. rubric:: Problem
-      :class: sectiontitle
-
-   Delay the creation of an object, potentially expensive, until it is accessed.
-   In parallel programming, initialization must also be guarded against race conditions.
-
-
-.. container:: section
-
-
-   .. rubric:: Context
-      :class: sectiontitle
-
-   The cost of operations that take place during the initialization
-   of the object may be considerably high. In that case, the object
-   should be initialized only when needed. Lazy initialization is
-   the common tactic that allows implementing such an approach.
-
-
-.. container:: section
-
-
-   .. rubric:: Solution
-      :class: sectiontitle
-
-   Using ``oneapi::tbb::collaborative_call_once`` with ``oneapi::tbb::collaborative_once_flag``
-   helps to implement thread-safe lazy initialization for a user object.
-
-
-   In addition, ``collaborative_call_once`` allows other thread blocked on
-   the same ``collaborative_once_flag`` to join other |short_name|
-   parallel constructions called within the initializing function.
-
-
-.. container:: section
-
-
-   .. rubric:: Example
-      :class: sectiontitle
-
-   This example illustrates the implementation of lazy initialization
-   for the calculation of the Fibonacci numbers. Here is a graphical
-   representation of the Fibonacci recursion tree for N=4.
-
-
-   |image0|
-
-
-   As seen in the diagram, some elements are recalculated more than once. These operations are redundant,
-   so the "lazy initialized" Fibonacci numbers are relevant here.
-
-
-   An implementation without the use of lazy initialization would have *O(2^N)* time complexity due to
-   the full recursion tree traversal and recalculation of values. Since all the nodes are traversed once,
-   the tree becomes a list, making the time complexity *O(N)*.
-
-
-   |image1|
-
-
-   Here you can see the code for the implementation. Already calculated values are stored in a buffer
-   paired with ``collaborative_once_flag`` and will not be recalculated when ``collaborative_call_once``
-   is invoked when initialization has already been done.
-
-
-   ::
-
-
-      using FibBuffer = std::vector<std::pair<oneapi::tbb::collaborative_once_flag, std::uint64_t>>;
-
-      std::uint64_t LazyFibHelper(int n, FibBuffer& buffer) {
-         // Base case
-         if (n <= 1) {
-            return n;
-         }
-         // Calculate nth value only once and store it in the buffer.
-         // Other threads won't be blocked on already taken collaborative_once_flag
-         // but join parallelism inside functor
-         oneapi::tbb::collaborative_call_once(buffer[n].first, [&]() {
-            std::uint64_t a, b;
-            oneapi::tbb::parallel_invoke([&] { a = LazyFibHelper(n - 2, buffer); },
-                                         [&] { b = LazyFibHelper(n - 1, buffer); });
-            buffer[n].second = a + b;
-         });
-
-         return buffer[n].second;
-      }
-
-      std::uint64_t Fib(int n) {
-         FibBuffer buffer(n+1);
-         return LazyFibHelper(n, buffer);
-      }
-
-
-.. |image0| image:: Images/image008a.jpg
-   :width: 744px
-   :height: 367px
-.. |image1| image:: Images/image009a.jpg
-   :width: 744px
-   :height: 367px
@@ -9,7 +9,8 @@ You may not always want to block the main application thread by calling
 wait_for_all(). However, it is safest to call wait_for_all on a graph
 before destroying it. A common solution is to enqueue a task to build
 and wait for the graph to complete. For example, assume you really do
-not want to call a wait_for_all in the example from :ref:`always_use_wait_for_all`,
+not want to call a wait_for_all in the example from `Always Use
+wait_for_all() <always_use_wait_for_all.html#always_use_wait4all>`__,
 Instead you can enqueue a task that creates the graph and waits for it:


@@ -120,5 +120,11 @@ example uses the default grainsize of 1 because by default
 ``parallel_for`` applies a heuristic that works well with the default
 grainsize.

-.. include:: parallel_for_toctree.rst
-   
+.. toctree::
+   :maxdepth: 4
+
+   ../tbb_userguide/Lambda_Expressions
+   ../tbb_userguide/Automatic_Chunking
+   ../tbb_userguide/Controlling_Chunking
+   ../tbb_userguide/Bandwidth_and_Cache_Affinity
+   ../tbb_userguide/Partitioner_Summary
@@ -1,10 +0,0 @@
-.. _parallel_for_toctree:
-
-.. toctree::
-   :maxdepth: 4
-
-   ../tbb_userguide/Lambda_Expressions
-   ../tbb_userguide/Automatic_Chunking
-   ../tbb_userguide/Controlling_Chunking_os
-   ../tbb_userguide/Bandwidth_and_Cache_Affinity_os
-   ../tbb_userguide/Partitioner_Summary
@@ -1,76 +0,0 @@
-/*
-    Copyright (c) 2022 Intel Corporation
-
-    Licensed under the Apache License, Version 2.0 (the "License");
-    you may not use this file except in compliance with the License.
-    You may obtain a copy of the License at
-
-        http://www.apache.org/licenses/LICENSE-2.0
-
-    Unless required by applicable law or agreed to in writing, software
-    distributed under the License is distributed on an "AS IS" BASIS,
-    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-    See the License for the specific language governing permissions and
-    limitations under the License.
-*/
-
-/* Flow Graph Code Example for the Userguide.
-*/
-
-//! Enable extended task_arena constraints feature for supporting Intel Hybrid Technology
-//! and Intel Hyper-Threading Technology.
-#define TBB_PREVIEW_TASK_ARENA_CONSTRAINTS_EXTENSION 1
-
-#include <oneapi/tbb/flow_graph.h>
-#include <vector>
-
-using namespace tbb::flow;
-
-//! Example shows how to set the most performant core type as the preferred one
-//! for a graph execution.
-static void flow_graph_attach_to_arena_1() {
-/*begin_attach_to_arena_1*/
-    std::vector<tbb::core_type_id> core_types = tbb::info::core_types();
-    tbb::task_arena arena(
-        tbb::task_arena::constraints{}.set_core_type(core_types.back())
-    );
-
-    arena.execute( [&]() {
-        graph g;
-        function_node< int > f( g, unlimited, []( int ) {
-             /*the most performant core type is defined as preferred.*/
-        } );
-        f.try_put(1);
-        g.wait_for_all();
-    } );
-/*end_attach_to_arena_1*/
-}
-
-//! Reattach existing graph to an arena with the most performant core type as
-//! the preferred one for a work execution.
-static void flow_graph_attach_to_arena_2() {
-/*begin_attach_to_arena_2*/
-    graph g;
-    function_node< int > f( g, unlimited, []( int ) {
-        /*the most performant core type is defined as preferred.*/
-    } );
-
-    std::vector<tbb::core_type_id> core_types = tbb::info::core_types();
-    tbb::task_arena arena(
-        tbb::task_arena::constraints{}.set_core_type(core_types.back())
-    );
-
-    arena.execute( [&]() {
-        g.reset();
-    } );
-    f.try_put(1);
-    g.wait_for_all();
-/*end_attach_to_arena_2*/
-}
-
-int main() {
-    flow_graph_attach_to_arena_1();
-    flow_graph_attach_to_arena_2();
-
-    return 0;
-}
@@ -9,7 +9,7 @@
   :maxdepth: 4

   ../tbb_userguide/Package_Contents
-   ../tbb_userguide/Parallelizing_Simple_Loops_os
+   ../tbb_userguide/Parallelizing_Simple_Loops
   ../tbb_userguide/Parallelizing_Complex_Loops
   ../tbb_userguide/Flow_Graph
   ../tbb_userguide/work_isolation
@@ -7,7 +7,8 @@ Use graph::reset() to Reset a Canceled Graph
 When a graph execution is canceled either because of an unhandled
 exception or because its task_group_context is canceled explicitly, the
 graph and its nodes may be left in an indeterminate state. For example,
-in the code samples shown in :ref:`cancel_a_graph` the input 2 may be
+in the code samples shown in `Cancel a Graph
+Explicitly <cancel_a_graph.html#cancel_a_graph>`__ the input 2 may be
 left in a buffer. But even beyond remnants in the buffers, there are
 other optimizations performed during the execution of a flow graph that
 can leave its nodes and edges in an indeterminate state. If you want to
@@ -29,7 +29,8 @@ All ``input_node`` objects are constructed in the inactive state and usually
 activated after the entire flow graph is constructed.


-For example, you can use the code in :ref:`Data_Flow_Graph`. In that implementation,
+For example, you can use the code in `Data Flow
+Graph <Data_Flow_Graph.html#Data_Flow_Graph>`__. In that implementation,
 the ``input_node`` is constructed in the inactive state and activated after
 all other edges are made:

@@ -1,53 +0,0 @@
-@ECHO OFF
-
-rem ============================================================================
-rem Copyright (C) 2022 Intel Corporation
-rem
-rem Licensed under the Apache License, Version 2.0 (the "License");
-rem you may not use this file except in compliance with the License.
-rem You may obtain a copy of the License at
-rem
-rem     http://www.apache.org/licenses/LICENSE-2.0
-rem
-rem Unless required by applicable law or agreed to in writing, software
-rem distributed under the License is distributed on an "AS IS" BASIS,
-rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-rem See the License for the specific language governing permissions and
-rem limitations under the License.
-rem ============================================================================
-
-
-
-pushd %~dp0
-
-REM Command file for Sphinx documentation
-
-if "%SPHINXBUILD%" == "" (
-	set SPHINXBUILD=sphinx-build
-)
-set SOURCEDIR=doc
-set BUILDDIR=build
-
-if "%1" == "" goto help
-
-%SPHINXBUILD% >NUL 2>NUL
-if errorlevel 9009 (
-	echo.
-	echo.The 'sphinx-build' command was not found. Make sure you have Sphinx
-	echo.installed, then set the SPHINXBUILD environment variable to point
-	echo.to the full path of the 'sphinx-build' executable. Alternatively you
-	echo.may add the Sphinx directory to PATH.
-	echo.
-	echo.If you don't have Sphinx installed, grab it from
-	echo.http://sphinx-doc.org/
-	exit /b 1
-)
-
-%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
-goto end
-
-:help
-%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
-
-:end
-popd
@@ -121,7 +121,6 @@ if  (NOT _find_index EQUAL -1)
    elseif ("${EXAMPLES_UI_MODE}" STREQUAL "x")
        set_x_ui_project_settings()
    endif()
-    target_compile_options(UI_LIB_${PROJECT_NAME} PRIVATE ${TBB_CXX_STD_FLAG})
 endif()

 unset(_available_ui_modes)
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2022 Intel Corporation
+    Copyright (c) 2005-2021 Intel Corporation

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
@@ -19,9 +19,9 @@

 #include "video.hpp"

-unsigned int *g_pImg = nullptr;
+unsigned int *g_pImg = 0;
 int g_sizex, g_sizey;
-static video *g_video = nullptr;
+static video *g_video = 0;
 static int g_fps = 0;

 #if _WIN32 || _WIN64
@@ -52,7 +52,7 @@ video::video()
          red_mask(0xff),
          green_mask(0xff00),
          blue_mask(0xff0000) {
-    assert(g_video == nullptr);
+    assert(g_video == 0);
    g_video = this;
    title = "Video";
    updating = calc_fps = false;
@@ -87,11 +87,12 @@ void video::terminate() {
        printf("%s: %.1f fps\n", title, fps);
    }
 #endif
-    g_video = nullptr;
+    g_video = 0;
    running = false;
-
-    delete[] g_pImg;
-    g_pImg = nullptr;
+    if (g_pImg) {
+        delete[] g_pImg;
+        g_pImg = 0;
+    }
 }

 video::~video() {
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2022 Intel Corporation
+    Copyright (c) 2005-2021 Intel Corporation

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
@@ -59,7 +59,7 @@ void DrawBitmap() {
    if (m_pRenderTarget) {
        m_pRenderTarget->BeginDraw();
        if (m_pBitmap)
-            hr = m_pBitmap->CopyFromMemory(nullptr, (BYTE *)g_pImg, 4 * g_sizex);
+            hr = m_pBitmap->CopyFromMemory(NULL, (BYTE *)g_pImg, 4 * g_sizex);
        DisplayError("DrawBitmap error", hr);
        m_pRenderTarget->DrawBitmap(m_pBitmap);
        m_pRenderTarget->EndDraw();
@@ -82,7 +82,7 @@ LRESULT CALLBACK InternalWndProc(HWND hwnd, UINT iMsg, WPARAM wParam, LPARAM lPa
            // Check to make sure our window exists before we tell it to repaint.
            // This will fail the first time (while the window is being created).
            if (hwnd) {
-                InvalidateRect(hwnd, nullptr, FALSE);
+                InvalidateRect(hwnd, NULL, FALSE);
                UpdateWindow(hwnd);
            }
            return 0L;
@@ -162,11 +162,12 @@ void video::terminate() {
        m_pRenderTarget->Release();
    if (m_pD2DFactory)
        m_pD2DFactory->Release();
-    g_video = nullptr;
+    g_video = 0;
    running = false;
-
-    delete[] g_pImg;
-    g_pImg = nullptr;
+    if (g_pImg) {
+        delete[] g_pImg;
+        g_pImg = 0;
+    }
 }

 //////////// drawing area constructor & destructor /////////////
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2022 Intel Corporation
+    Copyright (c) 2005-2021 Intel Corporation

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
@@ -40,12 +40,12 @@ bool DisplayError(LPSTR lpstrErr, HRESULT hres) {
            hres = GetLastError();
        FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |
                          FORMAT_MESSAGE_IGNORE_INSERTS,
-                      nullptr,
+                      NULL,
                      hres,
                      MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
                      (LPTSTR)&lpMsgBuf,
                      0,
-                      nullptr);
+                      NULL);
        retval = MessageBox(g_hAppWnd, lpstrErr, lpMsgBuf, MB_OK | MB_ICONERROR);
        LocalFree((HLOCAL)lpMsgBuf);
        InError = false;
@@ -60,7 +60,7 @@ LRESULT CALLBACK InternalWndProc(HWND hwnd, UINT iMsg, WPARAM wParam, LPARAM lPa
            // Check to make sure our window exists before we tell it to repaint.
            // This will fail the first time (while the window is being created).
            if (hwnd) {
-                InvalidateRect(hwnd, nullptr, FALSE);
+                InvalidateRect(hwnd, NULL, FALSE);
                UpdateWindow(hwnd);
            }
            return 0L;
@@ -114,7 +114,7 @@ bool video::init_window(int sizex, int sizey) {
        return false;
    }
    ShowWindow(g_hAppWnd, SW_SHOW);
-    Gdiplus::GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, nullptr);
+    Gdiplus::GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL);
    g_pImg = new unsigned int[sizex * sizey];
    g_pBitmap =
        new Gdiplus::Bitmap(g_sizex, g_sizey, 4 * g_sizex, PixelFormat32bppRGB, (BYTE*)g_pImg);
@@ -123,15 +123,17 @@ bool video::init_window(int sizex, int sizey) {
 }

 void video::terminate() {
-    delete g_pBitmap;
-    g_pBitmap = nullptr;
-
+    if (g_pBitmap) {
+        delete g_pBitmap;
+        g_pBitmap = 0;
+    }
    Gdiplus::GdiplusShutdown(gdiplusToken);
-    g_video = nullptr;
+    g_video = 0;
    running = false;
-
-    delete[] g_pImg;
-    g_pImg = nullptr;
+    if (g_pImg) {
+        delete[] g_pImg;
+        g_pImg = 0;
+    }
 }

 //////////// drawing area constructor & destructor /////////////
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2022 Intel Corporation
+    Copyright (c) 2005-2021 Intel Corporation

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
@@ -20,11 +20,11 @@
 #include <iostream>
 #include <pthread.h>

-unsigned int *g_pImg = nullptr;
+unsigned int *g_pImg = 0;
 int g_sizex = 0, g_sizey = 0;
-static video *g_video = nullptr;
+static video *g_video = 0;
 static int g_fps = 0;
-char *window_title = nullptr;
+char *window_title = NULL;
 #define WINDOW_TITLE_SIZE 256
 int cocoa_update = 0;

@@ -51,7 +51,7 @@ video::video()
          blue_mask(0xff)
 #endif
 {
-    assert(g_video == nullptr);
+    assert(g_video == 0);
    g_video = this;
    title = "Video";
    cocoa_update = 1;
@@ -63,7 +63,7 @@ bool video::init_window(int x, int y) {
    g_sizex = x;
    g_sizey = y;
    g_pImg = new unsigned int[x * y];
-    if (window_title == nullptr)
+    if (window_title == NULL)
        window_title = (char *)malloc(WINDOW_TITLE_SIZE);
    strncpy(window_title, title, WINDOW_TITLE_SIZE - 1);
    running = true;
@@ -85,11 +85,12 @@ void video::terminate() {
               (g_time.tv_sec + 1.0 * g_time.tv_usec / 1000000.0);
        printf("%s: %.1f fps\n", title, fps);
    }
-    g_video = nullptr;
+    g_video = 0;
    running = false;
-
-    delete[] g_pImg;
-    g_pImg = nullptr;
+    if (g_pImg) {
+        delete[] g_pImg;
+        g_pImg = 0;
+    }
 }

 video::~video() {
@@ -150,9 +151,9 @@ void video::main_loop() {
    pthread_t handle;
    pthread_attr_t attr;
    pthread_attr_init(&attr);
-    pthread_create(&handle, &attr, &thread_func, (void *)nullptr);
+    pthread_create(&handle, &attr, &thread_func, (void *)NULL);
    pthread_detach(handle);
-    cocoa_main(0, nullptr);
+    cocoa_main(0, NULL);
 }

 //! Change window title
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2022 Intel Corporation
+    Copyright (c) 2005-2021 Intel Corporation

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
@@ -73,7 +73,7 @@ bool WinInit(HINSTANCE hInstance,
    }
    else {
        memset(&wndclass, 0, sizeof(wndclass));
-        wndclass.hCursor = LoadCursor(nullptr, IDC_ARROW);
+        wndclass.hCursor = LoadCursor(NULL, IDC_ARROW);
        wndclass.lpszClassName = title;
    }
    wndclass.cbSize = sizeof(wndclass);
@@ -99,11 +99,11 @@ bool WinInit(HINSTANCE hInstance,
                              0, // Initial y pos: not used here
                              g_sizex + xaddend, // Initial x size
                              g_sizey + yaddend, // Initial y size
-                              nullptr, // parent window handle
-                              nullptr, // window menu handle
+                              NULL, // parent window handle
+                              NULL, // window menu handle
                              hInstance, // program instance handle
-                              nullptr); // Creation parameters
-    return g_hAppWnd != nullptr;
+                              NULL); // Creation parameters
+    return g_hAppWnd != NULL;
 }

 //! create console window with redirection
@@ -127,7 +127,7 @@ static bool RedirectIOToConsole(void) {
        return false;
    fp = _fdopen(hConHandle, "w");
    *stdout = *fp;
-    setvbuf(stdout, nullptr, _IONBF, 0);
+    setvbuf(stdout, NULL, _IONBF, 0);

    // redirect unbuffered STDERR to the console
    lStdHandle = (size_t)GetStdHandle(STD_ERROR_HANDLE);
@@ -135,7 +135,7 @@ static bool RedirectIOToConsole(void) {
    if (hConHandle > 0) {
        fp = _fdopen(hConHandle, "w");
        *stderr = *fp;
-        setvbuf(stderr, nullptr, _IONBF, 0);
+        setvbuf(stderr, NULL, _IONBF, 0);
    }

    // redirect unbuffered STDIN to the console
@@ -144,7 +144,7 @@ static bool RedirectIOToConsole(void) {
    if (hConHandle > 0) {
        fp = _fdopen(hConHandle, "r");
        *stdin = *fp;
-        setvbuf(stdin, nullptr, _IONBF, 0);
+        setvbuf(stdin, NULL, _IONBF, 0);
    }

    // make cout, wcout, cin, wcin, wcerr, cerr, wclog and clog
@@ -229,7 +229,7 @@ static bool loop_once(video *v) {
    }
    // event processing, including painting
    MSG msg;
-    if (PeekMessage(&msg, nullptr, 0, 0, PM_REMOVE)) {
+    if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
        if (msg.message == WM_QUIT) {
            v->running = false;
            return false;
@@ -255,7 +255,7 @@ void video::main_loop() {
    g_msec = GetTickCount();
    // now, start main process
    if (threaded) {
-        g_handles[0] = CreateThread(nullptr, // LPSECURITY_ATTRIBUTES security_attrs
+        g_handles[0] = CreateThread(NULL, // LPSECURITY_ATTRIBUTES security_attrs
                                    0, // SIZE_T stacksize
                                    (LPTHREAD_START_ROUTINE)thread_video,
                                    this, // argument
@@ -266,7 +266,7 @@ void video::main_loop() {
            return;
        }
        else // harmless race is possible here
-            g_handles[1] = CreateEvent(nullptr, false, false, nullptr);
+            g_handles[1] = CreateEvent(NULL, false, false, NULL);
        while (running) {
            while (loop_once(this))
                ;
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2022 Intel Corporation
+    Copyright (c) 2005-2021 Intel Corporation

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
@@ -56,8 +56,8 @@ static Pixmap pixmap = 0;
 static bool already_called_X_ShmAttach = false;
 static bool already_advised_about_NOSHMEM_workarounds = false;
 #endif
-static char *display_name = nullptr;
-static Display *dpy = nullptr;
+static char *display_name = NULL;
+static Display *dpy = NULL;
 static Screen *scrn;
 static Visual *vis;
 static Colormap cmap;
@@ -181,7 +181,7 @@ bool video::init_window(int xsize, int ysize) {
        sh.flags = PSize | PMinSize | PMaxSize;
        sh.width = sh.min_width = sh.max_width = xsize;
        sh.height = sh.min_height = sh.max_height = ysize;
-        XSetStandardProperties(dpy, win, g_video->title, g_video->title, None, nullptr, 0, &sh);
+        XSetStandardProperties(dpy, win, g_video->title, g_video->title, None, NULL, 0, &sh);
        _XA_WM_DELETE_WINDOW = XInternAtom(dpy, "WM_DELETE_WINDOW", false);
        XSetWMProtocols(dpy, win, &_XA_WM_DELETE_WINDOW, 1);
        gc = XCreateGC(dpy, win, 0L, &xgcv);
@@ -206,7 +206,7 @@ bool video::init_window(int xsize, int ysize) {
            g_pImg = (unsigned int *)(shmseginfo.shmaddr = (char *)shmat(shmseginfo.shmid, 0, 0));
            if (g_pImg == (unsigned int *)-1) {
                fprintf(stderr, "Warning: Can't attach to shared memory: %s\n", strerror(errno));
-                shmctl(shmseginfo.shmid, IPC_RMID, nullptr);
+                shmctl(shmseginfo.shmid, IPC_RMID, NULL);
                goto generic;
            }
            shmseginfo.readOnly = false;
@@ -218,7 +218,7 @@ bool video::init_window(int xsize, int ysize) {
                        err,
                        x_error);
                shmdt(shmseginfo.shmaddr);
-                shmctl(shmseginfo.shmid, IPC_RMID, nullptr);
+                shmctl(shmseginfo.shmid, IPC_RMID, NULL);
                goto generic;
            }
            already_called_X_ShmAttach = true;
@@ -323,7 +323,7 @@ void video::terminate() {
            g_pImg = 0;
        }
        if (shmseginfo.shmid >= 0)
-            shmctl(shmseginfo.shmid, IPC_RMID, nullptr);
+            shmctl(shmseginfo.shmid, IPC_RMID, NULL);
 #endif
        if (gc)
            XFreeGC(dpy, gc);
@@ -125,8 +125,8 @@ void ParallelEvolution::Run(double execution_time, int nthread) {
            break;
        }
    }
-    delete pGlobControl;
-    pGlobControl = nullptr;
+    if (pGlobControl)
+        delete pGlobControl;
 }

 /**
@@ -124,8 +124,8 @@ public:

    ~ParallelEvolution() {
        //! delete global_control object
-        delete m_pGlobControl;
-        m_pGlobControl = nullptr;
+        if (m_pGlobControl != nullptr)
+            delete m_pGlobControl;
    }
    virtual void Run(double execution_time, int nthread);
    virtual void Step();
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2022 Intel Corporation
+    Copyright (c) 2005-2021 Intel Corporation

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
@@ -98,7 +98,7 @@ bool ParseCommandLine(int argc, char* argv[]) {
        high = strtol(s, &end, 0);
    low = strtol(s, &end, 0);
    switch (*end) {
-        case ':': high = strtol(end + 1, nullptr, 0); break;
+        case ':': high = strtol(end + 1, 0, 0); break;
        case '\0': break;
        default: PrintUsage(); return false;
    }
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2022 Intel Corporation
+    Copyright (c) 2005-2021 Intel Corporation

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
@@ -167,7 +167,7 @@ bool ParseCmdLine(int argc, char *argv[]) {
        char *end;
        gThreadsHigh = gThreadsLow = (int)strtol(argv[0], &end, 0);
        switch (*end) {
-            case ':': gThreadsHigh = (int)strtol(end + 1, nullptr, 0); break;
+            case ':': gThreadsHigh = (int)strtol(end + 1, 0, 0); break;
            case '\0': break;
            default:
                std::cout << "Unexpected character in thread specifier: " << *end << "\n";
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2022 Intel Corporation
+    Copyright (c) 2005-2021 Intel Corporation

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
@@ -19,9 +19,9 @@

 #include "pover_global.hpp" // for declaration of DEFINE and INIT

-DEFINE Polygon_map_t *gPolymap1 INIT(nullptr);
-DEFINE Polygon_map_t *gPolymap2 INIT(nullptr);
-DEFINE Polygon_map_t *gResultMap INIT(nullptr);
+DEFINE Polygon_map_t *gPolymap1 INIT(0);
+DEFINE Polygon_map_t *gPolymap2 INIT(0);
+DEFINE Polygon_map_t *gResultMap INIT(0);

 extern void Usage(int argc, char *argv[]);

@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2022 Intel Corporation
+    Copyright (c) 2005-2021 Intel Corporation

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
@@ -22,7 +22,7 @@

 #include "pover_global.hpp" // for declaration of DEFINE and INIT

-DEFINE class video *gVideo INIT(nullptr);
+DEFINE class video *gVideo INIT(0);

 DEFINE int n_next_frame_calls INIT(0);
 DEFINE int frame_skips INIT(10);
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2022 Intel Corporation
+    Copyright (c) 2005-2021 Intel Corporation

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
@@ -74,7 +74,7 @@ bool global_usegraphics;

 bool silent_mode = false; /* silent mode */

-class tachyon_video *video = nullptr;
+class tachyon_video *video = 0;

 typedef struct {
    int foundfilename; /* was a model file name found in the args? */
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2022 Intel Corporation
+    Copyright (c) 2005-2021 Intel Corporation

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
@@ -82,6 +82,6 @@ void renderscene(scenedef scene) {
  outfile = opentgafile(scene.outfilename);
  */

-    trace_region(scene, nullptr /*outfile*/, 0, 0, scene.hres, scene.vres);
+    trace_region(scene, 0 /*outfile*/, 0, 0, scene.hres, scene.vres);
    //fclose((FILE *)outfile);
 } /* end of renderscene() */
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2022 Intel Corporation
+    Copyright (c) 2005-2021 Intel Corporation

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
@@ -87,7 +87,7 @@ private:
    }

 public:
-    fractal_video() : fg(nullptr) {
+    fractal_video() : fg(0) {
        title = "oneTBB: Fractal Example";
        v = this;
    }
@@ -1 +1 @@
 .0.0
 .1.0