New doc

* Signed-off-by:Alexandra Epanchinzeva alexandra.epanchinzeva@intel.com

* Minor fixes

* Update CONTRIBUTING.md

* Update CONTRIBUTING.md

* Update CONTRIBUTING.md

.bazelrc

@@ -0,0 +1,19 @@
+# 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.
+# 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.
+
+# DISCLAIMER: Bazel support is community-based. The maintainers do not
+# use Bazel internally. The Bazel build can have security risks or 
+# optimization gaps.
+
+build --symlink_prefix=/ # Out of source build

.bazelversion

@@ -0,0 +1 @@
+4.1.0

.gitattributes

@@ -0,0 +1,45 @@
+# Set the default behavior, in case people don't have core.autocrlf set.
+* text=auto
+
+# Explicitly declare text files you want to always be normalized and converted
+# to native line endings on checkout.
+*.c text
+*.h text
+*.cpp text
+*.def text
+*.rc text
+*.i text
+*.sh text
+*.csh text
+*.mk text
+*.java text
+*.csv text
+*.lst text
+*.asm text
+*.cfg text
+*.css text
+*.inc text
+*.js text
+*.rb text
+*.strings text
+*.txt text
+*export.lst text
+*.xml text
+*.py text
+*.md text
+*.classpath text
+*.cproject text
+*.project text
+*.properties text
+*.java text
+*.gradle text
+
+# Declare files that will always have CRLF line endings on checkout.
+*.sln text eol=crlf
+*.bat text eol=crlf
+
+# Denote all files that are truly binary and should not be modified.
+*.png binary
+*.jpg binary
+*.ico binary
+*.spir binary

.github/scripts/codespell.sh

@@ -0,0 +1,60 @@
+#!/bin/bash
+#
+# 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.
+# 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.
+
+SCAN_TARGET=$1
+
+SKIP_PATTERN='*/.github/*'
+
+# Ignored cases
+IGNORE_COMMAND="sed -e /.*\\sOd\\s*=.*/d \
+-e /.*\\sOt\\s*=.*/d \
+-e /.*\\siff\\s*=.*/d \
+-e /.*\\sith\\s*=.*/d \
+-e /.*\\scas\\s*=.*/d \
+-e /.*\\sCAS\\s*=.*/d \
+-e /.*\\ssom\\s*=.*/d \
+-e /.*\\sSOM\\s*=.*/d \
+-e /.*\\suint\\s*=.*/d \
+-e /.*\\sUINT\\s*=.*/d \
+-e /.*\\scopyable\\s*=.*/d \
+-e /.*\\sCopyable\\s*=.*/d \
+-e /.*\\sFo\\s*=.*/d \
+-e /.*pipeline_filters.h.*nd\\s*=.*/d \
+-e /.*ittnotify.h.*unx\\s*=.*/d \
+-e /.*bzlib.cpp.*MSDOS\\s*=.*/d \
+-e /.*test_task.cpp.*tE\\s*=.*/d \
+-e /.*backend.cpp.*resSize\\s*=.*/d \
+-e /.*test_join_node.h.*Ned\\s*=.*/d \
+-e /.*test_indexer_node.cpp.*OT\\s*=.*/d \
+-e /.*allocator_stl_test_common.h.*Aci*\\s*=.*/d \
+-e /.*seismic_video.cpp.*DialogBox\\s*=.*/d \
+-e /.*test_composite_node.cpp.*que\\s*=.*/d \
+-e /.*blocksort.cpp.*hiSt\\s*=.*/d \
+-e /.*compress.cpp.*fave\\s*=.*/d \
+-e /.*count_strings.cpp.*ue\\s*=.*/d \
+-e /.*count_strings.cpp.*nd\\s*=.*/d \
+-e /.*count_strings.cpp.*ths\\s*=.*/d \
+-e /.*polygon_overlay\/README.md.*ist\\s*=.*/d \
+-e /.*_pipeline_filters.h.*nd\\s*=.*/d \
+-e /.*sub_string_finder\/README.md.*ba\\s*=.*/d"
+
+SCAN_RESULT=`codespell --quiet-level=2 --skip "${SKIP_PATTERN}" ${SCAN_TARGET}`
+SCAN_RESULT=`echo -e "${SCAN_RESULT}" | ${IGNORE_COMMAND}`
+echo "${SCAN_RESULT}"
+
+if [[ ! -z ${SCAN_RESULT} ]]; then
+    exit 1
+fi

.github/workflows/ci.yml

@@ -0,0 +1,316 @@
+# 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.
+# 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.
+
+name: oneTBB CI
+
+on:
+  push:
+    branches: [master]
+
+  pull_request:
+    branches: [master]
+    types:
+      - opened
+      - synchronize
+      - reopened
+
+env:
+  BUILD_CONCURRENCY: 2
+  MACOS_BUILD_CONCURRENCY: 3
+  TEST_TIMEOUT: 180
+
+jobs:
+  codespell:
+    runs-on: [ubuntu-20.04]
+    timeout-minutes: 10
+    steps:
+      - uses: actions/checkout@v2
+      - name: Run scan
+        run: |
+          sudo apt update && sudo apt install -y codespell
+          ${GITHUB_WORKSPACE}/.github/scripts/codespell.sh `pwd`
+
+  examples_clang-format:
+    runs-on: [ubuntu-20.04]
+    timeout-minutes: 10
+    steps:
+      - uses: actions/checkout@v2
+      - name: Run scan
+        run: |
+          cp -r examples examples_formatted
+          find examples_formatted -regex '.*\.\(cpp\|hpp\)' -exec clang-format-9 -style=file -i {} \;
+          diff -r examples examples_formatted
+
+  documentation:
+    needs: [codespell]
+    env:
+      BUILD_TYPE: oss
+    runs-on: [ubuntu-20.04]
+    timeout-minutes: 10
+    steps:
+      - uses: actions/checkout@v2
+      - name: Install prerequisites
+        run: |
+          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/main html
+          tar -czvf html.tar.gz html/
+      - name: Save docs
+        uses: actions/upload-artifact@v2.2.1
+        with:
+          name: oneTBB-html-docs-${{ env.GITHUB_SHA_SHORT }}
+          path: html.tar.gz
+
+  pages:
+    if: ${{ github.ref == 'refs/heads/master' }}
+    runs-on: ubuntu-latest
+    needs: [documentation]
+    steps:
+      - name: Checkout gh-pages
+        uses: actions/checkout@v2
+        with:
+          ref: gh-pages
+          path: gh-pages
+      - name: Set env
+        run: echo GITHUB_SHA_SHORT=${GITHUB_SHA::8} >> $GITHUB_ENV
+      - name: Download documetation
+        uses: actions/download-artifact@v2
+        with:
+          name: oneTBB-html-docs-${{ env.GITHUB_SHA_SHORT }}
+      - name: Publish to github pages
+        run: |
+          tar -xvf html.tar.gz
+          cd gh-pages
+          rm -rf *
+          touch .nojekyll # https://github.blog/2009-12-29-bypassing-jekyll-on-github-pages/
+          cp -r ../html/* .
+          git config user.name github-actions
+          git config user.email github-actions@github.com
+          git add .
+          git commit --reset-author --amend -m "Update from GitHub Actions"
+          git push --force origin gh-pages
+
+  python_module_test_ubuntu18-04:
+    runs-on: [ubuntu-18.04]
+    timeout-minutes: 15
+    steps:
+      - uses: actions/checkout@v2
+      - name: Run testing
+        run: |
+          mkdir build && cd build
+          cmake -DTBB4PY_BUILD=ON -DCMAKE_CXX_COMPILER=g++ -DCMAKE_C_COMPILER=gcc ..
+          make VERBOSE=1 -j${BUILD_CONCURRENCY} python_build
+          ctest -R python_test --output-on-failure --timeout ${TEST_TIMEOUT}
+
+  linux-testing:
+    name: ${{ matrix.os }}_${{ matrix.cxx_compiler }}_cxx${{ matrix.std }}_${{ matrix.build_type }}_preview=${{ matrix.preview }}
+    runs-on: ['${{ matrix.os }}']
+    timeout-minutes: 45
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-18.04
+            c_compiler: gcc
+            cxx_compiler: g++
+            std: 14
+            build_type: relwithdebinfo
+            preview: 'OFF'
+          - os: ubuntu-20.04
+            c_compiler: gcc
+            cxx_compiler: g++
+            std: 17
+            build_type: release
+            preview: 'ON'
+          - os: ubuntu-20.04
+            c_compiler: gcc-10
+            cxx_compiler: g++-10
+            std: 20
+            build_type: debug
+            preview: 'ON'
+    steps:
+      - uses: actions/checkout@v2
+      - name: Run testing
+        shell: bash
+        run: |
+          set -x
+          mkdir build && cd build
+          cmake -DCMAKE_CXX_STANDARD=${{ matrix.std }} -DCMAKE_BUILD_TYPE=${{ matrix.build_type }} \
+            -DCMAKE_CXX_COMPILER=${{ matrix.cxx_compiler }} -DCMAKE_C_COMPILER=${{ matrix.c_compiler }} -DTBB_CPF=${{ matrix.preview }} ..
+          make VERBOSE=1 -j${BUILD_CONCURRENCY}
+          ctest --timeout ${TEST_TIMEOUT} --output-on-failure
+
+  macos-testing:
+    name: ${{ matrix.os }}_${{ matrix.cxx_compiler }}_cxx${{ matrix.std }}_${{ matrix.build_type }}_preview=${{ matrix.preview }}
+    runs-on: ['${{ matrix.os }}']
+    timeout-minutes: 45
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: macos-10.15
+            c_compiler: clang
+            cxx_compiler: clang++
+            std: 14
+            build_type: relwithdebinfo
+            preview: 'ON'
+    steps:
+      - uses: actions/checkout@v2
+      - name: Run testing
+        shell: bash
+        run: |
+          set -x
+          mkdir build && cd build
+          cmake -DCMAKE_CXX_STANDARD=${{ matrix.std }} -DCMAKE_BUILD_TYPE=${{ matrix.build_type }} \
+            -DCMAKE_CXX_COMPILER=${{ matrix.cxx_compiler }} -DCMAKE_C_COMPILER=${{ matrix.c_compiler }} -DTBB_CPF=${{ matrix.preview }} ..
+          make VERBOSE=1 -j${MACOS_BUILD_CONCURRENCY}
+          ctest --timeout ${TEST_TIMEOUT} --output-on-failure
+
+  windows-testing:
+    name: ${{ matrix.job_name }}
+    runs-on: ['${{ matrix.os }}']
+    timeout-minutes: 45
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: windows-2016
+            generator: Visual Studio 15 2017
+            c_compiler: cl
+            cxx_compiler: cl
+            std: 14
+            build_type: relwithdebinfo
+            preview: 'ON'
+            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_cl2019_cxx17_relwithdebinfo_preview=OFF
+    steps:
+      - uses: actions/checkout@v2
+      - name: Run testing
+        run: |
+          mkdir build
+          cd build
+          cmake -G "${{ matrix.generator }}" -A x64 -DCMAKE_CXX_STANDARD=${{ matrix.std }} `
+            -DCMAKE_BUILD_TYPE=${{ matrix.build_type }} -DCMAKE_CXX_COMPILER=${{ matrix.cxx_compiler }} `
+            -DCMAKE_C_COMPILER=${{ matrix.c_compiler }} -DTBB_CPF=${{ matrix.preview }} ..
+          cmake --build . --config ${{ matrix.build_type }} -j -v
+          ctest -C ${{ matrix.build_type }} --timeout ${env:TEST_TIMEOUT} --output-on-failure
+
+  linux-examples-testing:
+    name: examples_${{ matrix.os }}_${{ matrix.cxx_compiler }}_cxx${{ matrix.std }}_${{ matrix.build_type }}_preview=${{ matrix.preview }}
+    runs-on: ['${{ matrix.os }}']
+    timeout-minutes: 20
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-18.04
+            c_compiler: gcc
+            cxx_compiler: g++
+            std: 14
+            build_type: relwithdebinfo
+            preview: 'OFF'
+          - os: ubuntu-20.04
+            c_compiler: gcc
+            cxx_compiler: g++
+            std: 17
+            build_type: release
+            preview: 'ON'
+          - os: ubuntu-20.04
+            c_compiler: gcc-10
+            cxx_compiler: g++-10
+            std: 20
+            build_type: debug
+            preview: 'ON'
+    steps:
+      - uses: actions/checkout@v2
+      - name: Run testing
+        shell: bash
+        run: |
+          set -x
+          mkdir build && cd build
+          cmake -DCMAKE_CXX_STANDARD=${{ matrix.std }} -DCMAKE_BUILD_TYPE=${{ matrix.build_type }} \
+            -DCMAKE_CXX_COMPILER=${{ matrix.cxx_compiler }} -DCMAKE_C_COMPILER=${{ matrix.c_compiler }} \
+            -DTBB_CPF=${{ matrix.preview }} -DTBB_TEST=OFF -DTBB_EXAMPLES=ON ..
+          cmake --build . -v --target light_test_examples
+
+  macos-examples-testing:
+    name: examples_${{ matrix.os }}_${{ matrix.cxx_compiler }}_cxx${{ matrix.std }}_${{ matrix.build_type }}_preview=${{ matrix.preview }}
+    runs-on: ['${{ matrix.os }}']
+    timeout-minutes: 20
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: macos-10.15
+            c_compiler: clang
+            cxx_compiler: clang++
+            std: 14
+            build_type: relwithdebinfo
+            preview: 'ON'
+    steps:
+      - uses: actions/checkout@v2
+      - name: Run testing
+        shell: bash
+        run: |
+          set -x
+          mkdir build && cd build
+          cmake -DCMAKE_CXX_STANDARD=${{ matrix.std }} -DCMAKE_BUILD_TYPE=${{ matrix.build_type }} \
+            -DCMAKE_CXX_COMPILER=${{ matrix.cxx_compiler }} -DCMAKE_C_COMPILER=${{ matrix.c_compiler }} \
+            -DTBB_CPF=${{ matrix.preview }} -DTBB_TEST=OFF -DTBB_EXAMPLES=ON ..
+          cmake --build . -v --target light_test_examples
+
+  windows-examples-testing:
+    name: ${{ matrix.job_name }}
+    runs-on: ['${{ matrix.os }}']
+    timeout-minutes: 20
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - 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_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_cl2019_cxx17_relwithdebinfo_preview=OFF
+    steps:
+      - uses: actions/checkout@v2
+      - name: Run testing
+        run: |
+          mkdir build
+          cd build
+          cmake -G "${{ matrix.generator }}" -A x64 -DCMAKE_CXX_STANDARD=${{ matrix.std }} `
+            -DCMAKE_BUILD_TYPE=${{ matrix.build_type }} -DCMAKE_CXX_COMPILER=${{ matrix.cxx_compiler }} `
+            -DCMAKE_C_COMPILER=${{ matrix.c_compiler }} -DTBB_CPF=${{ matrix.preview }} -DTBB_TEST=OFF -DTBB_EXAMPLES=ON ..
+          cmake --build . -v --target light_test_examples

.gitignore

@@ -0,0 +1,62 @@
+# -------- C++ --------
+# Prerequisites
+*.d
+
+# Compiled Object files
+*.slo
+*.lo
+*.o
+*.obj
+
+# Precompiled Headers
+*.gch
+*.pch
+
+# Compiled Dynamic libraries
+*.so
+*.so.*
+*.dylib
+*.dll
+
+# Fortran module files
+*.mod
+*.smod
+
+# Compiled Static libraries
+*.lai
+*.la
+*.a
+*.lib
+
+# Executables
+*.exe
+*.out
+*.app
+
+# -------- CMake --------
+CMakeCache.txt
+CMakeFiles
+CMakeScripts
+Testing
+Makefile
+cmake_install.cmake
+install_manifest.txt
+compile_commands.json
+CTestTestfile.cmake
+build/*
+
+# -------- Python --------
+__pycache__/
+*.py[cod]
+*$py.class
+
+# -------- IDE --------
+.vscode/*
+.vs/*
+out/*
+CMakeSettings.json
+
+# -------- CTags --------
+.tags
+.ctags
+

BUILD.bazel

@@ -0,0 +1,112 @@
+# 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.
+# 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.
+
+# DISCLAIMER: Bazel support is community-based. The maintainers do not
+# use Bazel internally. The Bazel build can have security risks or
+# optimization gaps.
+
+package(
+    default_visibility = ["//visibility:public"],
+)
+
+cc_library(
+    name = "tbb",
+    srcs = glob([
+        "src/tbb/*.cpp",
+        "src/tbb/*.h",
+    ]) + select({
+        "@platforms//cpu:x86_64": glob(["src/tbb/tools_api/**/*.h"]),
+        "//conditions:default": [],
+    }),
+    hdrs = glob([
+        "include/tbb/*.h",
+        "include/oneapi/*.h",
+        "include/oneapi/tbb/*.h",
+        "include/oneapi/tbb/detail/*.h",
+    ]),
+    copts = [
+        "-w",
+    ],
+    defines =
+        select({
+            "@platforms//cpu:x86_64": ["__TBB_NO_IMPLICIT_LINKAGE"],
+            "//conditions:default": [
+                "USE_PTHREAD",
+            ],
+        }),
+    includes = [
+        "include",
+    ],
+    linkopts =
+        select({
+            "@bazel_tools//platforms:windows": [],
+            "//conditions:default": [
+                "-ldl",
+                "-pthread",
+                "-lrt",
+            ],
+        }),
+    local_defines = select({
+        "@platforms//cpu:x86_64": [
+            "__TBB_USE_ITT_NOTIFY",
+        ],
+        "//conditions:default": [],
+    }) + [
+        "__TBB_BUILD",
+    ],
+    textual_hdrs = select({
+        "@platforms//cpu:x86_64": [
+            "src/tbb/tools_api/ittnotify_static.c",
+        ],
+        "//conditions:default": [],
+    }),
+)
+
+cc_library(
+    name = "tbbmalloc",
+    srcs =
+        glob([
+            "src/tbbmalloc/*.h",
+            "src/tbb/*.h",
+            "src/tbbmalloc_proxy/*.h",
+        ]) + [
+            "src/tbbmalloc/backend.cpp",
+            "src/tbbmalloc/backref.cpp",
+            "src/tbbmalloc/frontend.cpp",
+            "src/tbbmalloc/large_objects.cpp",
+            "src/tbbmalloc/tbbmalloc.cpp",
+        ],
+    hdrs = glob([
+        "include/tbb/*.h",
+        "include/oneapi/tbb/detail/*.h",
+        "include/oneapi/tbb/*.h",
+    ]),
+    includes = [
+        "include",
+    ],
+    local_defines = [
+        "__TBBMALLOC_BUILD",
+    ],
+)
+
+cc_library(
+    name = "tbbmalloc_proxy",
+    srcs = [
+        "src/tbbmalloc_proxy/function_replacement.cpp",
+        "src/tbbmalloc_proxy/proxy.cpp",
+    ],
+    deps = [
+        ":tbbmalloc",
+    ],
+)

Bazel.md

@@ -0,0 +1,60 @@
+# Bazel build support
+
+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.
+
+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.
+
+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).
+
+2. Create the following files in one folder (this folder will be considered as the workspace folder):
+
+_WORKSPACE.bazel_:
+```
+load("@bazel_tools//tools/build_defs/repo:git.bzl", "git_repository")
+
+git_repository(
+    name = "oneTBB",
+    branch = "master",
+    remote = "https://github.com/oneapi-src/oneTBB/",
+)
+```
+
+_BUILD_:
+```
+cc_binary(
+    name = "Demo",
+    srcs = ["main.cpp"],
+    deps = ["@oneTBB//:tbb"],
+)
+```
+
+_main.cpp_:
+```
+#include "oneapi/tbb/version.h"
+
+#include <iostream>
+
+int main() {
+    std::cout << "Hello from oneTBB "
+              << TBB_VERSION_MAJOR << "."
+              << TBB_VERSION_MINOR << "."
+              << TBB_VERSION_PATCH
+              << "!" << std::endl;
+
+    return 0;
+}
+```
+
+3. Switch to the folder where you create the files.
+
+4. Execute the command `bazel run //:Demo`.
+As an expected output, you should see the oneTBB version.

CMakeLists.txt

@@ -0,0 +1,278 @@
+# 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.
+# 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.
+
+cmake_minimum_required(VERSION 3.1)
+
+# Enable CMake policies
+
+if (POLICY CMP0091)
+    # The NEW behavior for this policy is to not place MSVC runtime library flags in the default
+    # CMAKE_<LANG>_FLAGS_<CONFIG> cache entries and use CMAKE_MSVC_RUNTIME_LIBRARY abstraction instead.
+    cmake_policy(SET CMP0091 NEW)
+elseif (DEFINED CMAKE_MSVC_RUNTIME_LIBRARY)
+    message(FATAL_ERROR "CMAKE_MSVC_RUNTIME_LIBRARY was defined while policy CMP0091 is not available. Use CMake 3.15 or newer.")
+endif()
+
+if (TBB_WINDOWS_DRIVER AND (NOT ("${CMAKE_MSVC_RUNTIME_LIBRARY}" STREQUAL MultiThreaded OR "${CMAKE_MSVC_RUNTIME_LIBRARY}" STREQUAL MultiThreadedDebug)))
+    message(FATAL_ERROR "Enabled TBB_WINDOWS_DRIVER requires CMAKE_MSVC_RUNTIME_LIBRARY to be set to MultiThreaded or MultiThreadedDebug.")
+endif()
+
+# Enable support of minimum supported macOS version flag
+if (APPLE)
+    if (NOT CMAKE_CXX_OSX_DEPLOYMENT_TARGET_FLAG)
+        set(CMAKE_CXX_OSX_DEPLOYMENT_TARGET_FLAG "-mmacosx-version-min=" CACHE STRING "Minimum macOS version flag")
+    endif()
+    if (NOT CMAKE_C_OSX_DEPLOYMENT_TARGET_FLAG)
+        set(CMAKE_C_OSX_DEPLOYMENT_TARGET_FLAG "-mmacosx-version-min=" CACHE STRING "Minimum macOS version flag")
+    endif()
+endif()
+
+# Until CMake 3.4.0 FindThreads.cmake requires C language enabled.
+# Enable C language before CXX to avoid possible override of CMAKE_SIZEOF_VOID_P.
+if (CMAKE_VERSION VERSION_LESS 3.4)
+    enable_language(C)
+endif()
+
+file(READ include/oneapi/tbb/version.h _tbb_version_info)
+string(REGEX REPLACE ".*#define TBB_VERSION_MAJOR ([0-9]+).*" "\\1" _tbb_ver_major "${_tbb_version_info}")
+string(REGEX REPLACE ".*#define TBB_VERSION_MINOR ([0-9]+).*" "\\1" _tbb_ver_minor "${_tbb_version_info}")
+string(REGEX REPLACE ".*#define TBB_VERSION_PATCH ([0-9]+).*" "\\1" _tbb_ver_patch "${_tbb_version_info}")
+string(REGEX REPLACE ".*#define TBB_INTERFACE_VERSION ([0-9]+).*" "\\1" TBB_INTERFACE_VERSION "${_tbb_version_info}")
+string(REGEX REPLACE ".*#define __TBB_BINARY_VERSION ([0-9]+).*" "\\1" TBB_BINARY_VERSION "${_tbb_version_info}")
+set(TBB_BINARY_MINOR_VERSION ${_tbb_ver_minor})
+set(TBBMALLOC_BINARY_VERSION 2)
+set(TBBBIND_BINARY_VERSION 3)
+
+project(TBB VERSION ${_tbb_ver_major}.${_tbb_ver_minor}.${_tbb_ver_patch} LANGUAGES CXX)
+unset(_tbb_ver_major)
+unset(_tbb_ver_minor)
+
+include(CheckCXXCompilerFlag)
+include(GNUInstallDirs)
+
+# ---------------------------------------------------------------------------------------------------------
+# Handle C++ standard version.
+if (NOT MSVC)  # no need to cover MSVC as it uses C++14 by default.
+    if (NOT CMAKE_CXX_STANDARD)
+        set(CMAKE_CXX_STANDARD 11)
+    endif()
+
+    if (CMAKE_CXX${CMAKE_CXX_STANDARD}_STANDARD_COMPILE_OPTION)  # if standard option was detected by CMake
+        set(CMAKE_CXX_STANDARD_REQUIRED ON)
+    else()  # if standard option wasn't detected by CMake (e.g. for Intel Compiler with CMake 3.1)
+        # TBB_CXX_STD_FLAG should be added to targets via target_compile_options
+        set(TBB_CXX_STD_FLAG -std=c++${CMAKE_CXX_STANDARD})
+
+        check_cxx_compiler_flag(${TBB_CXX_STD_FLAG} c++${CMAKE_CXX_STANDARD})
+        if (NOT c++${CMAKE_CXX_STANDARD})
+            message(FATAL_ERROR "C++${CMAKE_CXX_STANDARD} (${TBB_CXX_STD_FLAG}) support is required")
+        endif()
+        unset(c++${CMAKE_CXX_STANDARD})
+    endif()
+endif()
+
+set(CMAKE_CXX_EXTENSIONS OFF) # use -std=c++... instead of -std=gnu++...
+# ---------------------------------------------------------------------------------------------------------
+
+# Detect architecture (bitness).
+if (CMAKE_SIZEOF_VOID_P EQUAL 4)
+    set(TBB_ARCH 32)
+else()
+    set(TBB_ARCH 64)
+endif()
+
+option(TBB_TEST "Enable testing" ON)
+option(TBB_EXAMPLES "Enable examples" OFF)
+option(TBB_STRICT "Treat compiler warnings as errors" ON)
+option(TBB_WINDOWS_DRIVER "Build as Universal Windows Driver (UWD)" OFF)
+option(TBB_NO_APPCONTAINER "Apply /APPCONTAINER:NO (for testing binaries for Windows Store)" OFF)
+option(TBB4PY_BUILD "Enable tbb4py build" OFF)
+option(TBB_BUILD "Enable tbb build" ON)
+option(TBBMALLOC_BUILD "Enable tbbmalloc build" ON)
+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)
+
+if (NOT DEFINED BUILD_SHARED_LIBS)
+    set(BUILD_SHARED_LIBS ON)
+endif()
+
+if (NOT BUILD_SHARED_LIBS)
+    set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+    message(WARNING "You are building oneTBB as a static library. This is highly discouraged and such configuration is not supported. Consider building a dynamic library to avoid unforeseen issues.")
+endif()
+
+if (NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
+    set(CMAKE_BUILD_TYPE RelWithDebInfo CACHE STRING "Build type" FORCE)
+    message(STATUS "CMAKE_BUILD_TYPE is not specified. Using default: ${CMAKE_BUILD_TYPE}")
+    # Possible values of build type for cmake-gui
+    set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "Debug" "Release" "MinSizeRel" "RelWithDebInfo")
+endif()
+
+# -------------------------------------------------------------------
+# Files and folders naming
+set(CMAKE_DEBUG_POSTFIX _debug)
+
+if (NOT DEFINED TBB_OUTPUT_DIR_BASE)
+    if (MSVC)
+        if (NOT DEFINED CMAKE_MSVC_RUNTIME_LIBRARY OR CMAKE_MSVC_RUNTIME_LIBRARY MATCHES DLL)
+            set(_tbb_msvc_runtime _md)
+        else()
+            set(_tbb_msvc_runtime _mt)
+        endif()
+
+        if (WINDOWS_STORE)
+            if (TBB_NO_APPCONTAINER)
+                set(_tbb_win_store _wsnoappcont)
+            else()
+                set(_tbb_win_store _ws)
+            endif()
+        elseif(TBB_WINDOWS_DRIVER)
+            set(_tbb_win_store _wd)
+        endif()
+    endif()
+
+     string(REGEX MATCH "^([0-9]+\.[0-9]+|[0-9]+)" _tbb_compiler_version_short ${CMAKE_CXX_COMPILER_VERSION})
+     string(TOLOWER ${CMAKE_CXX_COMPILER_ID}_${_tbb_compiler_version_short}_cxx${CMAKE_CXX_STANDARD}_${TBB_ARCH}${_tbb_msvc_runtime}${_tbb_win_store} TBB_OUTPUT_DIR_BASE)
+     unset(_tbb_msvc_runtime)
+     unset(_tbb_win_store)
+     unset(_tbb_compiler_version_short)
+endif()
+
+foreach(output_type LIBRARY ARCHIVE PDB RUNTIME)
+    if (CMAKE_BUILD_TYPE)
+        string(TOLOWER ${CMAKE_BUILD_TYPE} _tbb_build_type_lower)
+        set(CMAKE_${output_type}_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/${TBB_OUTPUT_DIR_BASE}_${_tbb_build_type_lower})
+        unset(_tbb_build_type_lower)
+    endif()
+
+    if (CMAKE_CONFIGURATION_TYPES)
+        foreach(suffix ${CMAKE_CONFIGURATION_TYPES})
+            string(TOUPPER ${suffix} _tbb_suffix_upper)
+            string(TOLOWER ${suffix} _tbb_suffix_lower)
+            set(CMAKE_${output_type}_OUTPUT_DIRECTORY_${_tbb_suffix_upper} ${CMAKE_BINARY_DIR}/${TBB_OUTPUT_DIR_BASE}_${_tbb_suffix_lower})
+        endforeach()
+        unset(_tbb_suffix_lower)
+        unset(_tbb_suffix_upper)
+    endif()
+endforeach()
+
+# -------------------------------------------------------------------
+
+# -------------------------------------------------------------------
+# Common dependencies
+set(THREADS_PREFER_PTHREAD_FLAG TRUE)
+find_package(Threads REQUIRED)
+# -------------------------------------------------------------------
+
+file(GLOB FILES_WITH_EXTRA_TARGETS ${CMAKE_CURRENT_SOURCE_DIR}/cmake/*.cmake)
+foreach(FILE_WITH_EXTRA_TARGETS ${FILES_WITH_EXTRA_TARGETS})
+    include(${FILE_WITH_EXTRA_TARGETS})
+endforeach()
+
+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})
+else()
+    message(WARNING "TBB compiler settings not found ${TBB_COMPILER_SETTINGS_FILE}")
+endif()
+
+if (TBB_FIND_PACKAGE OR TBB_DIR)
+    # Allow specifying external TBB to test with.
+    # Do not add main targets and installation instructions in that case.
+    message(STATUS "Using external TBB for testing")
+    find_package(TBB REQUIRED)
+else()
+    if (TBB_BUILD)
+        add_subdirectory(src/tbb)
+    endif()
+    if (NOT "${CMAKE_SYSTEM_PROCESSOR}" MATCHES "mips")
+        if (TBBMALLOC_BUILD)
+            add_subdirectory(src/tbbmalloc)
+            add_subdirectory(src/tbbmalloc_proxy)
+        endif()
+        if (APPLE)
+            message(STATUS "TBBBind build targets are disabled due to unsupported environment")
+        else()
+            add_subdirectory(src/tbbbind)
+        endif()
+    endif()
+
+    # -------------------------------------------------------------------
+    # Installation instructions
+    include(CMakePackageConfigHelpers)
+
+    install(DIRECTORY include/
+            DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
+            COMPONENT devel)
+
+    install(EXPORT ${PROJECT_NAME}Targets
+            NAMESPACE TBB::
+            DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}
+            COMPONENT devel)
+    file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Config.cmake
+               "include(\${CMAKE_CURRENT_LIST_DIR}/${PROJECT_NAME}Targets.cmake)\n")
+
+    write_basic_package_version_file("${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake"
+                                     COMPATIBILITY AnyNewerVersion)
+
+    install(FILES "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Config.cmake"
+                  "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake"
+            DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}
+            COMPONENT devel)
+
+    install(FILES "README.md"
+            DESTINATION ${CMAKE_INSTALL_DOCDIR}
+            COMPONENT devel)
+    # -------------------------------------------------------------------
+endif()
+
+if (TBB_TEST)
+    enable_testing()
+    add_subdirectory(test)
+endif()
+
+if (TBB_EXAMPLES)
+    add_subdirectory(examples)
+endif()
+
+if (TBB_BENCH)
+    if (NOT EXISTS ${CMAKE_CURRENT_LIST_DIR}/benchmark)
+        message(FATAL_ERROR "Benchmarks are not supported yet")
+    endif()
+
+    enable_testing()
+    add_subdirectory(benchmark)
+endif()
+
+if (ANDROID_PLATFORM)
+    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"
+        COPYONLY)
+    endif()
+    # This custom target may be implemented without separate CMake script, but it requires
+    # ADB(Android Debug Bridge) executable file availability, so to incapsulate this requirement
+    # only for corresponding custom target, it was implemented by this way.
+    add_custom_target(device_environment_cleanup COMMAND ${CMAKE_COMMAND}
+                      -P ${CMAKE_CURRENT_SOURCE_DIR}/cmake/android/device_environment_cleanup.cmake)
+endif()
+
+if (TBB4PY_BUILD)
+    add_subdirectory(python)
+endif()
+
+# Keep it the last instruction.
+add_subdirectory(cmake/post_install)

CONTRIBUTING.md

@@ -0,0 +1,55 @@
+<!--
+******************************************************************************
+* 
+* 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.
+*******************************************************************************/-->
+
+# How to Contribute
+As an open source project, we welcome community contributions to oneAPI Threading Building Blocks (oneTBB).  This document explains how to participate in project conversations, log bugs and enhancement requests, and submit code patches to the project. 
+
+## Licensing 
+
+Licensing is very important to open source projects. It helps ensure the software continues to be available under the terms that the author desired. The oneTBB project uses the [Apache 2.0 License](https://github.com/oneapi-src/oneTBB/blob/master/LICENSE.txt), a permissive open source license that allows you to freely use, modify, and distribute your own products that include Apache 2.0 licensed software. By contributing to the oneTBB project, you agree to the license and copyright terms therein and release your own contributions under these terms. 
+
+Some imported or reused components within oneTBB use other licenses, as described in [third-party-programs.txt](https://github.com/oneapi-src/oneTBB/blob/master/third-party-programs.txt). By carefully reviewing potential contributions and enforcing a [Developer Certification of Origin (DCO)](https://developercertificate.org/) for contributed code, we can ensure that the community can develop products with oneTBB without concerns over patent or copyright issues. 
+
+The DCO is an attestation attached to every contribution made by every developer. In the commit message of the contribution, (described later), the developer simply adds a Signed-off-by statement and thereby agrees to the DCO. 
+
+## Prerequisites 
+
+As a contributor, you’ll want to be familiar with the oneTBB project and the repository layout. You should also know how to use it as explained in the [oneTBB documentation](https://oneapi-src.github.io/oneTBB/) and how to set up your build development environment to configure, build, and test oneTBB as explained in the [oneTBB Build System Description](cmake/README.md). 
+
+## Issues 
+If you face a problem, first check out open [oneTBB GitHub issues](https://github.com/oneapi-src/oneTBB/issues) to see if the issue you’d like to address is already reported. You may find users that have encountered the bug you’re finding or have similar ideas for changes or additions.
+
+You can use issues to report a problem, make a feature request, or add comments on an existing issue. 
+
+## Pull Requests 
+
+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-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: 
+
+* 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.  
+* 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. 

INSTALL.md

@@ -0,0 +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
+
+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. 
+
+NOTE: Be careful about installation. Avoid commands like `make install` unless you fully understand the consequences.
+
+The following installation 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.
+
+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 to create a simple portable package that includes header files, libraries, and integration files for CMake:
+
+```bash
+cmake <options> ..
+cpack
+```

LICENSE.txt

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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.

README.md

@@ -1,33 +1,34 @@
-# Intel(R) Threading Building Blocks
+# 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)
 
-Intel(R) Threading Building Blocks (Intel(R) TBB) lets you easily write parallel C++ programs that take
-full advantage of multicore performance, that are portable, composable and have future-proof scalability.
+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.
 
-## Intel(R) TBB Distribution
-* Commercial version: [https://software.intel.com/en-us/intel-tbb] (https://software.intel.com/en-us/intel-tbb)
-* Community licensing: [https://software.intel.com/sites/campaigns/nest/] (https://software.intel.com/sites/campaigns/nest/)
-* Open source version: [https://www.threadingbuildingblocks.org/] (https://www.threadingbuildingblocks.org/)
-* Intel(R) TBB for Python\*: [http://anaconda.org/intel/tbb] (http://anaconda.org/intel/tbb)
+## Installation
+You can install oneTBB from [GitHub*](https://github.com/oneapi-src/oneTBB/releases).
+See [Installation from Sources](INSTALL.md) for details.
 
-## Repository Content
-This is an official Intel(R) TBB public GitHub repository. All source and binary packages starting from Intel(R) TBB 4.4
-can be found at the [Release page] (https://github.com/01org/tbb/releases). Links to the packages with older versions of 
-Intel(R) TBB can be found in the [download.md] (download.md) file.
+## 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/tbb_userguide/Migration_Guide.html)
+* [README for build system](cmake/README.md)
+* [Basic support for the Bazel build system](Bazel.md)
 
-## Repository Structure
-The Master branch is empty and contains only README.md and download.md files.
+## Support
+Please report issues and suggestions via
+[GitHub issues](https://github.com/oneapi-src/oneTBB/issues).
 
-tbb_\<major_version\> - branch for the new major version. All minor versions of the major release will be committed in this branch.
+## How to Contribute
+We welcome community contributions, so check our [contributing guidelines](CONTRIBUTING.md)
+to learn more.
 
-For example:
-* Intel(R) TBB 2017 initial release goes to branch tbb_2017.
-* Intel(R) TBB 2017 Update 1 will go to branch tbb_2017 too.
-* Intel(R) TBB 2018 initial release will go to branch tbb_2018.
+## 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.
 
-## Сontact engineering team
-* [E-mail us.] (mailto:inteltbbdevelopers@intel.com)
+## Engineering team contacts
+* [E-mail us.](mailto:inteltbbdevelopers@intel.com)
 
 ------------------------------------------------------------------------
-Intel and the Intel logo are trademarks of Intel Corporation or its subsidiaries in the U.S. and/or other countries.
-
-\* Other names and brands may be claimed as the property of others.
+\* All names and brands may be claimed as the property of others.

WORKSPACE.bazel

@@ -0,0 +1,19 @@
+# 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.
+# 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.
+
+# DISCLAIMER: Bazel support is community-based. The maintainers do not
+# use Bazel internally. The Bazel build can have security risks or 
+# optimization gaps.
+
+workspace(name = "oneTBB")

cmake/README.md

@@ -0,0 +1,294 @@
+# Build system description
+
+The project uses CMake build configuration.
+
+The following controls are available during the configure stage:
+```
+TBB_TEST:BOOL - Enable testing (ON by default)
+TBB_STRICT:BOOL - Treat compiler warnings as errors (ON by default)
+TBB_SANITIZE:STRING - Sanitizer parameter, passed to compiler/linker
+TBB_SIGNTOOL:FILEPATH - Tool for digital signing, used in post install step for libraries if provided.
+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)
+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)
+```
+
+## Configure, build and test
+
+### Prerequisites
+
+*  CMake >= 3.1
+
+### Preparation
+
+In order to perform out-of-source build you have to create a build directory and go there:
+
+```bash
+mkdir /tmp/my-build
+cd /tmp/my-build
+```
+
+### Configure
+
+```bash
+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 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 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 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.
+
+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 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, 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
+cmake --build . <options>
+```
+
+Some useful options:
+- `--target <target>` - specific target, "all" is default.
+- `--config <Release|Debug>` - build configuration, applicable only for multi-config generators, e.g. Visual Studio generator.
+
+Binaries are placed to `./<compiler-id>_<compiler-ver>_cxx<stdver>_<build-type>` (for example, `./gnu_4.8_cxx11_release`)
+
+#### Build for 32-bit
+
+* 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 specific builds (CMake 3.15 or newer is required)
+
+* 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
+```
+```bash
+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`.
+```bash
+cmake -DCMAKE_MSVC_RUNTIME_LIBRARY=MultiThreaded ..
+```
+```bash
+cmake -DCMAKE_MSVC_RUNTIME_LIBRARY=MultiThreadedDebug -DCMAKE_BUILD_TYPE=Debug ..
+```
+* 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 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 ..
+```
+
+### Test
+
+#### Build test
+Using default ('all') target:
+```
+cmake --build .
+```
+
+or using specific test target:
+```
+cmake --build . --target <test> # e.g. test_version
+```
+
+#### Run test
+
+Using CTest:
+```bash
+ctest
+```
+
+or using 'test' target:
+```bash
+cmake --build . --target test # currently doesn't work on Windows
+```
+
+## Sanitizers - сonfigure, build and run
+
+```bash
+mkdir build
+cd build
+cmake -DTBB_SANITIZE=thread ..  # or -DTBB_SANITIZE=memory or any other sanitizer
+make -j
+ctest -V
+```
+
+## Valgrind memcheck - configure, build and run
+
+### Prerequisites
+* Valgrind tool executable
+### Example
+```bash
+mkdir build
+cd build
+cmake -DTBB_VALGRIND_MEMCHECK=ON ..
+make -j memcheck-<test name> # or memcheck-all to scan all tests 
+```
+
+## Test specification (Doxygen)
+
+```bash
+mkdir build
+cd build
+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.
+
+How to use this module in your CMake project:
+ 1. Let CMake know where to search for TBBConfig, e.g. specify location of TBBConfig.cmake in `TBB_DIR` (for more details about search paths see [find_package](https://cmake.org/cmake/help/latest/command/find_package.html)).
+ 2. Use [find_package](https://cmake.org/cmake/help/latest/command/find_package.html) to find oneTBB.
+ 3. Use provided variables and/or imported targets (described below) to work with the found oneTBB.
+
+Example:
+
+```cmake
+add_executable(foo foo.cpp)
+find_package(TBB)
+target_link_libraries(foo TBB::tbb)
+```
+
+oneTBB components can be passed to [find_package](https://cmake.org/cmake/help/latest/command/find_package.html) after keyword ``COMPONENTS`` or ``REQUIRED``.
+Use basic names of components (`tbb`, `tbbmalloc`, etc.).
+
+If components are not specified then the default set is used: `tbb`, `tbbmalloc` and ``tbbmalloc_proxy``.
+
+If `tbbmalloc_proxy` is requested, `tbbmalloc` component will also be added and set as dependency for `tbbmalloc_proxy`.
+
+TBBConfig creates [imported targets](https://cmake.org/cmake/help/latest/manual/cmake-buildsystem.7.html#imported-targets>) as
+shared libraries using the following format: `TBB::<component>` (for example, `TBB::tbb`, `TBB::tbbmalloc`).
+
+Set `TBB_FIND_RELEASE_ONLY` to `TRUE` before calling `find_package` in order to search only for release oneTBB version. This variable helps to avoid simultaneous linkage of release and debug oneTBB versions when CMake configuration is `Debug` but a third-party component depends on release oneTBB version.
+
+Variables set during TBB configuration:
+
+Variable | Description
+--- | ---
+`TBB_FOUND`             | oneTBB is found
+`TBB_<component>_FOUND` | Specific oneTBB component is found
+`TBB_VERSION`           | oneTBB version (format: `<major>.<minor>.<patch>.<tweak>`)
+`TBB_IMPORTED_TARGETS`  | All created oneTBB imported targets (not supported for builds from source code)
+
+Starting from [oneTBB 2021.1](https://github.com/oneapi-src/oneTBB/releases/tag/v2021.1) GitHub release TBBConfig files in the binary packages are located under `<tbb-root>/lib/cmake/TBB`.
+For example, `TBB_DIR` should be set to `<tbb-root>/lib/cmake/TBB`.
+
+TBBConfig files are automatically created during the build from source code and can be installed together with the library.
+Also oneTBB provides a helper function that creates TBBConfig files from predefined templates: see `tbb_generate_config` in `cmake/config_generation.cmake`.
+
+## oneTBB Python Module support
+`TBB4PY_BUILD` Cmake option provides ability to build Python module for oneTBB.
+
+### Targets:
+ - `irml` - build IPC RML server
+ - `python_build` - build oneTBB module for Python
+
+`python_build` target requirements:
+ - Python version 3.5 or newer
+ - SWIG version 3.0.6 or newer
+
+## CMake files
+
+### Compile/link options
+
+Compile and link options may be specific for certain compilers. This part is handled in `cmake/compilers/*` files.
+
+Options in TBB CMake are handled via variables in two ways for convenience:
+
+*  by options group
+*  by specific option
+
+#### Options group
+
+Naming convention is the following: `TBB_<SCOPE>_<STAGE>_<CATEGORY>`, where
+
+*  `<SCOPE>` could be
+    *  `LIB` - options applied during libraries build.
+    *  `TEST` - options applied during test build.
+    *  `BENCH` - options applied during benchmarks build.
+    *  `COMMON` - options applied during all (libraries, test, benchmarks) builds.
+*  `<STAGE>` could be
+    *  `COMPILE` - options applied during the compilation.
+    *  `LINK` - options applied during the linkage.
+*  `<CATEGORY>` could be
+    *  `FLAGS` - list of flags
+    *  `LIBS` - list of libraries
+
+*Examples*
+
+Variable | Description
+--- | ---
+`TBB_COMMON_COMPILE_FLAGS` | Applied to libraries, tests and benchmarks as compile options
+`TBB_LIB_LINK_FLAGS`       | Applied to libraries as link options
+`TBB_LIB_LINK_LIBS `       | Applied to libraries as link libraries
+`TBB_TEST_COMPILE_FLAGS`   | Applied to tests as compile options
+
+Please specify the `LINK` options prefixed with dash(-) for MSVC(Visual Studio) compiler with CMake < 3.13 to avoid issues caused by `target_link_libraries` CMake command usage.
+
+#### Specific options
+
+If the option used only in part of the places (library, tests, benchmarks) as well as adding this option to the group of other options is not possible,
+then the option must be named using common sense.
+
+Warnings supperssions should be added into `TBB_WARNING_SUPPRESS` variable which is applied during the compilation of libraries, tests and benchmarks.
+Additional warnings should be added into `TBB_WARNING_TEST_FLAGS` variable which is applied during the compilation of tests.

cmake/android/device_environment_cleanup.cmake

@@ -0,0 +1,17 @@
+# 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.
+# 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.
+
+include(${CMAKE_CURRENT_LIST_DIR}/environment.cmake)
+
+execute_on_device("rm -rf ${ANDROID_DEVICE_TESTING_DIRECTORY}")

cmake/android/environment.cmake

@@ -0,0 +1,35 @@
+# 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.
+# 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.
+
+set(ANDROID_DEVICE_TESTING_DIRECTORY "/data/local/tmp/tbb_testing")
+
+find_program(adb_executable adb)
+if (NOT adb_executable)
+    message(FATAL_ERROR "Could not find adb")
+endif()
+
+macro(execute_on_device cmd)
+    execute_process(COMMAND ${adb_executable} shell ${cmd} RESULT_VARIABLE CMD_RESULT)
+    if (CMD_RESULT)
+        message(FATAL_ERROR "Error while on device execution: ${cmd} error_code: ${CMD_RESULT}")
+    endif()
+endmacro()
+
+macro(transfer_data data_path)
+    execute_process(COMMAND ${adb_executable} push --sync ${data_path} ${ANDROID_DEVICE_TESTING_DIRECTORY}
+                    RESULT_VARIABLE CMD_RESULT OUTPUT_QUIET)
+    if (CMD_RESULT)
+        message(FATAL_ERROR "Error while data transferring: ${data_path} error_code: ${CMD_RESULT}")
+    endif()
+endmacro()

cmake/android/test_launcher.cmake

@@ -0,0 +1,27 @@
+# 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.
+# 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.
+
+include(${CMAKE_CURRENT_LIST_DIR}/environment.cmake)
+
+# transfer data to device
+execute_on_device("mkdir -m 755 -p ${ANDROID_DEVICE_TESTING_DIRECTORY}")
+
+file (GLOB_RECURSE BINARIES_LIST "${BINARIES_PATH}/*.so*" "${BINARIES_PATH}/${TEST_NAME}")
+foreach(BINARY_FILE ${BINARIES_LIST})
+    transfer_data(${BINARY_FILE})
+endforeach()
+
+# execute binary
+execute_on_device("chmod -R 755 ${ANDROID_DEVICE_TESTING_DIRECTORY}")
+execute_on_device("LD_LIBRARY_PATH=${ANDROID_DEVICE_TESTING_DIRECTORY} ${ANDROID_DEVICE_TESTING_DIRECTORY}/${TEST_NAME}")

cmake/compilers/AppleClang.cmake

@@ -0,0 +1,41 @@
+# 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.
+# 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.
+
+set(TBB_LINK_DEF_FILE_FLAG -Wl,-exported_symbols_list,)
+set(TBB_DEF_FILE_PREFIX mac${TBB_ARCH})
+set(TBB_WARNING_LEVEL -Wall -Wextra $<$<BOOL:${TBB_STRICT}>:-Werror>)
+set(TBB_TEST_WARNING_FLAGS -Wshadow -Wcast-qual -Woverloaded-virtual -Wnon-virtual-dtor)
+set(TBB_WARNING_SUPPRESS -Wno-parentheses -Wno-non-virtual-dtor -Wno-dangling-else)
+# For correct ucontext.h structures layout
+set(TBB_COMMON_COMPILE_FLAGS -D_XOPEN_SOURCE)
+
+# Depfile options (e.g. -MD) are inserted automatically in some cases.
+# Don't add -MMD to avoid conflicts in such cases.
+if (NOT CMAKE_GENERATOR MATCHES "Ninja" AND NOT CMAKE_CXX_DEPENDS_USE_COMPILER)
+    set(TBB_MMD_FLAG -MMD)
+endif()
+
+# Ignore -Werror 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)
+    tbb_remove_compile_flag(-Werror)
+endif()
+
+# 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
+set(TBBMALLOC_LIB_COMPILE_FLAGS -fno-rtti -fno-exceptions)
+

cmake/compilers/Clang.cmake

@@ -0,0 +1,69 @@
+# 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.
+# 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.
+
+if (MINGW)
+    set(TBB_LINK_DEF_FILE_FLAG "")
+    set(TBB_DEF_FILE_PREFIX "")
+elseif (APPLE)
+    set(TBB_LINK_DEF_FILE_FLAG -Wl,-exported_symbols_list,)
+    set(TBB_DEF_FILE_PREFIX mac${TBB_ARCH})
+
+    # For correct ucontext.h structures layout
+    set(TBB_COMMON_COMPILE_FLAGS ${TBB_COMMON_COMPILE_FLAGS} -D_XOPEN_SOURCE)
+elseif (MSVC)
+    include(${CMAKE_CURRENT_LIST_DIR}/MSVC.cmake)
+    return()
+else()
+    set(TBB_LINK_DEF_FILE_FLAG -Wl,--version-script=)
+    set(TBB_DEF_FILE_PREFIX lin${TBB_ARCH})
+endif()
+
+# Depfile options (e.g. -MD) are inserted automatically in some cases.
+# Don't add -MMD to avoid conflicts in such cases.
+if (NOT CMAKE_GENERATOR MATCHES "Ninja" AND NOT CMAKE_CXX_DEPENDS_USE_COMPILER)
+    set(TBB_MMD_FLAG -MMD)
+endif()
+
+set(TBB_WARNING_LEVEL -Wall -Wextra $<$<BOOL:${TBB_STRICT}>:-Werror>)
+set(TBB_TEST_WARNING_FLAGS -Wshadow -Wcast-qual -Woverloaded-virtual -Wnon-virtual-dtor)
+
+# Ignore -Werror 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)
+    tbb_remove_compile_flag(-Werror)
+endif()
+
+# Enable Intel(R) Transactional Synchronization Extensions (-mrtm) and WAITPKG instructions support (-mwaitpkg) on relevant processors
+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()
+
+set(TBB_COMMON_LINK_LIBS ${CMAKE_DL_LIBS})
+
+if (ANDROID_PLATFORM)
+    set(TBB_COMMON_COMPILE_FLAGS ${TBB_COMMON_COMPILE_FLAGS} $<$<NOT:$<CONFIG:Debug>>:-D_FORTIFY_SOURCE=2>)
+endif()
+
+if (MINGW)
+    list(APPEND TBB_COMMON_COMPILE_FLAGS -U__STRICT_ANSI__)
+endif()
+
+# 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)

cmake/compilers/GNU.cmake

@@ -0,0 +1,74 @@
+# 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.
+# 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.
+
+if (MINGW)
+    set(TBB_LINK_DEF_FILE_FLAG "")
+    set(TBB_DEF_FILE_PREFIX "")
+elseif (APPLE)
+    set(TBB_LINK_DEF_FILE_FLAG -Wl,-exported_symbols_list,)
+    set(TBB_DEF_FILE_PREFIX mac${TBB_ARCH})
+
+    # For correct ucontext.h structures layout
+    set(TBB_COMMON_COMPILE_FLAGS ${TBB_COMMON_COMPILE_FLAGS} -D_XOPEN_SOURCE)
+else()
+    set(TBB_LINK_DEF_FILE_FLAG -Wl,--version-script=)
+    set(TBB_DEF_FILE_PREFIX lin${TBB_ARCH})
+endif()
+
+set(TBB_WARNING_LEVEL -Wall -Wextra $<$<BOOL:${TBB_STRICT}>:-Werror> -Wfatal-errors)
+set(TBB_TEST_WARNING_FLAGS -Wshadow -Wcast-qual -Woverloaded-virtual -Wnon-virtual-dtor)
+
+# Depfile options (e.g. -MD) are inserted automatically in some cases.
+# Don't add -MMD to avoid conflicts in such cases.
+if (NOT CMAKE_GENERATOR MATCHES "Ninja" AND NOT CMAKE_CXX_DEPENDS_USE_COMPILER)
+    set(TBB_MMD_FLAG -MMD)
+endif()
+
+# Enable Intel(R) Transactional Synchronization Extensions (-mrtm) and WAITPKG instructions support (-mwaitpkg) on relevant processors
+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()
+
+if (NOT MINGW)
+    set(TBB_COMMON_LINK_LIBS dl)
+endif()
+
+# Ignore -Werror 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)
+    tbb_remove_compile_flag(-Werror)
+endif()
+
+if (NOT ${CMAKE_CXX_COMPILER_ID} STREQUAL Intel)
+    # gcc 6.0 and later have -flifetime-dse option that controls elimination of stores done outside the object lifetime
+    set(TBB_DSE_FLAG $<$<NOT:$<VERSION_LESS:${CMAKE_CXX_COMPILER_VERSION},6.0>>:-flifetime-dse=1>)
+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>:-mxgot>)
+endif()
+
+if (MINGW)
+    list(APPEND TBB_COMMON_COMPILE_FLAGS -U__STRICT_ANSI__)
+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)
+set(TBB_OPENMP_FLAG -fopenmp)

cmake/compilers/Intel.cmake

@@ -0,0 +1,36 @@
+# 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.
+# 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.
+
+if (MSVC)
+    include(${CMAKE_CURRENT_LIST_DIR}/MSVC.cmake)
+    set(TBB_WARNING_LEVEL ${TBB_WARNING_LEVEL} /W3)
+    set(TBB_OPENMP_FLAG /Qopenmp)
+    set(TBB_IPO_COMPILE_FLAGS $<$<NOT:$<CONFIG:Debug>>:/Qipo>)
+    set(TBB_IPO_LINK_FLAGS $<$<NOT:$<CONFIG:Debug>>:/INCREMENTAL:NO>)
+elseif (APPLE)
+    include(${CMAKE_CURRENT_LIST_DIR}/AppleClang.cmake)
+    set(TBB_COMMON_COMPILE_FLAGS ${TBB_COMMON_COMPILE_FLAGS} -fstack-protector -Wformat -Wformat-security
+                                 $<$<NOT:$<CONFIG:Debug>>:-fno-omit-frame-pointer -qno-opt-report-embed -D_FORTIFY_SOURCE=2>)
+    set(TBB_OPENMP_FLAG -qopenmp)
+    set(TBB_IPO_COMPILE_FLAGS $<$<NOT:$<CONFIG:Debug>>:-ipo>)
+else()
+    include(${CMAKE_CURRENT_LIST_DIR}/GNU.cmake)
+    set(TBB_LIB_LINK_FLAGS ${TBB_LIB_LINK_FLAGS} -static-intel -Wl,-z,relro,-z,now,)
+    set(TBB_COMMON_COMPILE_FLAGS ${TBB_COMMON_COMPILE_FLAGS} -fstack-protector -Wformat -Wformat-security
+                                 $<$<NOT:$<CONFIG:Debug>>:-qno-opt-report-embed -D_FORTIFY_SOURCE=2>
+                                 $<$<EQUAL:${TBB_ARCH},32>:-falign-stack=maintain-16-byte>)
+    set(TBB_OPENMP_FLAG -qopenmp)
+    set(TBB_IPO_COMPILE_FLAGS $<$<NOT:$<CONFIG:Debug>>:-ipo>)
+endif()
+set(TBB_IPO_LINK_FLAGS ${TBB_IPO_LINK_FLAGS} ${TBB_IPO_COMPILE_FLAGS})

cmake/compilers/IntelLLVM.cmake

@@ -0,0 +1,23 @@
+# 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.
+# 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.
+
+if (WIN32)
+    include(${CMAKE_CURRENT_LIST_DIR}/MSVC.cmake)
+    set(TBB_IPO_COMPILE_FLAGS $<$<NOT:$<CONFIG:Debug>>:/Qipo>)
+    set(TBB_IPO_LINK_FLAGS $<$<NOT:$<CONFIG:Debug>>:/INCREMENTAL:NO>)
+else()
+    include(${CMAKE_CURRENT_LIST_DIR}/Clang.cmake)
+    set(TBB_IPO_COMPILE_FLAGS $<$<NOT:$<CONFIG:Debug>>:-ipo>)
+endif()
+set(TBB_IPO_LINK_FLAGS ${TBB_IPO_LINK_FLAGS} ${TBB_IPO_COMPILE_FLAGS})

cmake/compilers/MSVC.cmake

@@ -0,0 +1,85 @@
+# 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.
+# 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.
+
+set(TBB_LINK_DEF_FILE_FLAG ${CMAKE_LINK_DEF_FILE_FLAG})
+set(TBB_DEF_FILE_PREFIX win${TBB_ARCH})
+
+# Workaround for CMake issue https://gitlab.kitware.com/cmake/cmake/issues/18317.
+# TODO: consider use of CMP0092 CMake policy.
+string(REGEX REPLACE "/W[0-4]" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+
+set(TBB_WARNING_LEVEL $<$<NOT:$<CXX_COMPILER_ID:Intel>>:/W4> $<$<BOOL:${TBB_STRICT}>:/WX>)
+
+# Warning suppression C4324: structure was padded due to alignment specifier
+set(TBB_WARNING_SUPPRESS /wd4324)
+
+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.
+    # More info can be found at
+    # https://docs.microsoft.com/en-us/cpp/error-messages/compiler-warnings/compiler-warning-level-1-c4503
+    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)
+
+# 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)
+    tbb_remove_compile_flag(/WX)
+endif()
+
+if (WINDOWS_STORE OR TBB_WINDOWS_DRIVER)
+    set(TBB_COMMON_COMPILE_FLAGS ${TBB_COMMON_COMPILE_FLAGS} /D_WIN32_WINNT=0x0A00)
+    set(TBB_COMMON_LINK_FLAGS -NODEFAULTLIB:kernel32.lib -INCREMENTAL:NO)
+    set(TBB_COMMON_LINK_LIBS OneCore.lib)
+endif()
+
+if (WINDOWS_STORE)
+    if (NOT CMAKE_SYSTEM_VERSION EQUAL 10.0)
+        message(FATAL_ERROR "CMAKE_SYSTEM_VERSION must be equal to 10.0")
+    endif()
+
+    set(TBB_COMMON_COMPILE_FLAGS ${TBB_COMMON_COMPILE_FLAGS} /ZW /ZW:nostdlib)
+
+    # CMake define this extra lib, remove it for this build type
+    string(REGEX REPLACE "WindowsApp.lib" "" CMAKE_CXX_STANDARD_LIBRARIES "${CMAKE_CXX_STANDARD_LIBRARIES}")
+
+    if (TBB_NO_APPCONTAINER)
+        set(TBB_LIB_LINK_FLAGS ${TBB_LIB_LINK_FLAGS} -APPCONTAINER:NO)
+    endif()
+endif()
+
+if (TBB_WINDOWS_DRIVER)
+    # Since this is universal driver disable this variable
+    set(CMAKE_SYSTEM_PROCESSOR "")
+
+    # CMake define list additional libs, remove it for this build type
+    set(CMAKE_CXX_STANDARD_LIBRARIES "")
+
+    set(TBB_COMMON_COMPILE_FLAGS ${TBB_COMMON_COMPILE_FLAGS} /D _UNICODE /DUNICODE /DWINAPI_FAMILY=WINAPI_FAMILY_APP /D__WRL_NO_DEFAULT_LIB__)
+endif()
+
+if (CMAKE_CXX_COMPILER_ID MATCHES "(Clang|IntelLLVM)")
+    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>)
+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)

cmake/compilers/QCC.cmake

@@ -0,0 +1,18 @@
+# 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.
+# 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.
+
+include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/compilers/GNU.cmake)
+
+# Remove dl library not present in QNX systems
+unset(TBB_COMMON_LINK_LIBS)

cmake/config_generation.cmake

@@ -0,0 +1,131 @@
+# 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.
+# 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.
+
+# Save current location,
+# see for details: https://cmake.org/cmake/help/latest/variable/CMAKE_CURRENT_LIST_DIR.html
+set(_tbb_gen_cfg_path ${CMAKE_CURRENT_LIST_DIR})
+
+include(CMakeParseArguments)
+
+function(tbb_generate_config)
+    set(options      HANDLE_SUBDIRS)
+    set(oneValueArgs INSTALL_DIR
+                     SYSTEM_NAME
+                     LIB_REL_PATH INC_REL_PATH DLL_REL_PATH
+                     VERSION
+                     TBB_BINARY_VERSION
+                     TBBMALLOC_BINARY_VERSION
+                     TBBMALLOC_PROXY_BINARY_VERSION
+                     TBBBIND_BINARY_VERSION)
+
+    cmake_parse_arguments(tbb_gen_cfg "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+
+    get_filename_component(config_install_dir ${tbb_gen_cfg_INSTALL_DIR} ABSOLUTE)
+    file(MAKE_DIRECTORY ${config_install_dir})
+
+    file(TO_CMAKE_PATH "${tbb_gen_cfg_LIB_REL_PATH}" TBB_LIB_REL_PATH)
+    file(TO_CMAKE_PATH "${tbb_gen_cfg_DLL_REL_PATH}" TBB_DLL_REL_PATH)
+    file(TO_CMAKE_PATH "${tbb_gen_cfg_INC_REL_PATH}" TBB_INC_REL_PATH)
+
+    set(TBB_VERSION ${tbb_gen_cfg_VERSION})
+
+    set(_tbb_pc_lib_name tbb)
+    set(_prefix_for_pc_file "\${pcfiledir}/../../")
+    set(_includedir_for_pc_file "\${prefix}/include")
+
+    set(TBB_COMPONENTS_BIN_VERSION "
+set(_tbb_bin_version ${tbb_gen_cfg_TBB_BINARY_VERSION})
+set(_tbbmalloc_bin_version ${tbb_gen_cfg_TBBMALLOC_BINARY_VERSION})
+set(_tbbmalloc_proxy_bin_version ${tbb_gen_cfg_TBBMALLOC_PROXY_BINARY_VERSION})
+set(_tbbbind_bin_version ${tbb_gen_cfg_TBBBIND_BINARY_VERSION})
+")
+
+    if (tbb_gen_cfg_SYSTEM_NAME STREQUAL "Linux")
+        set(TBB_LIB_PREFIX "lib")
+        set(TBB_LIB_EXT "so.\${_\${_tbb_component}_bin_version}")
+        set(TBB_IMPLIB_RELEASE "")
+        set(TBB_IMPLIB_DEBUG "")
+        if (tbb_gen_cfg_HANDLE_SUBDIRS)
+            set(TBB_HANDLE_SUBDIRS "
+if (CMAKE_SIZEOF_VOID_P STREQUAL \"8\")
+    set(_tbb_subdir intel64/gcc4.8)
+else ()
+    set(_tbb_subdir ia32/gcc4.8)
+endif()
+")
+
+            set(_libdir_for_pc_file "\${prefix}/lib/intel64/gcc4.8")
+            configure_file(${_tbb_gen_cfg_path}/../integration/pkg-config/tbb.pc.in ${config_install_dir}/tbb.pc @ONLY)
+
+            set(_libdir_for_pc_file "\${prefix}/lib/ia32/gcc4.8")
+            configure_file(${_tbb_gen_cfg_path}/../integration/pkg-config/tbb.pc.in ${config_install_dir}/tbb32.pc @ONLY)
+        endif()
+    elseif (tbb_gen_cfg_SYSTEM_NAME STREQUAL "Darwin")
+        set(TBB_LIB_PREFIX "lib")
+        set(TBB_LIB_EXT "\${_\${_tbb_component}_bin_version}.dylib")
+        set(TBB_IMPLIB_RELEASE "")
+        set(TBB_IMPLIB_DEBUG "")
+        set(_libdir_for_pc_file "\${prefix}/lib")
+        configure_file(${_tbb_gen_cfg_path}/../integration/pkg-config/tbb.pc.in ${config_install_dir}/tbb.pc @ONLY)
+    elseif (tbb_gen_cfg_SYSTEM_NAME STREQUAL "Windows")
+        set(TBB_LIB_PREFIX "")
+        set(TBB_LIB_EXT "dll")
+        set(TBB_COMPILE_DEFINITIONS "
+                                  INTERFACE_COMPILE_DEFINITIONS \"__TBB_NO_IMPLICIT_LINKAGE=1\"")
+
+        # .lib files installed to TBB_LIB_REL_PATH (e.g. <prefix>/lib);
+        # .dll files installed to TBB_DLL_REL_PATH (e.g. <prefix>/bin);
+        # Expand TBB_LIB_REL_PATH here in IMPORTED_IMPLIB property and
+        # redefine it with TBB_DLL_REL_PATH value to properly fill IMPORTED_LOCATION property in TBBConfig.cmake.in template.
+        set(TBB_IMPLIB_RELEASE "
+                                      IMPORTED_IMPLIB_RELEASE \"\${_tbb_root}/${TBB_LIB_REL_PATH}/\${_tbb_subdir}/\${_tbb_component}\${_bin_version}.lib\"")
+        set(TBB_IMPLIB_DEBUG "
+                                      IMPORTED_IMPLIB_DEBUG \"\${_tbb_root}/${TBB_LIB_REL_PATH}/\${_tbb_subdir}/\${_tbb_component}\${_bin_version}_debug.lib\"")
+        set(TBB_LIB_REL_PATH ${TBB_DLL_REL_PATH})
+
+        if (tbb_gen_cfg_HANDLE_SUBDIRS)
+            set(TBB_HANDLE_SUBDIRS "
+set(_tbb_subdir vc14)
+if (WINDOWS_STORE)
+    set(_tbb_subdir \${_tbb_subdir}_uwp)
+endif()
+
+if (CMAKE_SIZEOF_VOID_P STREQUAL \"8\")
+    set(_tbb_subdir intel64/\${_tbb_subdir})
+else ()
+    set(_tbb_subdir ia32/\${_tbb_subdir})
+endif()
+")
+            set(_tbb_pc_lib_name ${_tbb_pc_lib_name}${TBB_BINARY_VERSION})
+
+            set(_libdir_for_pc_file "\${prefix}/lib/intel64/vc14")
+            configure_file(${_tbb_gen_cfg_path}/../integration/pkg-config/tbb.pc.in ${config_install_dir}/tbb.pc @ONLY)
+
+            set(_libdir_for_pc_file "\${prefix}/lib/ia32/vc14")
+            configure_file(${_tbb_gen_cfg_path}/../integration/pkg-config/tbb.pc.in ${config_install_dir}/tbb32.pc @ONLY)
+        endif()
+
+        set(TBB_HANDLE_BIN_VERSION "
+    unset(_bin_version)
+    if (_tbb_component STREQUAL tbb)
+        set(_bin_version \${_tbb_bin_version})
+    endif()
+")
+    else()
+        message(FATAL_ERROR "Unsupported OS name: ${tbb_system_name}")
+    endif()
+
+    configure_file(${_tbb_gen_cfg_path}/templates/TBBConfig.cmake.in ${config_install_dir}/TBBConfig.cmake @ONLY)
+    configure_file(${_tbb_gen_cfg_path}/templates/TBBConfigVersion.cmake.in ${config_install_dir}/TBBConfigVersion.cmake @ONLY)
+endfunction()

cmake/hwloc_detection.cmake

@@ -0,0 +1,66 @@
+# 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.
+# 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.
+
+list(APPEND HWLOC_REQUIRED_VERSIONS 1_11 2 2_5)
+
+foreach(hwloc_version ${HWLOC_REQUIRED_VERSIONS})
+    if (NOT WIN32)
+        set(CMAKE_HWLOC_${hwloc_version}_DLL_PATH STUB)
+    endif()
+    set(HWLOC_TARGET_NAME HWLOC::hwloc_${hwloc_version})
+
+    if (NOT TARGET ${HWLOC_TARGET_NAME} AND
+        CMAKE_HWLOC_${hwloc_version}_LIBRARY_PATH AND
+        CMAKE_HWLOC_${hwloc_version}_DLL_PATH AND
+        CMAKE_HWLOC_${hwloc_version}_INCLUDE_PATH
+    )
+        add_library(${HWLOC_TARGET_NAME} SHARED IMPORTED)
+        set_target_properties(${HWLOC_TARGET_NAME} PROPERTIES INTERFACE_INCLUDE_DIRECTORIES
+            "${CMAKE_HWLOC_${hwloc_version}_INCLUDE_PATH}")
+        if (WIN32)
+            set_target_properties(${HWLOC_TARGET_NAME} PROPERTIES
+                                  IMPORTED_LOCATION "${CMAKE_HWLOC_${hwloc_version}_DLL_PATH}"
+                                  IMPORTED_IMPLIB   "${CMAKE_HWLOC_${hwloc_version}_LIBRARY_PATH}")
+        else()
+            set_target_properties(${HWLOC_TARGET_NAME} PROPERTIES
+                                  IMPORTED_LOCATION "${CMAKE_HWLOC_${hwloc_version}_LIBRARY_PATH}")
+        endif()
+    endif()
+
+    if (TARGET ${HWLOC_TARGET_NAME})
+        set(HWLOC_TARGET_EXPLICITLY_DEFINED TRUE)
+    endif()
+endforeach()
+
+unset(HWLOC_TARGET_NAME)
+
+if (NOT HWLOC_TARGET_EXPLICITLY_DEFINED AND
+    # No hwloc auto detection for cross compilation
+    NOT CMAKE_CROSSCOMPILING AND
+    NOT TBB_DISABLE_HWLOC_AUTOMATIC_SEARCH
+)
+    find_package(PkgConfig QUIET)
+    if (PKG_CONFIG_FOUND AND NOT CMAKE_VERSION VERSION_LESS 3.6)
+        pkg_search_module(HWLOC hwloc IMPORTED_TARGET)
+        if (TARGET PkgConfig::HWLOC)
+            if (HWLOC_VERSION VERSION_LESS 2)
+                set(TBBBIND_LIBRARY_NAME tbbbind)
+            elseif(HWLOC_VERSION VERSION_LESS 2.5)
+                set(TBBBIND_LIBRARY_NAME tbbbind_2_0)
+            else()
+                set(TBBBIND_LIBRARY_NAME tbbbind_2_5)
+            endif()
+        endif()
+    endif()
+endif()

cmake/memcheck.cmake

@@ -0,0 +1,104 @@
+# 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.
+# 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.
+
+option(TBB_VALGRIND_MEMCHECK "Enable scan for memory leaks using Valgrind" OFF)
+
+if (NOT TBB_VALGRIND_MEMCHECK)
+    return()
+endif()
+
+add_custom_target(memcheck-all
+    COMMENT "Run memcheck on all tests")
+
+find_program(VALGRIND_EXE valgrind)
+
+if (NOT VALGRIND_EXE)
+    message(FATAL_ERROR "Valgrind executable is not found, add tool to PATH or turn off TBB_VALGRIND_MEMCHECK")
+else()
+    message(STATUS "Found Valgrind to run memory leak scan")
+endif()
+
+file(MAKE_DIRECTORY ${CMAKE_BINARY_DIR}/memcheck)
+
+function(_tbb_run_memcheck test_target)
+    set(target_name memcheck-${test_target})
+    add_custom_target(${target_name} 
+        COMMAND ${VALGRIND_EXE} --leak-check=full --show-leak-kinds=all --log-file=${CMAKE_BINARY_DIR}/memcheck/${target_name}.log -v $<TARGET_FILE:${test_target}>)
+    add_dependencies(memcheck-all ${target_name})
+endfunction()
+
+add_custom_target(memcheck-short
+    COMMENT "Run memcheck scan on specified list")
+
+# List of reasonable and quick enough tests to use in automated memcheck
+add_dependencies(memcheck-short 
+    memcheck-test_allocators
+    memcheck-test_arena_constraints
+    memcheck-test_dynamic_link
+    memcheck-test_concurrent_lru_cache
+    memcheck-conformance_concurrent_unordered_map
+    memcheck-conformance_concurrent_unordered_set
+    memcheck-conformance_concurrent_map
+    memcheck-conformance_concurrent_set
+    memcheck-conformance_concurrent_priority_queue
+    memcheck-conformance_concurrent_vector
+    memcheck-conformance_concurrent_queue
+    memcheck-conformance_concurrent_hash_map
+    memcheck-test_parallel_for
+    memcheck-test_parallel_for_each
+    memcheck-test_parallel_reduce
+    memcheck-test_parallel_sort
+    memcheck-test_parallel_invoke
+    memcheck-test_parallel_scan
+    memcheck-test_parallel_pipeline
+    memcheck-test_eh_algorithms
+    memcheck-test_task_group
+    memcheck-test_task_arena
+    memcheck-test_enumerable_thread_specific
+    memcheck-test_resumable_tasks
+    memcheck-conformance_mutex
+    memcheck-test_function_node
+    memcheck-test_multifunction_node
+    memcheck-test_broadcast_node
+    memcheck-test_buffer_node
+    memcheck-test_composite_node
+    memcheck-test_continue_node
+    memcheck-test_eh_flow_graph
+    memcheck-test_flow_graph
+    memcheck-test_flow_graph_priorities
+    memcheck-test_flow_graph_whitebox
+    memcheck-test_indexer_node
+    memcheck-test_join_node
+    memcheck-test_join_node_key_matching
+    memcheck-test_join_node_msg_key_matching
+    memcheck-test_priority_queue_node
+    memcheck-test_sequencer_node
+    memcheck-test_split_node
+    memcheck-test_tagged_msg
+    memcheck-test_overwrite_node
+    memcheck-test_write_once_node
+    memcheck-test_async_node
+    memcheck-test_input_node
+    memcheck-test_profiling
+    memcheck-test_concurrent_queue_whitebox
+    memcheck-test_intrusive_list
+    memcheck-test_semaphore
+    memcheck-test_environment_whitebox
+    memcheck-test_handle_perror
+    memcheck-test_hw_concurrency
+    memcheck-test_eh_thread
+    memcheck-test_global_control
+    memcheck-test_task
+    memcheck-test_concurrent_monitor
+)

cmake/packaging.cmake

@@ -0,0 +1,21 @@
+# 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.
+# 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.
+
+# Note: current implementation uses CMAKE_BUILD_TYPE,
+# this parameter is not defined for multi-config generators.
+set(CPACK_PACKAGE_NAME "${PROJECT_NAME}")
+set(CPACK_PACKAGE_VERSION "${TBB_VERSION}")
+string(TOLOWER ${CPACK_PACKAGE_NAME}-${PROJECT_VERSION}-${CMAKE_SYSTEM_NAME}_${TBB_OUTPUT_DIR_BASE}_${CMAKE_BUILD_TYPE} CPACK_PACKAGE_FILE_NAME)
+set(CPACK_GENERATOR ZIP)
+include(CPack)

cmake/post_install/CMakeLists.txt

@@ -0,0 +1,21 @@
+# 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.
+# 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.
+
+# Add code signing as post-install step.
+if (DEFINED 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})
+")
+endif()

cmake/python/test_launcher.cmake

@@ -0,0 +1,38 @@
+# 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.
+# 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.
+
+find_package(PythonInterp 3.5 REQUIRED)
+
+file(GLOB_RECURSE MODULES_LIST "${PYTHON_MODULE_BUILD_PATH}/*TBB.py*" )
+list(LENGTH MODULES_LIST MODULES_COUNT)
+
+if (MODULES_COUNT EQUAL 0)
+    message(FATAL_ERROR "Cannot find oneTBB Python module")
+elseif (MODULES_COUNT GREATER 1)
+    message(WARNING "Found more than oneTBB Python modules, the only first found module will be tested")
+endif()
+
+list(GET MODULES_LIST 0 PYTHON_MODULE)
+get_filename_component(PYTHON_MODULE_PATH ${PYTHON_MODULE} DIRECTORY)
+
+execute_process(
+    COMMAND
+        ${CMAKE_COMMAND} -E env LD_LIBRARY_PATH=${TBB_BINARIES_PATH}
+        ${PYTHON_EXECUTABLE} -m tbb test
+    WORKING_DIRECTORY ${PYTHON_MODULE_PATH}
+    RESULT_VARIABLE CMD_RESULT
+)
+if (CMD_RESULT)
+    message(FATAL_ERROR "Error while test execution: ${cmd} error_code: ${CMD_RESULT}")
+endif()

cmake/sanitize.cmake

@@ -0,0 +1,40 @@
+# 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.
+# 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.
+
+set(TBB_SANITIZE ${TBB_SANITIZE} CACHE STRING "Sanitizer parameter passed to compiler/linker" FORCE)
+# Possible values of sanitizer parameter for cmake-gui for convenience, user still can use any other value.
+set_property(CACHE TBB_SANITIZE PROPERTY STRINGS "thread" "memory" "leak" "address -fno-omit-frame-pointer")
+
+if (NOT TBB_SANITIZE)
+    return()
+endif()
+
+set(TBB_SANITIZE_OPTION -fsanitize=${TBB_SANITIZE})
+
+# It is required to add sanitizer option to CMAKE_REQUIRED_LIBRARIES to make check_cxx_compiler_flag working properly:
+# sanitizer option should be passed during the compilation phase as well as during the compilation.
+set(CMAKE_REQUIRED_LIBRARIES "${TBB_SANITIZE_OPTION} ${CMAKE_REQUIRED_LIBRARIES}")
+
+string(MAKE_C_IDENTIFIER ${TBB_SANITIZE_OPTION} FLAG_DISPLAY_NAME)
+check_cxx_compiler_flag(${TBB_SANITIZE_OPTION} ${FLAG_DISPLAY_NAME})
+if (NOT ${FLAG_DISPLAY_NAME})
+    message(FATAL_ERROR
+    "${TBB_SANITIZE_OPTION} is not supported by compiler ${CMAKE_CXX_COMPILER_ID}:${CMAKE_CXX_COMPILER_VERSION}, "
+    "please try another compiler or omit TBB_SANITIZE variable")
+endif()
+
+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}")

cmake/scripts/cmake_gen_github_configs.cmake

@@ -0,0 +1,50 @@
+# 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.
+# 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.
+
+include(${CMAKE_CURRENT_LIST_DIR}/../config_generation.cmake)
+
+# TBBConfig in TBB provided packages are expected to be placed into: <tbb-root>/lib/cmake/tbb*
+set(TBB_ROOT_REL_PATH "../../..")
+
+# Paths relative to TBB root directory
+set(INC_REL_PATH "include")
+set(LIB_REL_PATH "lib")
+set(DLL_REL_PATH "redist")
+
+# Parse version info
+file(READ ${CMAKE_CURRENT_LIST_DIR}/../../include/oneapi/tbb/version.h _tbb_version_info)
+string(REGEX REPLACE ".*#define TBB_VERSION_MAJOR ([0-9]+).*" "\\1" _tbb_ver_major "${_tbb_version_info}")
+string(REGEX REPLACE ".*#define TBB_VERSION_MINOR ([0-9]+).*" "\\1" _tbb_ver_minor "${_tbb_version_info}")
+string(REGEX REPLACE ".*#define TBB_VERSION_PATCH ([0-9]+).*" "\\1" _tbb_ver_patch "${_tbb_version_info}")
+string(REGEX REPLACE ".*#define __TBB_BINARY_VERSION ([0-9]+).*" "\\1" TBB_BINARY_VERSION "${_tbb_version_info}")
+file(READ ${CMAKE_CURRENT_LIST_DIR}/../../CMakeLists.txt _tbb_cmakelist)
+string(REGEX REPLACE ".*TBBMALLOC_BINARY_VERSION ([0-9]+).*" "\\1" TBBMALLOC_BINARY_VERSION "${_tbb_cmakelist}")
+set(TBBMALLOC_PROXY_BINARY_VERSION ${TBBMALLOC_BINARY_VERSION})
+string(REGEX REPLACE ".*TBBBIND_BINARY_VERSION ([0-9]+).*" "\\1" TBBBIND_BINARY_VERSION "${_tbb_cmakelist}")
+
+set(COMMON_ARGS
+    TBB_ROOT_REL_PATH ${TBB_ROOT_REL_PATH}
+    INC_REL_PATH ${INC_REL_PATH}
+    LIB_REL_PATH ${LIB_REL_PATH}
+    VERSION ${_tbb_ver_major}.${_tbb_ver_minor}.${_tbb_ver_patch}
+    TBB_BINARY_VERSION ${TBB_BINARY_VERSION}
+    TBBMALLOC_BINARY_VERSION ${TBBMALLOC_BINARY_VERSION}
+    TBBMALLOC_PROXY_BINARY_VERSION ${TBBMALLOC_PROXY_BINARY_VERSION}
+    TBBBIND_BINARY_VERSION ${TBBBIND_BINARY_VERSION}
+)
+
+tbb_generate_config(INSTALL_DIR ${INSTALL_DIR}/linux   SYSTEM_NAME Linux   HANDLE_SUBDIRS ${COMMON_ARGS})
+tbb_generate_config(INSTALL_DIR ${INSTALL_DIR}/windows SYSTEM_NAME Windows HANDLE_SUBDIRS DLL_REL_PATH ${DLL_REL_PATH} ${COMMON_ARGS})
+tbb_generate_config(INSTALL_DIR ${INSTALL_DIR}/darwin  SYSTEM_NAME Darwin  ${COMMON_ARGS})
+message(STATUS "TBBConfig files were created in ${INSTALL_DIR}")

cmake/suppressions/lsan.suppressions

@@ -0,0 +1,2 @@
+# LSAN suppression for ltdl library known issue.
+leak:libltdl.so

cmake/templates/TBBConfig.cmake.in

@@ -0,0 +1,98 @@
+# Copyright (c) 2017-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.
+# 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.
+
+# It defines the following variables:
+#     TBB_<component>_FOUND
+#     TBB_IMPORTED_TARGETS
+#
+# TBBConfigVersion.cmake defines TBB_VERSION
+#
+# Initialize to default values
+if (NOT TBB_IMPORTED_TARGETS)
+    set(TBB_IMPORTED_TARGETS "")
+endif()
+
+if (NOT TBB_FIND_COMPONENTS)
+    set(TBB_FIND_COMPONENTS "tbb;tbbmalloc;tbbmalloc_proxy")
+    foreach (_tbb_component ${TBB_FIND_COMPONENTS})
+        set(TBB_FIND_REQUIRED_${_tbb_component} 1)
+    endforeach()
+endif()
+
+get_filename_component(_tbb_root "${CMAKE_CURRENT_LIST_DIR}" REALPATH)
+get_filename_component(_tbb_root "${_tbb_root}/@TBB_ROOT_REL_PATH@" ABSOLUTE)
+
+set(TBB_INTERFACE_VERSION @TBB_INTERFACE_VERSION@)
+@TBB_COMPONENTS_BIN_VERSION@
+# Add components with internal dependencies: tbbmalloc_proxy -> tbbmalloc
+list(FIND TBB_FIND_COMPONENTS tbbmalloc_proxy _tbbmalloc_proxy_ix)
+if (NOT _tbbmalloc_proxy_ix EQUAL -1)
+    list(APPEND TBB_FIND_COMPONENTS tbbmalloc)
+    list(REMOVE_DUPLICATES TBB_FIND_COMPONENTS)
+    set(TBB_FIND_REQUIRED_tbbmalloc ${TBB_FIND_REQUIRED_tbbmalloc_proxy})
+endif()
+unset(_tbbmalloc_proxy_ix)
+@TBB_HANDLE_SUBDIRS@
+foreach (_tbb_component ${TBB_FIND_COMPONENTS})
+    set(TBB_${_tbb_component}_FOUND 0)
+    @TBB_HANDLE_BIN_VERSION@
+    get_filename_component(_tbb_release_lib "${_tbb_root}/@TBB_LIB_REL_PATH@/${_tbb_subdir}/@TBB_LIB_PREFIX@${_tbb_component}${_bin_version}.@TBB_LIB_EXT@" ABSOLUTE)
+
+    if (NOT TBB_FIND_RELEASE_ONLY)
+        get_filename_component(_tbb_debug_lib "${_tbb_root}/@TBB_LIB_REL_PATH@/${_tbb_subdir}/@TBB_LIB_PREFIX@${_tbb_component}${_bin_version}_debug.@TBB_LIB_EXT@" ABSOLUTE)
+    endif()
+
+    if (EXISTS "${_tbb_release_lib}" OR EXISTS "${_tbb_debug_lib}")
+        if (NOT TARGET TBB::${_tbb_component})
+            add_library(TBB::${_tbb_component} SHARED IMPORTED)
+
+            get_filename_component(_tbb_include_dir "${_tbb_root}/@TBB_INC_REL_PATH@" ABSOLUTE)
+            set_target_properties(TBB::${_tbb_component} PROPERTIES
+                                  INTERFACE_INCLUDE_DIRECTORIES "${_tbb_include_dir}"@TBB_COMPILE_DEFINITIONS@)
+            unset(_tbb_current_realpath)
+            unset(_tbb_include_dir)
+
+            if (EXISTS "${_tbb_release_lib}")
+                set_target_properties(TBB::${_tbb_component} PROPERTIES
+                                      IMPORTED_LOCATION_RELEASE "${_tbb_release_lib}"@TBB_IMPLIB_RELEASE@)
+                set_property(TARGET TBB::${_tbb_component} APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+            endif()
+
+            if (EXISTS "${_tbb_debug_lib}")
+                set_target_properties(TBB::${_tbb_component} PROPERTIES
+                                      IMPORTED_LOCATION_DEBUG "${_tbb_debug_lib}"@TBB_IMPLIB_DEBUG@)
+                set_property(TARGET TBB::${_tbb_component} APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG)
+            endif()
+
+            # Add internal dependencies for imported targets: TBB::tbbmalloc_proxy -> TBB::tbbmalloc
+            if (_tbb_component STREQUAL tbbmalloc_proxy)
+                set_target_properties(TBB::tbbmalloc_proxy PROPERTIES INTERFACE_LINK_LIBRARIES TBB::tbbmalloc)
+            endif()
+        endif()
+        list(APPEND TBB_IMPORTED_TARGETS TBB::${_tbb_component})
+        set(TBB_${_tbb_component}_FOUND 1)
+    elseif (TBB_FIND_REQUIRED AND TBB_FIND_REQUIRED_${_tbb_component})
+        message(STATUS "Missed required oneTBB component: ${_tbb_component}")
+        if (TBB_FIND_RELEASE_ONLY)
+            message(STATUS "  ${_tbb_release_lib} must exist.")
+        else()
+            message(STATUS "  one or both of:\n   ${_tbb_release_lib}\n    ${_tbb_debug_lib}\n   files must exist.")
+        endif()
+        set(TBB_FOUND FALSE)
+    endif()
+endforeach()
+list(REMOVE_DUPLICATES TBB_IMPORTED_TARGETS)
+unset(_tbb_release_lib)
+unset(_tbb_debug_lib)
+unset(_tbb_root)

cmake/templates/TBBConfigVersion.cmake.in

@@ -0,0 +1,24 @@
+# Copyright (c) 2017-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.
+# 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.
+
+set(PACKAGE_VERSION @TBB_VERSION@)
+
+if ("${PACKAGE_VERSION}" VERSION_LESS "${PACKAGE_FIND_VERSION}")
+    set(PACKAGE_VERSION_COMPATIBLE FALSE)
+else()
+    set(PACKAGE_VERSION_COMPATIBLE TRUE)
+    if ("${PACKAGE_VERSION}" VERSION_EQUAL "${PACKAGE_FIND_VERSION}")
+        set(PACKAGE_VERSION_EXACT TRUE)
+    endif()
+endif()

cmake/test_spec.cmake

@@ -0,0 +1,35 @@
+# 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.
+# 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.
+
+option(TBB_TEST_SPEC "Generate test specification (Doxygen)" OFF)
+
+if (TBB_TEST_SPEC)
+    find_package(Doxygen REQUIRED)
+
+    set(DOXYGEN_PREDEFINED_MACROS
+      "TBB_USE_EXCEPTIONS \
+      __TBB_RESUMABLE_TASKS \
+      __TBB_HWLOC_PRESENT \
+      __TBB_CPP17_DEDUCTION_GUIDES_PRESENT \
+      __TBB_CPP17_MEMORY_RESOURCE_PRESENT \
+      __TBB_CPP14_GENERIC_LAMBDAS_PRESENT"
+    )
+
+    add_custom_target(
+      test_spec ALL
+      COMMAND ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile
+      COMMENT "Generating test specification with Doxygen"
+      VERBATIM)
+    configure_file(${CMAKE_CURRENT_SOURCE_DIR}/doc/Doxyfile.in ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile @ONLY)
+endif()

cmake/toolchains/mips.cmake

@@ -0,0 +1,40 @@
+# 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.
+# 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.
+
+# Prevent double invocation.
+if (MIPS_TOOLCHAIN_INCLUDED)
+    return()
+endif()
+set(MIPS_TOOLCHAIN_INCLUDED TRUE)
+
+set(CMAKE_SYSTEM_NAME Linux)
+set(CMAKE_SYSTEM_VERSION 1)
+set(CMAKE_SYSTEM_PROCESSOR mips)
+
+set(CMAKE_C_COMPILER ${CMAKE_FIND_ROOT_PATH}/bin/mips-img-linux-gnu-gcc)
+set(CMAKE_CXX_COMPILER ${CMAKE_FIND_ROOT_PATH}/bin/mips-img-linux-gnu-g++)
+set(CMAKE_LINKER ${CMAKE_FIND_ROOT_PATH}/bin/mips-img-linux-gnu-ld)
+
+# Define result for try_run used in find_package(Threads).
+# In old CMake versions (checked on 3.5) there is invocation of try_run command in FindThreads.cmake module.
+# It can't be executed on host system in case of cross-compilation for MIPS architecture.
+# Define return code for this try_run as 0 since threads are expected to be available on target machine.
+set(THREADS_PTHREAD_ARG "0" CACHE STRING "Result from TRY_RUN" FORCE)
+
+set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
+
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -EL -mabi=64 -march=mips64r6 -mcrc -mfp64 -mmt -mtune=mips64r6 -ggdb -ffp-contract=off -mhard-float" CACHE INTERNAL "")
+set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -mvirt -mxpa" CACHE INTERNAL "")
+set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -mvirt -mxpa" CACHE INTERNAL "")  # for tests

cmake/utils.cmake

@@ -0,0 +1,46 @@
+# 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.
+# 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.
+
+macro(tbb_remove_compile_flag flag)
+    get_property(_tbb_compile_options DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} PROPERTY COMPILE_OPTIONS)
+    list(REMOVE_ITEM _tbb_compile_options ${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 ${flag} "" CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})
+    endif()
+endmacro()
+
+macro(tbb_install_target target)
+    install(TARGETS ${target}
+        EXPORT TBBTargets
+        LIBRARY
+            DESTINATION ${CMAKE_INSTALL_LIBDIR}
+            NAMELINK_SKIP
+            COMPONENT runtime
+        RUNTIME
+            DESTINATION ${CMAKE_INSTALL_BINDIR}
+            COMPONENT runtime
+        ARCHIVE
+            DESTINATION ${CMAKE_INSTALL_LIBDIR}
+            COMPONENT devel)
+
+    if (BUILD_SHARED_LIBS)
+        install(TARGETS ${target}
+            LIBRARY
+                DESTINATION ${CMAKE_INSTALL_LIBDIR}
+                NAMELINK_ONLY
+                COMPONENT devel)
+    endif()
+endmacro()

cmake/vars_utils.cmake

@@ -0,0 +1,48 @@
+# 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.
+# 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.
+
+option(TBB_INSTALL_VARS "Enable auto-generated vars installation" OFF)
+
+if (WIN32)
+    set(TBB_VARS_TEMPLATE "windows/env/vars.bat.in")
+elseif (APPLE)
+    set(TBB_VARS_TEMPLATE "mac/env/vars.sh.in")
+else()
+    set(TBB_VARS_TEMPLATE "linux/env/vars.sh.in")
+endif()
+
+get_filename_component(TBB_VARS_TEMPLATE_NAME ${PROJECT_SOURCE_DIR}/integration/${TBB_VARS_TEMPLATE} NAME)
+string(REPLACE ".in" "" TBB_VARS_NAME ${TBB_VARS_TEMPLATE_NAME})
+
+macro(tbb_gen_vars target)
+    if (${CMAKE_PROJECT_NAME} STREQUAL ${PROJECT_NAME})
+        add_custom_command(TARGET ${target} POST_BUILD COMMAND
+            ${CMAKE_COMMAND}
+            -DBINARY_DIR=${CMAKE_BINARY_DIR}
+            -DSOURCE_DIR=${PROJECT_SOURCE_DIR}
+            -DBIN_PATH=$<TARGET_FILE_DIR:${target}>
+            -DVARS_TEMPLATE=${TBB_VARS_TEMPLATE}
+            -DVARS_NAME=${TBB_VARS_NAME}
+            -DTBB_INSTALL_VARS=${TBB_INSTALL_VARS}
+            -DTBB_CMAKE_INSTALL_LIBDIR=${CMAKE_INSTALL_LIBDIR}
+            -P ${PROJECT_SOURCE_DIR}/integration/cmake/generate_vars.cmake
+        )
+    endif()
+endmacro(tbb_gen_vars)
+
+if (TBB_INSTALL_VARS)
+    install(PROGRAMS "${CMAKE_BINARY_DIR}/internal_install_vars"
+            DESTINATION env
+            RENAME ${TBB_VARS_NAME})
+endif()

doc/DoxygenLayout.xml

@@ -0,0 +1,195 @@
+<doxygenlayout version="1.0">
+  <!-- Generated by doxygen 1.8.14 -->
+  <!-- Navigation index tabs for HTML output -->
+  <navindex>
+    <tab type="mainpage" visible="no" title=""/>
+    <tab type="pages" visible="no" title="" intro=""/>
+    <tab type="modules" visible="yes" title="" intro=""/>
+    <tab type="namespaces" visible="yes" title="">
+      <tab type="namespacelist" visible="yes" title="" intro=""/>
+      <tab type="namespacemembers" visible="yes" title="" intro=""/>
+    </tab>
+    <tab type="classes" visible="no" title="">
+      <tab type="classlist" visible="yes" title="" intro=""/>
+      <tab type="classindex" visible="$ALPHABETICAL_INDEX" title=""/> 
+      <tab type="hierarchy" visible="yes" title="" intro=""/>
+      <tab type="classmembers" visible="yes" title="" intro=""/>
+    </tab>
+    <tab type="files" visible="yes" title="Test Suites">
+      <tab type="filelist" visible="no" title="" intro=""/>
+      <tab type="globals" visible="no" title="" intro=""/>
+    </tab>
+    <tab type="user" url="@ref test_classification" visible="yes" title="Test Classification"/>
+    <tab type="examples" visible="yes" title="" intro=""/>  
+  </navindex>
+
+  <!-- Layout definition for a class page -->
+  <class>
+    <briefdescription visible="yes"/>
+    <includes visible="$SHOW_INCLUDE_FILES"/>
+    <inheritancegraph visible="$CLASS_GRAPH"/>
+    <collaborationgraph visible="$COLLABORATION_GRAPH"/>
+    <memberdecl>
+      <nestedclasses visible="yes" title=""/>
+      <publictypes title=""/>
+      <services title=""/>
+      <interfaces title=""/>
+      <publicslots title=""/>
+      <signals title=""/>
+      <publicmethods title=""/>
+      <publicstaticmethods title=""/>
+      <publicattributes title=""/>
+      <publicstaticattributes title=""/>
+      <protectedtypes title=""/>
+      <protectedslots title=""/>
+      <protectedmethods title=""/>
+      <protectedstaticmethods title=""/>
+      <protectedattributes title=""/>
+      <protectedstaticattributes title=""/>
+      <packagetypes title=""/>
+      <packagemethods title=""/>
+      <packagestaticmethods title=""/>
+      <packageattributes title=""/>
+      <packagestaticattributes title=""/>
+      <properties title=""/>
+      <events title=""/>
+      <privatetypes title=""/>
+      <privateslots title=""/>
+      <privatemethods title=""/>
+      <privatestaticmethods title=""/>
+      <privateattributes title=""/>
+      <privatestaticattributes title=""/>
+      <friends title=""/>
+      <related title="" subtitle=""/>
+      <membergroups visible="yes"/>
+    </memberdecl>
+    <detaileddescription title=""/>
+    <memberdef>
+      <inlineclasses title=""/>
+      <typedefs title=""/>
+      <enums title=""/>
+      <services title=""/>
+      <interfaces title=""/>
+      <constructors title=""/>
+      <functions title=""/>
+      <related title=""/>
+      <variables title=""/>
+      <properties title=""/>
+      <events title=""/>
+    </memberdef>
+    <allmemberslink visible="yes"/>
+    <usedfiles visible="$SHOW_USED_FILES"/>
+    <authorsection visible="yes"/>
+  </class>
+
+  <!-- Layout definition for a namespace page -->
+  <namespace>
+    <briefdescription visible="yes"/>
+    <memberdecl>
+      <nestednamespaces visible="yes" title=""/>
+      <constantgroups visible="yes" title=""/>
+      <classes visible="yes" title=""/>
+      <typedefs title=""/>
+      <enums title=""/>
+      <functions title=""/>
+      <variables title=""/>
+      <membergroups visible="yes"/>
+    </memberdecl>
+    <detaileddescription title=""/>
+    <memberdef>
+      <inlineclasses title=""/>
+      <typedefs title=""/>
+      <enums title=""/>
+      <functions title=""/>
+      <variables title=""/>
+    </memberdef>
+    <authorsection visible="yes"/>
+  </namespace>
+
+  <!-- Layout definition for a file page -->
+  <file>
+    <briefdescription visible="yes"/>
+    <includes visible="$SHOW_INCLUDE_FILES"/>
+    <includegraph visible="$INCLUDE_GRAPH"/>
+    <includedbygraph visible="$INCLUDED_BY_GRAPH"/>
+    <sourcelink visible="yes"/>
+    <memberdecl>
+      <classes visible="yes" title=""/>
+      <namespaces visible="yes" title=""/>
+      <constantgroups visible="yes" title=""/>
+      <defines title=""/>
+      <typedefs title=""/>
+      <enums title=""/>
+      <functions title=""/>
+      <variables title=""/>
+      <membergroups visible="yes"/>
+    </memberdecl>
+    <detaileddescription title=""/>
+    <memberdef>
+      <inlineclasses title=""/>
+      <defines title=""/>
+      <typedefs title=""/>
+      <enums title=""/>
+      <functions title=""/>
+      <variables title=""/>
+    </memberdef>
+    <authorsection/>
+  </file>
+
+  <!-- Layout definition for a group page -->
+  <group>
+    <briefdescription visible="yes"/>
+    <groupgraph visible="$GROUP_GRAPHS"/>
+    <memberdecl>
+      <nestedgroups visible="yes" title=""/>
+      <dirs visible="yes" title=""/>
+      <files visible="yes" title=""/>
+      <namespaces visible="yes" title=""/>
+      <classes visible="yes" title=""/>
+      <defines title=""/>
+      <typedefs title=""/>
+      <enums title=""/>
+      <enumvalues title=""/>
+      <functions title=""/>
+      <variables title=""/>
+      <signals title=""/>
+      <publicslots title=""/>
+      <protectedslots title=""/>
+      <privateslots title=""/>
+      <events title=""/>
+      <properties title=""/>
+      <friends title=""/>
+      <membergroups visible="yes"/>
+    </memberdecl>
+    <detaileddescription title=""/>
+    <memberdef>
+      <pagedocs/>
+      <inlineclasses title=""/>
+      <defines title=""/>
+      <typedefs title=""/>
+      <enums title=""/>
+      <enumvalues title=""/>
+      <functions title=""/>
+      <variables title=""/>
+      <signals title=""/>
+      <publicslots title=""/>
+      <protectedslots title=""/>
+      <privateslots title=""/>
+      <events title=""/>
+      <properties title=""/>
+      <friends title=""/>
+    </memberdef>
+    <authorsection visible="yes"/>
+  </group>
+
+  <!-- Layout definition for a directory page -->
+  <directory>
+    <briefdescription visible="yes"/>
+    <directorygraph visible="yes"/>
+    <memberdecl>
+      <dirs visible="yes"/>
+      <files visible="yes"/>
+    </memberdecl>
+    <detaileddescription title=""/>
+  </directory>
+</doxygenlayout>

doc/GSG/conf.py

@@ -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

doc/GSG/index.rst

@@ -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.

doc/main/_static/custom.js

@@ -0,0 +1,53 @@
+//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: {
+        src: '\\operatorname{src}',
+        srclayer: '\\operatorname{src\\_layer}',
+        srciter: '\\operatorname{src\\_iter}',
+        srciterc: '\\operatorname{src\\_iter\\_c}',
+        weights: '\\operatorname{weights}',
+        weightslayer: '\\operatorname{weights\\_layer}',
+        weightsiter: '\\operatorname{weights\\_iter}',
+        weightspeephole: '\\operatorname{weights\\_peephole}',
+        weightsprojection: '\\operatorname{weights\\_projection}',
+        bias: '\\operatorname{bias}',
+        dst: '\\operatorname{dst}',
+        dstlayer: '\\operatorname{dst\\_layer}',
+        dstiter: '\\operatorname{dst\\_iter}',
+        dstiterc: '\\operatorname{dst\\_iter\\_c}',
+        diffsrc: '\\operatorname{diff\\_src}',
+        diffsrclayer: '\\operatorname{diff\\_src\\_layer}',
+        diffsrciter: '\\operatorname{diff\\_src\\_iter}',
+        diffsrciterc: '\\operatorname{diff\\_src\\_iter\\_c}',
+        diffweights: '\\operatorname{diff\\_weights}',
+        diffweightslayer: '\\operatorname{diff\\_weights\\_layer}',
+        diffweightsiter: '\\operatorname{diff\\_weights\\_iter}',
+        diffweightspeephole: '\\operatorname{diff\\_weights\\_peephole}',
+        diffweightsprojection: '\\operatorname{diff\\_weights\\_projection}',
+        diffbias: '\\operatorname{diff\\_bias}',
+        diffdst: '\\operatorname{diff\\_dst}',
+        diffdstlayer: '\\operatorname{diff\\_dst\\_layer}',
+        diffdstiter: '\\operatorname{diff\\_dst\\_iter}',
+        diffdstiterc: '\\operatorname{diff\\_dst\\_iter\\_c}',
+        diffgamma: '\\operatorname{diff\\_\\gamma}',
+        diffbeta: '\\operatorname{diff\\_\\beta}',
+        workspace: '\\operatorname{workspace}'
+    }
+    }
+}

doc/main/_static/theme_overrides.css

@@ -0,0 +1,13 @@
+/* override table width restrictions */
+@media screen and (min-width: 767px) {
+
+   .wy-table-responsive table td {
+      /* !important prevents the common CSS stylesheets from overriding
+         this as on RTD they are loaded after this stylesheet */
+      white-space: normal !important;
+   }
+
+   .wy-table-responsive {
+      overflow: visible !important;
+   }
+}

doc/main/conf.py

@@ -0,0 +1,294 @@
+# -*- 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 -----------------------------------------------------
+
+if BUILD_TYPE == 'oneapi':
+    project = u'Intel® oneAPI Threading Building Blocks (oneTBB)'
+else:
+    project = u'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' 
+
+if BUILD_TYPE == 'oneapi':
+    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
+    """
+else:
+    rst_prolog = """
+.. |full_name| replace:: 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.
+#
+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>'
+    }
+
+
+
+# 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':
+    html_context = {
+        'css_files': [
+            '_static/theme_overrides.css',  # override wide tables in RTD theme
+        ],
+    }
+else:
+    html_js_files = ['custom.js']
+    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.
+#
+# 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

doc/main/index.rst

@@ -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

doc/main/intro/Benefits.rst

@@ -0,0 +1,88 @@
+.. _Benefits:
+
+|short_name| Benefits
+=====================
+
+
+|full_name| is a library that helps you leverage multi-core performance
+without having to be a threading expert. Typically you can improve
+performance for multi-core processors by implementing the key points
+explained in the early sections of the Developer Guide. As your
+expertise grows, you may want to dive into more complex subjects that
+are covered in advanced sections.
+
+
+There are a variety of approaches to parallel programming, ranging from
+using platform-dependent threading primitives to exotic new languages.
+The advantage of oneTBB is that it works at a higher level than raw
+threads, yet does not require exotic languages or compilers. You can use
+it with any compiler supporting ISO C++. The library differs from
+typical threading packages in the following ways:
+
+
+-  **oneTBB enables you to specify logical paralleism instead of
+   threads**. Most threading packages require you to specify threads.
+   Programming directly in terms of threads can be tedious and lead to
+   inefficient programs, because threads are low-level, heavy constructs
+   that are close to the hardware. Direct programming with threads
+   forces you to efficiently map logical tasks onto threads. In
+   contrast, the oneTBB run-time library automatically maps logical
+   parallelism onto threads in a way that makes efficient use of
+   processor resources.
+
+
+-  **oneTBB targets threading for performance**. Most general-purpose
+   threading packages support many different kinds of threading, such as
+   threading for asynchronous events in graphical user interfaces. As a
+   result, general-purpose packages tend to be low-level tools that
+   provide a foundation, not a solution. Instead, oneTBB focuses on the
+   particular goal of parallelizing computationally intensive work,
+   delivering higher-level, simpler solutions.
+
+
+-  **oneTBB is compatible with other threading packages.** Because the
+   library is not designed to address all threading problems, it can
+   coexist seamlessly with other threading packages.
+
+
+-  **oneTBB emphasizes scalable, data parallel programming**. Breaking a
+   program up into separate functional blocks, and assigning a separate
+   thread to each block is a solution that typically does not scale well
+   since typically the number of functional blocks is fixed. In
+   contrast, oneTBB emphasizes *data-parallel* programming, enabling
+   multiple threads to work on different parts of a collection.
+   Data-parallel programming scales well to larger numbers of processors
+   by dividing the collection into smaller pieces. With data-parallel
+   programming, program performance increases as you add processors.
+
+
+-  **oneTBB relies on generic programming**. Traditional libraries
+   specify interfaces in terms of specific types or base classes.
+   Instead, oneAPI Threading Building Blocks uses generic programming.
+   The essence of generic programming is writing the best possible
+   algorithms with the fewest constraints. The C++ Standard Template
+   Library (STL) is a good example of generic programming in which the
+   interfaces are specified by *requirements* on types. For example, C++
+   STL has a template function ``sort`` that sorts a sequence abstractly
+   defined in terms of iterators on the sequence. The requirements on
+   the iterators are:
+
+
+   -  Provide random access
+
+
+   -  The expression ``*i<*j`` is true if the item pointed to by
+      iterator ``i`` should precede the item pointed to by iterator
+      ``j``, and false otherwise.
+
+
+   -  The expression ``swap(*i,*j)`` swaps two elements.
+
+
+Specification in terms of requirements on types enables the template to
+sort many different representations of sequences, such as vectors and
+deques. Similarly, the oneTBB templates specify requirements on types,
+not particular types, and thus adapt to different data representations.
+Generic programming enables oneTBB to deliver high performance
+algorithms with broad applicability.
+

doc/main/intro/help_support.rst

@@ -0,0 +1,26 @@
+.. _help_support:
+
+Getting Help and Support
+========================
+
+
+
+
+
+.. container:: section
+
+
+   .. rubric:: Getting Technical Support
+      :class: sectiontitle
+
+   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: http://www.intel.com/software/products/support/.
+

doc/main/intro/intro.rst

@@ -0,0 +1,39 @@
+.. _intro:
+
+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 
+
+
+

doc/main/intro/introducing_main.rst

@@ -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 
+
+
+

doc/main/intro/notation.rst

@@ -0,0 +1,106 @@
+.. _notation:
+
+Notational Conventions
+======================
+
+
+The following conventions may be used in this document.
+
+
+.. container:: tablenoborder
+
+
+   .. list-table:: 
+      :header-rows: 1
+
+      * -     Convention     
+        -     Explanation     
+        -     Example     
+      * -     \ *Italic*     
+        -     Used for introducing new terms, denotation of terms,    placeholders, or titles of manuals.    
+        -     The filename consists of the *basename* and the *extension*.     
+      * -     \ ``Monospace``     
+        -     Indicates directory paths and filenames, commands and    command line        options, function names, methods,   classes, data structures in body text, source code.    
+        -     \ ``ippsapi.h``        \ ``\alt\include``           Use the okCreateObjs() function to...          \ ``printf("hello, world\n");``    
+      * -     [ ]     
+        -     Items enclosed in brackets are optional.     
+        -     Fa[c]        Indicates Fa or Fac.     
+      * -     { \| }     
+        -     Braces and vertical bars indicate the choice of one item    from a selection of two or more items.    
+        -     X{K \| W \| P}        Indicates XK, XW, or XP.       
+      * -     "[" "]" "{"    | " }" "|"    
+        -     Writing a metacharacter in quotation marks negates the      syntactical meaning stated above;   | the character is taken as a literal.    
+        -     "[" X "]" [ Y ]        Denotes the letter X    enclosed in brackets, optionally followed by the letter Y.    
+      * -     ...     
+        -     The ellipsis indicates that the previous item can be    repeated several times.    
+        -     \ ``filename`` ...        Indicates that one or    more filenames can be specified.    
+      * -     ,...     
+        -     The ellipsis preceded by a comma indicates that the      previous item can be repeated several times,   | separated by commas.    
+        -     \ ``word`` ,...        Indicates that one or    more words can be specified. If more than one word is specified, the   words are comma-separated.    
+
+
+
+
+.. container:: section
+
+
+   Class members are summarized by informal class declarations that
+   describe the class as it seems to clients, not how it is actually
+   implemented. For example, here is an informal declaration of class
+   ``Foo``:
+
+
+   ::
+
+
+      class Foo {
+      public:
+          int x();
+          int y;
+          ~Foo();
+      };
+
+
+   The actual implementation might look like:
+
+
+   ::
+
+
+      namespace internal {
+          class FooBase  {
+          protected:
+              int x();
+          };
+
+
+          class Foo_v3: protected FooBase {
+          private:
+              int internal_stuff;
+          public:
+              using FooBase::x;
+              int y;
+          };
+      }
+
+
+      typedef internal::Foo_v3 Foo;
+
+
+   The example shows two cases where the actual implementation departs
+   from the informal declaration:
+
+
+   -  ``Foo`` is actually a typedef to ``Foo_v3``.
+
+
+   -  Method ``x()`` is inherited from a protected base class.
+
+
+   -  The destructor is an implicit method generated by the compiler.
+
+
+   The informal declarations are intended to show you what you need to
+   know to use the class without the distraction of irrelevant clutter
+   particular to the implementation.
+

doc/main/intro/notices_and_disclaimers.rst

@@ -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.
+

doc/main/reference/blocking_terminate.rst

@@ -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;
+    }

doc/main/reference/concurrent_lru_cache_cls.rst

@@ -0,0 +1,163 @@
+.. _concurrent_lru_cache:
+
+concurrent_lru_cache
+====================
+
+.. note::
+   To enable this feature, define the ``TBB_PREVIEW_CONCURRENT_LRU_CACHE`` macro to 1.
+
+A Class Template for Least Recently Used cache with concurrent operations.
+
+.. contents::
+    :local:
+    :depth: 1
+
+Description
+***********
+
+A ``concurrent_lru_cache`` container maps keys to values with the ability
+to limit the number of stored unused values. For each key, there is at most one item
+stored in the container.
+
+The container permits multiple threads to concurrently retrieve items from it.
+
+The container tracks which items are in use by returning a proxy
+``concurrent_lru_cache::handle`` object that refers to an item instead of its value.
+Once there are no ``handle`` objects holding reference to an item, it is considered unused.
+
+The container stores all the items that are currently in use plus a limited
+number of unused items. Excessive unused items are erased according to
+least recently used policy.
+
+When no item is found for a given key, the container calls the user-specified
+``value_function_type`` object to construct a value for the key, and stores that value.
+The ``value_function_type`` object must be thread-safe.
+
+API
+***
+
+Header
+------
+
+.. code:: cpp
+
+    #include "oneapi/tbb/concurrent_lru_cache.h"
+
+Synopsis
+--------
+
+.. code:: cpp
+
+    namespace oneapi {
+        namespace tbb {
+            template <typename Key, typename Value, typename ValueFunctionType = Value (*)(Key)>
+            class concurrent_lru_cache {
+            public:
+                using key_type = Key;
+                using value_type = Value;
+                using pointer = value_type*;
+                using const_pointer = const value_type*;
+                using reference = value_type&;
+                using const_reference = const value_type&;
+
+                using value_function_type = ValueFunctionType;
+
+                class handle {
+                public:
+                    handle();
+                    handle( handle&& other );
+
+                    ~handle();
+
+                    handle& operator=( handle&& other );
+
+                    operator bool() const;
+                    value_type& value();
+                }; // class handle
+
+                concurrent_lru_cache( value_function_type f, std::size_t number_of_lru_history_items );
+                ~concurrent_lru_cache();
+
+                handle operator[]( key_type key );
+            }; // class concurrent_lru_cache
+        } // namespace tbb
+    } // namespace oneapi
+
+Member Functions
+----------------
+
+.. cpp:function:: concurrent_lru_cache( value_function_type f, std::size_t number_of_lru_history_items );
+
+    **Effects**: Constructs an empty cache that can keep up to ``number_of_lru_history_items``
+    unused values, with a function object ``f`` for constructing new values.
+
+-------------------------------------------------------
+
+.. cpp:function:: ~concurrent_lru_cache();
+
+    **Effects**: Destroys the ``concurrent_lru_cache``. Calls the destructors of the stored elements and
+    deallocates the used storage.
+
+The behavior is undefined in case of concurrent operations with ``*this``.
+
+-------------------------------------------------------
+
+.. cpp:function:: handle operator[]( key_type k );
+
+    **Effects**: Searches the container for an item that corresponds to the given key.
+    If such an item is not found, the user-specified function object is called to
+    construct a value that is inserted into the container.
+
+    **Returns**: a ``handle`` object holding reference to the matching value.
+
+Member Objects
+--------------
+
+``handle`` class
+^^^^^^^^^^^^^^^^
+
+**Member Functions**
+
+.. cpp:function:: handle();
+
+    **Effects**: Constructs a ``handle`` object that does not refer to any value.
+
+--------------------------------------------------
+
+.. cpp:function:: handle( handle&& other );
+
+    **Effects**: Transfers the reference to the value stored in ``concurrent_lru_cache``
+    from ``other`` to the newly constructed object. Upon completion,
+    ``other`` no longer refers to any value.
+
+---------------------------------------------------
+
+.. cpp:function:: ~handle();
+
+    **Effects**: Releases the reference (if it exists) to a value stored in ``concurrent_lru_cache``.
+
+The behavior is undefined for concurrent operations with ``*this``.
+
+---------------------------------------------------
+
+.. cpp:function:: handle& operator=( handle&& other );
+
+    **Effects**: Transfers the reference to a value stored in ``concurrent_lru_cache`` from ``other``
+    to ``*this``. If existed, the previous reference held by ``*this`` is released. Upon
+    completion ``other`` no longer refers to any value.
+
+    **Returns**: a reference to ``*this``.
+
+---------------------------------------------------
+
+.. cpp:function:: operator bool() const;
+
+    **Returns**: ``true`` if ``*this`` holds reference to a value, ``false`` otherwise.
+
+---------------------------------------------------
+
+.. cpp:function:: value_type& value();
+
+    **Returns**: a reference to a ``value_type`` object stored in ``concurrent_lru_cache``.
+
+The behavior is undefined if ``*this`` does not refer to any value.

doc/main/reference/constraints_extensions.rst

@@ -0,0 +1,118 @@
+.. _constraints_extensions:
+
+task_arena::constraints extensions
+======================================
+
+.. note::
+    To enable this feature, set the ``TBB_PREVIEW_TASK_ARENA_CONSTRAINTS_EXTENSION`` macro to 1.
+
+.. contents::
+    :local:
+    :depth: 1
+
+Description
+***********
+
+These extensions allow to customize ``tbb::task_arena::constraints`` with the following properties:
+
+* On machines with Intel® Hybrid Technology set the preferred core type for threads working within the task arena.
+* Limit the maximum number of threads that can be scheduled to one core simultaneously.
+
+API
+***
+
+Header
+------
+
+.. code:: cpp
+
+    #include <oneapi/tbb/task_arena.h>
+
+Synopsis
+--------
+
+.. code:: cpp
+
+    namespace oneapi {
+        namespace tbb {
+
+            class task_arena {
+            public:
+                struct constraints {
+                    constraints& set_numa_id(numa_node_id id);
+                    constraints& set_max_concurrency(int maximal_concurrency);
+                    constraints& set_core_type(core_type_id id);
+                    constraints& set_max_threads_per_core(int threads_number);
+
+                    numa_node_id numa_id = task_arena::automatic;
+                    int max_concurrency = task_arena::automatic;
+                    core_type_id core_type = task_arena::automatic;
+                    int max_threads_per_core = task_arena::automatic;
+                }; // struct constraints
+            }; // class task_arena
+
+        } // namespace tbb
+    } // namespace oneapi
+
+Member Functions
+----------------
+
+.. cpp:function:: constraints& set_numa_id(numa_node_id id)
+
+    Sets the ``numa_id`` field to the ``id``.
+
+    **Returns:** Reference to ``*this``.
+
+.. cpp:function:: constraints& set_max_concurrency(int maximal_concurrency)
+
+    Sets the ``max_concurrency`` field to the ``maximal_concurrency``.
+
+    **Returns:** Reference to ``*this``.
+
+.. cpp:function:: constraints& set_core_type(core_type_id id)
+
+    Sets the ``core_type`` field to the ``id``.
+
+    **Returns:** Reference to ``*this``.
+
+.. cpp:function:: constraints& set_max_threads_per_core(int threads_number)
+
+    Sets the ``max_threads_per_core`` field to the ``threads_number``.
+
+    **Returns:** Reference to ``*this``.
+
+Member Objects
+--------------
+
+.. cpp:member:: numa_node_id numa_id
+
+    An integral logical index uniquely identifying a NUMA node. All threads joining the
+    ``task_arena`` are bound to this NUMA node.
+
+    .. note::
+
+        To obtain a valid NUMA node ID, call ``oneapi::tbb::info::numa_nodes()``.
+
+.. cpp:member:: int max_concurrency
+
+    The maximum number of threads that can participate in work processing within the
+    ``task_arena`` at the same time.
+
+
+.. cpp:member:: core_type_id core_type
+
+    An integral logical index uniquely identifying a core type. All threads joining the
+    ``task_arena`` are bound to this core type.
+
+    .. note::
+
+        To obtain a valid core type node ID, call ``oneapi::tbb::info::core_types()``.
+
+.. cpp:member:: int max_threads_per_core
+
+    The maximum number of threads that can be scheduled to one core simultaneously.
+
+See also:
+
+* :doc:`oneapi::tbb::info namespace preview extensions <info_namespace_extensions>`
+* `oneapi::tbb::task_arena specification <https://spec.oneapi.com/versions/latest/elements/oneTBB/source/task_scheduler/task_arena/task_arena_cls.html>`_

doc/main/reference/constructors_for_nodes.rst

@@ -0,0 +1,104 @@
+.. _constructors_for_fg_nodes:
+
+Constructors for Flow Graph nodes
+=================================
+
+.. note::
+   To enable this feature, define the ``TBB_PREVIEW_FLOW_GRAPH_FEATURES`` macro to 1.
+
+.. contents::
+    :local:
+    :depth: 1
+
+Description
+***********
+
+The "Helper Functions for Expressing Graphs" feature adds a set of new constructors
+that can be used to construct a node that ``follows`` or ``precedes`` a set of nodes.
+
+Where possible, the constructors support Class Template Argument Deduction (since C++17).
+
+API
+***
+
+Header
+------
+
+.. code:: cpp
+
+    #include <oneapi/tbb/flow_graph.h>
+
+Syntax
+------
+
+.. code:: cpp
+
+    // continue_node
+    continue_node(follows(...), Body body, Policy = Policy());
+    continue_node(precedes(...), Body body, Policy = Policy());
+
+    continue_node(follows(...), int number_of_predecessors, Body body, Policy = Policy());
+    continue_node(precedes(...), int number_of_predecessors, Body body, Policy = Policy());
+
+    // function_node
+    function_node(follows(...), std::size_t concurrency, Policy = Policy());
+    function_node(precedes(...), std::size_t concurrency, Policy = Policy());
+
+    // input_node
+    input_node(precedes(...), body);
+
+    // multifunction_node
+    multifunction_node(follows(...), std::size_t concurrency, Body body);
+    multifunction_node(precedes(...), std::size_t concurrency, Body body);
+
+    // async_node
+    async_node(follows(...), std::size_t concurrency, Body body);
+    async_node(precedes(...), std::size_t concurrency, Body body);
+
+    // overwrite_node
+    explicit overwrite_node(follows(...));
+    explicit overwrite_node(precedes(...));
+
+    // write_once_node
+    explicit write_once_node(follows(...));
+    explicit write_once_node(precedes(...));
+
+    // buffer_node
+    explicit buffer_node(follows(...));
+    explicit buffer_node(precedes(...));
+
+    // queue_node
+    explicit queue_node(follows(...));
+    explicit queue_node(precedes(...));
+
+    // priority_queue_node
+    explicit priority_queue_node(follows(...), const Compare& comp = Compare());
+    explicit priority_queue_node(precedes(...), const Compare& compare = Compare());
+
+    // sequencer_node
+    sequencer_node(follows(...), const Sequencer& s);
+    sequencer_node(precedes(...), const Sequencer& s);
+
+    // limiter_node
+    limiter_node(follows(...), std::size_t threshold);
+    limiter_node(precedes(...), std::size_t threshold);
+
+    // broadcast_node
+    explicit broadcast_node(follows(...));
+    explicit broadcast_node(precedes(...));
+
+    // join_node
+    explicit join_node(follows(...), Policy = Policy());
+    explicit join_node(precedes(...), Policy = Policy());
+
+    // split_node
+    explicit split_node(follows(...));
+    explicit split_node(precedes(...));
+
+    // indexer_node
+    indexer_node(follows(...));
+    indexer_node(precedes(...));
+
+See Also
+********
+:ref:`follows_precedes`

doc/main/reference/custom_mutex_chmap.rst

@@ -0,0 +1,158 @@
+.. _custom_mutex_chmap:
+
+The customizing mutex type for ``concurrent_hash_map``
+======================================================
+
+.. note::
+    To enable this feature, define the ``TBB_PREVIEW_CONCURRENT_HASH_MAP_EXTENSIONS`` macro to 1.
+
+.. contents::
+    :local:
+    :depth: 1
+
+Description
+***********
+
+oneTBB ``concurrnent_hash_map`` class uses reader-writer mutex
+to provide thread safety and avoid data races for insert, lookup, and erasure operations. This feature adds an extra template parameter
+for ``concurrent_hash_map`` that allows to customize the type of the reader-writer mutex.
+
+API
+***
+
+Header
+------
+
+.. code:: cpp
+
+    #include <oneapi/tbb/concurrent_hash_map.h>
+
+Synopsis
+--------
+
+.. code:: cpp
+
+    namespace oneapi {
+    namespace tbb {
+
+        template <typename Key, typename T,
+                typename HashCompare = tbb_hash_compare<Key>,
+                typename Allocator = tbb_allocator<std::pair<const Key, T>>,
+                typename Mutex = spin_rw_mutex>
+        class concurrent_hash_map {
+            using mutex_type = Mutex;
+        };
+
+    } // namespace tbb
+    } // namespace oneapi
+
+Type requirements
+-----------------
+
+The type of the mutex passed as a template argument for ``concurrent_hash_map`` should
+meet the requirements of `ReaderWriterMutex <https://spec.oneapi.com/versions/latest/elements/oneTBB/source/named_requirements/mutexes/rw_mutex.html>`_.
+It should also provide the following API:
+
+.. cpp:function:: bool ReaderWriterMutex::scoped_lock::is_writer() const;
+
+**Returns**: ``true`` if the ``scoped_lock`` object acquires the mutex as a writer, ``false`` otherwise.
+
+The behavior is undefined if the ``scoped_lock`` object does not acquire the mutex.
+
+``oneapi::tbb::spin_rw_mutex``, ``oneapi::tbb::speculative_spin_rw_mutex``, ``oneapi::tbb::queuing_rw_mutex``, ``oneapi::tbb::null_rw_mutex``,
+and ``oneapi::tbb::rw_mutex`` meet the requirements above.
+
+.. rubric:: Example
+
+The example below demonstrates how to wrap ``std::shared_mutex`` (C++17) to meet the requirements
+of `ReaderWriterMutex` and how to customize ``concurrent_hash_map`` to use this mutex.
+
+.. code:: cpp
+
+    #define TBB_PREVIEW_CONCURRENT_HASH_MAP_EXTENSIONS 1
+    #include "oneapi/tbb/concurrent_hash_map.h"
+    #include <shared_mutex>
+
+    class SharedMutexWrapper {
+    public:
+        // ReaderWriterMutex requirements
+
+        static constexpr bool is_rw_mutex = true;
+        static constexpr bool is_recursive_mutex = false;
+        static constexpr bool is_fair_mutex = false;
+
+        class scoped_lock {
+        public:
+            scoped_lock() : my_mutex_ptr(nullptr), my_writer_flag(false) {}
+            scoped_lock(SharedMutexWrapper& mutex, bool write = true)
+                : my_mutex_ptr(&mutex), my_writer_flag(write)
+            {
+                if (my_writer_flag) {
+                    my_mutex_ptr->my_mutex.lock();
+                } else {
+                    my_mutex_ptr->my_mutex.lock_shared();
+                }
+            }
+
+            ~scoped_lock() {
+                if (my_mutex_ptr) release();
+            }
+
+            void acquire(SharedMutexWrapper& mutex, bool write = true) {
+                if (my_mutex_ptr) release();
+
+                my_mutex_ptr = &mutex;
+                my_writer_flag = write;
+
+                if (my_writer_flag) {
+                    my_mutex_ptr->my_mutex.lock();
+                } else {
+                    my_mutex_ptr->my_mutex.lock_shared();
+                }
+            }
+
+            void release() {
+                if (my_writer_flag) {
+                    my_mutex_ptr->my_mutex.unlock();
+                } else {
+                    my_mutex_ptr->my_mutex.unlock_shared();
+                }
+            }
+
+            bool upgrade_to_writer() {
+                // std::shared_mutex does not have the upgrade/downgrade parallel_for_each_semantics
+                if (my_writer_flag) return true; // Already a writer
+
+                my_mutex_ptr->my_mutex.unlock_shared();
+                my_mutex_ptr->my_mutex.lock();
+                return false; // The lock was reacquired
+            }
+
+            bool downgrade_to_reader() {
+                if (!my_writer_flag) return true; // Already a reader
+
+                my_mutex_ptr->my_mutex.unlock();
+                my_mutex_ptr->my_mutex.lock_shared();
+                return false;
+            }
+
+            bool is_writer() const {
+                return my_writer_flag;
+            }
+
+        private:
+            SharedMutexWrapper* my_mutex_ptr;
+            bool                my_writer_flag;
+        };
+    private:
+        std::shared_mutex my_mutex;
+    }; // struct SharedMutexWrapper
+
+    int main() {
+        using map_type = oneapi::tbb::concurrent_hash_map<int, int,
+                                                          oneapi::tbb::tbb_hash_compare<int>,
+                                                          oneapi::tbb::tbb_allocator<std::pair<const int, int>>,
+                                                          SharedMutexWrapper>;
+
+        map_type map; // This object will use SharedMutexWrapper for thread safety of insert/find/erase operations
+    }

doc/main/reference/follows_and_precedes_functions.rst

@@ -0,0 +1,78 @@
+.. _follows_precedes:
+
+``follows`` and ``precedes`` function templates
+===============================================
+
+.. note::
+   To enable this feature, define the ``TBB_PREVIEW_FLOW_GRAPH_FEATURES`` macro to 1.
+
+The ``follows`` and ``precedes`` helper functions aid in expressing
+dependencies between nodes when building oneTBB flow graphs. These helper functions can
+only be used while constructing the node.
+
+.. contents::
+    :local:
+    :depth: 1
+
+Description
+***********
+
+The ``follows`` helper function specifies that the node being constructed is
+the successor of the set of nodes passed as an argument.
+
+The ``precedes`` helper function specifies that the node being constructed is
+the predecessor of the set of nodes passed as an argument.
+
+Functions ``follows`` and ``precedes`` are meant to replace the graph argument, which is
+passed as the first argument to the constructor of the node. The graph argument for the
+node being constructed is obtained either from the specified node set or the sequence of nodes passed
+to ``follows`` or ``precedes``.
+
+If the nodes passed to ``follows`` or ``precedes`` belong to
+different graphs, the behavior is undefined.
+
+API
+***
+
+Header
+------
+
+.. code:: cpp
+
+    #include <oneapi/tbb/flow_graph.h>
+
+Syntax
+------
+
+.. code:: cpp
+
+    // node_set is an exposition-only name for the type returned from make_node_set function
+
+    template <typename NodeType, typename... NodeTypes>
+    /*unspecified*/ follows( node_set<NodeType, NodeTypes...>& set );
+
+    template <typename NodeType, typename... NodeTypes>
+    /*unspecified*/ follows( NodeType& node, NodeTypes&... nodes );
+
+    template <typename NodeType, typename... NodeTypes>
+    /*unspecified*/ precedes( node_set<NodeType, NodeTypes...>& set );
+
+    template <typename NodeType, typename... NodeTypes>
+    /*unspecified*/ precedes( NodeType& node, NodeTypes&... nodes );
+
+Input Parameters
+----------------
+
+Either a set or a sequence of nodes can be used as arguments for ``follows`` and
+``precedes``. The following expressions are equivalent:
+
+.. code-block:: cpp
+    :caption: A set of nodes as an input
+
+    auto handlers = make_node_set(n1, n2, n3);
+    broadcast_node<int> input(precedes(handlers));
+
+.. code-block:: cpp
+    :caption: A sequence of nodes as an input
+ 
+    broadcast_node<int> input(precedes(n1, n2, n3));

doc/main/reference/helpers_for_expressing_graphs.rst

@@ -0,0 +1,118 @@
+.. _helpers_for_expressing_graphs:
+
+Helper Functions for Expressing Graphs
+======================================
+
+.. note::
+   To enable this feature, define the ``TBB_PREVIEW_FLOW_GRAPH_FEATURES`` macro to 1.
+
+Helper functions are intended to make creation of the flow graphs less verbose.
+
+.. contents::
+    :local:
+    :depth: 1
+
+Description
+***********
+
+This feature adds ``make_edges``, ``make_node_set``,
+``follows`` and ``precedes`` functions to ``oneapi::tbb::flow`` namespace.
+These functions simplify the process of building flow graphs by allowing to gather nodes
+into sets and connect them to other nodes in the graph.
+
+API
+***
+
+.. toctree::
+    :titlesonly:
+
+    constructors_for_nodes
+    follows_and_precedes_functions
+    make_node_set_function
+    make_edges_function
+
+Example
+*******
+
+Consider the graph depicted below.
+
+.. figure:: ./Resources/fg_api_graph_structure.png
+    :align: center
+
+In the examples below, C++17 Class Template Argument Deduction is used
+to avoid template parameter specification where possible.
+
+**Regular API**
+
+.. code:: cpp
+
+    #include <oneapi/tbb/flow_graph.h>
+
+    int main() {
+        using namespace oneapi::tbb::flow;
+
+        graph g;
+
+        broadcast_node<int> input(g);
+
+        function_node doubler(g, unlimited, [](const int& v) { return 2 * v; });
+        function_node squarer(g, unlimited, [](const int&) { return v * v; });
+        function_node cuber(g, unlimited, [](const int& v) { return v * v * v; });
+
+        join_node<std::tuple<int, int, int>> join(g);
+
+        int sum = 0;
+        function_node summer(g, serial, [&](const std::tuple<int, int, int>& v) {
+            int sub_sum = std::get<0>(v) + std::get<1>(v) + std::get<2>(v);
+            sum += sub_sum;
+            return sub_sum;
+        });
+
+        make_edge(input, doubler);
+        make_edge(input, squarer);
+        make_edge(input, cuber);
+        make_edge(doubler, std::get<0>(join.input_ports()));
+        make_edge(squarer, std::get<1>(join.input_ports()));
+        make_edge(cuber, std::get<2>(join.input_ports()));
+        make_edge(join, summer);
+
+        for (int i = 1; i <= 10; ++i) {
+            input.try_put(i);
+        }
+        g.wait_for_all();
+    }
+
+**Preview API**
+
+.. code:: cpp
+
+    #define TBB_PREVIEW_FLOW_GRAPH_FEATURES 1
+    #include <oneapi/tbb/flow_graph.h>
+
+    int main() {
+        using namespace oneapi::tbb::flow;
+
+        graph g;
+
+        function_node doubler(g, unlimited, [](const int& v) { return 2 * v; });
+        function_node squarer(g, unlimited, [](const int&) { return v * v; });
+        function_node cuber(g, unlimited, [](const int& v) { return v * v * v; });
+
+        auto handlers = make_node_set(doubler, squarer, cuber);
+
+        broadcast_node input(precedes(handlers));
+        join_node join(follows(handlers));
+
+        int sum = 0;
+        function_node summer(follows(join), serial,
+                             [&](const std::tuple<int, int, int>& v) {
+                                 int sub_sum = std::get<0>(v) + std::get<1>(v) + std::get<2>(v);
+                                 sum += sub_sum;
+                                 return sub_sum;
+                             });
+
+        for (int i = 1; i <= 10; ++i) {
+            input.try_put(i);
+        }
+        g.wait_for_all();
+    }

doc/main/reference/heterogeneous_extensions_chmap.rst

@@ -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");
+    }

doc/main/reference/info_namespace.rst

@@ -0,0 +1,17 @@
+.. _info_namespace:
+
+oneapi::tbb::info namespace
+===========================
+
+The ``oneapi::tbb::info`` namespace satisfies `the corresponding oneTBB specification section
+<https://spec.oneapi.com/versions/latest/elements/oneTBB/source/info_namespace.html>`_.
+
+The |full_name| implementation requires `the hwloc library <https://www-lb.open-mpi.org/projects/hwloc>`_
+to query NUMA(version >= 1.11) and Hybrid CPUs(version >= 2.4) topology information.
+
+See also:
+
+* `info namespace specification <https://spec.oneapi.com/versions/latest/elements/oneTBB/source/info_namespace.html>`_
+* `oneapi::tbb::task_arena specification <https://spec.oneapi.com/versions/latest/elements/oneTBB/source/task_scheduler/task_arena/task_arena_cls.html>`_
+* :doc:`oneapi::tbb::info namespace preview extensions <info_namespace_extensions>`
+* :doc:`task_arena::constraints class preview extensions <constraints_extensions>`

doc/main/reference/info_namespace_extensions.rst

@@ -0,0 +1,71 @@
+.. _info_namespace_extensions:
+
+oneapi::tbb::info namespace extensions
+======================================
+
+.. note::
+    To enable this feature, set the ``TBB_PREVIEW_TASK_ARENA_CONSTRAINTS_EXTENSION`` macro to 1.
+
+.. contents::
+    :local:
+    :depth: 1
+
+Description
+***********
+
+These extensions allow to query information about execution environment.
+
+.. contents::
+    :local:
+    :depth: 1
+
+API
+***
+
+Header
+------
+
+.. code:: cpp
+
+    #include <oneapi/tbb/info.h>
+
+Syntax
+------
+
+.. code:: cpp
+
+    namespace oneapi {
+        namespace tbb {
+            using core_type_id = /*implementation-defined*/;
+            namespace info {
+                std::vector<core_type_id> core_types();
+                int default_concurrency(task_arena::constraints c);
+            }
+        }
+    }
+
+Types
+-----
+
+``core_type_id`` - Represents core type identifier.
+
+Functions
+---------
+
+.. cpp:function:: std::vector<core_type_id> core_types()
+
+    Returns the vector of integral indexes that indicate available core types.
+    The indexes are sorted from the least performant to the most performant core type.
+
+    .. note::
+        If error occurs during system topology parsing, returns vector containing single element
+        that equals to ``task_arena::automatic``.
+
+.. cpp:function:: int default_concurrency(task_arena::constraints c)
+
+    Returns concurrency level for the given constraints.
+
+See also:
+
+* :doc:`task_arena::constraints class preview extensions <constraints_extensions>`
+* `info namespace specification <https://spec.oneapi.com/versions/latest/elements/oneTBB/source/info_namespace.html>`_

doc/main/reference/make_edges_function.rst

@@ -0,0 +1,81 @@
+.. _make_edges:
+
+``make_edges`` function template
+================================
+
+.. note::
+   To enable this feature, define the ``TBB_PREVIEW_FLOW_GRAPH_FEATURES`` macro to 1.
+
+.. contents::
+    :local:
+    :depth: 1
+
+Description
+***********
+
+The ``make_edges`` function template creates edges between a single node
+and each node in a set of nodes.
+
+There are two ways to connect nodes in a set and a single node using
+``make_edges``:
+
+.. figure:: ./Resources/make_edges_usage.png
+   :align: center
+
+API
+***
+
+Header
+------
+
+.. code:: cpp
+
+    #include <oneapi/tbb/flow_graph.h>
+
+Syntax
+------
+
+.. code:: cpp
+
+    // node_set is an exposition-only name for the type returned from make_node_set function
+
+    template <typename NodeType, typename Node, typename... Nodes>
+    void make_edges(node_set<Node, Nodes...>& set, NodeType& node);
+
+    template <typename NodeType, typename Node, typename... Nodes>
+    void make_edges(NodeType& node, node_set<Node, Nodes...>& set);
+
+Example
+-------
+
+The example implements the graph structure in the picture below.
+
+.. figure:: ./Resources/make_edges_example.png
+    :align: center
+
+.. code:: cpp
+
+    #define TBB_PREVIEW_FLOW_GRAPH_FEATURES 1
+    #include <oneapi/tbb/flow_graph.h>
+
+    int main() {
+        using namespace oneapi::tbb::flow;
+
+        graph g;
+        broadcast_node<int> input(g);
+
+        function_node doubler(g, unlimited, [](const int& i) { return 2 * i; });
+        function_node squarer(g, unlimited, [](const int& i) { return i * i; });
+        function_node cuber(g, unlimited, [](const int& i) { return i * i * i; });
+
+        buffer_node<int> buffer(g);
+
+        auto handlers = make_node_set(doubler, squarer, cuber);
+        make_edges(input, handlers);
+        make_edges(handlers, buffer);
+
+        for (int i = 1; i <= 10; ++i) {
+            input.try_put(i);
+        }
+        g.wait_for_all();
+    }

doc/main/reference/make_node_set_function.rst

@@ -0,0 +1,42 @@
+.. _make_node_set:
+
+``make_node_set`` function template
+===================================
+
+.. note::
+   To enable this feature, define the ``TBB_PREVIEW_FLOW_GRAPH_FEATURES`` macro to 1.
+
+.. contents::
+    :local:
+    :depth: 1
+
+Description
+***********
+
+The ``make_node_set`` function template creates a set of nodes that
+can be passed as arguments to ``make_edges``, ``follows`` and ``precedes`` functions.
+
+API
+***
+
+Header
+------
+
+.. code:: cpp
+
+    #include <oneapi/tbb/flow_graph.h>
+
+Syntax
+------
+
+.. code:: cpp
+
+    template <typename Node, typename... Nodes>
+    /*unspecified*/ make_node_set( Node& node, Nodes&... nodes );
+
+See Also
+********
+
+:ref:`make_edges`
+
+:ref:`follows_precedes`

doc/main/reference/mutex_cls.rst

@@ -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.

doc/main/reference/parallel_for_each_semantics.rst

@@ -0,0 +1,66 @@
+.. _parallel_for_each_semantics:
+
+parallel_for_each Body semantics and requirements
+=================================================
+
+.. contents::
+    :local:
+    :depth: 1
+
+Description
+***********
+
+This page clarifies `ParallelForEachBody <https://spec.oneapi.com/versions/latest/elements/oneTBB/source/named_requirements/algorithms/par_for_each_body.html>`_
+named requirements for ``tbb::parallel_for_each`` algorithm specification.
+
+.. code:: cpp
+
+    namespace oneapi {
+        namespace tbb {
+
+            template <typaname InputIterator, typename Body>
+            void parallel_for_each( InputIterator first, InputIterator last, Body body ); // overload (1)
+            template <typename InputIterator, typename Body>
+            void parallel_for_each( InputIterator first, InputIterator last, Body body, task_group_context& group ); // overload (2)
+
+            template <typename Container, typename Body>
+            void parallel_for_each( Container& c, Body body ); // overload (3)
+            template <typename Container, typename Body>
+            void parallel_for_each( Container& c, Body body, task_group_context& group ); // overload (4)
+
+            template <typename Container, typename Body>
+            void parallel_for_each( const Container& c, Body body ); // overload (5)
+            template <typename Container, typename Body>
+            void parallel_for_each( const Container& c, Body body, task_group_context& group ); // overload (6)
+
+        } // namespace tbb
+    } // namespace oneapi
+
+Terms
+-----
+
+* ``iterator`` determines the type of the iterator passed into ``parallel_for_each`` algorithm (which is ``InputIterator`` for overloads `(1)` and `(2)`
+  and ``decltype(std::begin(c))`` for overloads `(3) - (6)`)
+* ``value_type`` - the type ``typename std::iterator_traits<iterator>::value_type``
+* ``reference`` -  the type ``typename std::iterator_traits<iterator>::reference``.
+
+Requirements for different iterator types
+-----------------------------------------
+
+If the ``iterator`` satisfies `Input iterator` named requirements from [input.iterators] ISO C++ Standard section and do not satisfies
+`Forward iterator` named requirements from [forward.iterators] ISO C++ Standard section, ``tbb::parallel_for_each`` requires the execution
+of the ``body`` with an object of type ``const value_type&`` or ``value_type&&`` to be well-formed. If both forms are well-formed, an overload with
+rvalue reference will be preferred.
+
+.. caution::
+
+  If the ``Body`` only takes non-const lvalue reference to ``value_type``, named requirements above are violated and the program can be ill-formed.
+
+If the ``iterator`` satisfies `Forward iterator` named requirements from [forward.iterators] ISO C++ Standard section, ``tbb::parallel_for_each`` requires the execution of the ``body``
+with an object of type ``reference`` to be well-formed.
+
+Requirements for ``Body`` with ``feeder`` argument
+--------------------------------------------------
+
+Additional elements submitted into ``tbb::parallel_for_each`` through the ``feeder::add`` passes to the ``Body`` as rvalues and therefore the corresponding
+execution of the ``Body`` is required to be well-formed.

doc/main/reference/reference.rst

@@ -0,0 +1,58 @@
+.. _reference:
+
+|short_name| API Reference
+==========================
+
+For oneTBB API Reference, refer to `oneAPI Specification <https://spec.oneapi.com/>`_. The current supported
+version of oneAPI Specification is 1.0.
+
+Specification extensions
+************************
+
+|full_name| implements the `oneTBB specification <https://spec.oneapi.com/versions/latest/elements/oneTBB/source/nested-index.html>`_.
+This document provides additional details or restrictions where necessary.
+It also describes features that are not included in the oneTBB specification.
+
+.. toctree::
+    :titlesonly:
+
+    info_namespace
+    parallel_for_each_semantics
+
+Preview features
+****************
+
+A preview feature is a component of oneTBB introduced to receive early feedback from
+users.
+
+The key properties of a preview feature are:
+
+- It is off by default and must be explicitly enabled.
+- It is intended to have a high quality implementation.
+- There is no guarantee of future existence or compatibility.
+- It may have limited or no support in tools such as correctness analyzers, profilers and debuggers.
+
+
+.. caution::
+    A preview feature is subject to change in future. It might be removed or significantly
+    altered in future releases. Changes to a preview feature do NOT require
+    usual deprecation and removal process. Therefore, using preview features in production code
+    is strongly discouraged.
+
+.. toctree::
+    :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

doc/main/reference/rw_mutex_cls.rst

@@ -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.

doc/main/reference/scalable_memory_pools.rst

@@ -0,0 +1,43 @@
+.. _scalable_memory_pools_reference:
+
+Scalable Memory Pools
+=====================
+
+.. note::
+   To enable this feature, set the ``TBB_PREVIEW_MEMORY_POOL`` macro to 1.
+
+Memory pools allocate and free memory from a specified region or an underlying allocator using
+thread-safe, scalable operations. The  following table summarizes the Memory Pool named requirement.
+Here, ``P`` represents an instance of the memory pool class.
+
+.. container:: tablenoborder
+
+   .. list-table:: 
+      :header-rows: 1
+
+      * -    Pseudo-Signature
+        -    Semantics
+      * -    \ ``~P() throw();``
+        -    Destructor. Frees all the allocated memory.
+      * -    \ ``void P::recycle();``
+        -    Frees all the allocated memory.
+      * -    \ ``void* P::malloc(size_t n);``
+        -    Returns a pointer to ``n`` bytes allocated from the memory pool.
+      * -    \ ``void P::free(void* ptr);``
+        -    Frees the memory object specified via ``ptr`` pointer.
+      * -    \ ``void* P::realloc(void* ptr, size_t n);``
+        -    Reallocates the memory object pointed by ``ptr`` to ``n`` bytes.
+
+.. container:: section
+
+    .. rubric:: Model Types
+        :class: sectiontitle
+
+    The ``memory_pool`` template class and the ``fixed_pool`` class meet the Memory Pool named requirement.
+
+.. toctree::
+    :titlesonly:
+
+    scalable_memory_pools/memory_pool_cls
+    scalable_memory_pools/fixed_pool_cls
+    scalable_memory_pools/memory_pool_allocator_cls

doc/main/reference/scalable_memory_pools/fixed_pool_cls.rst

@@ -0,0 +1,76 @@
+.. _fixed_pool_cls:
+
+fixed_pool
+==========
+
+.. note::
+   To enable this feature, set the ``TBB_PREVIEW_MEMORY_POOL`` macro to 1.
+
+A class for scalable memory allocation from a buffer of fixed size.
+
+.. contents::
+    :local:
+    :depth: 1
+
+Description
+***********
+
+``fixed_pool`` allocates and frees memory in a way that scales with the number of processors.
+All the memory available for the allocation is initially passed through arguments of the constructor.
+``fixed_pool`` meet the :doc:`Memory Pool named requirement<../scalable_memory_pools>`.
+
+API
+***
+
+Header
+------
+
+.. code:: cpp
+
+    #include "oneapi/tbb/memory_pool.h"
+
+Synopsis
+--------
+
+.. code:: cpp
+
+    namespace oneapi {
+        namespace tbb {
+            class fixed_pool {
+            public:
+                fixed_pool(void *buffer, size_t size);
+                fixed_pool(const fixed_pool& other) = delete;
+                fixed_pool& operator=(const fixed_pool& other) = delete;
+                ~fixed_pool();
+
+                void recycle();
+                void* malloc(size_t size);
+                void free(void* ptr);
+                void* realloc(void* ptr, size_t size);
+            };
+        } // namespace tbb
+    } // namespace oneapi
+
+Member Functions
+----------------
+
+.. cpp:function:: fixed_pool(void *buffer, size_t size)
+
+    **Effects**: Constructs a memory pool to manage the memory of size ``size`` pointed to by ``buffer``.
+    Throws the ``bad_alloc`` exception if the library fails to construct an instance of the class.
+
+Examples
+********
+
+The code below provides a simple example of allocation from a fixed pool.
+
+.. code:: cpp
+
+    #define TBB_PREVIEW_MEMORY_POOL 1
+    #include "oneapi/tbb/memory_pool.h"
+    ...
+    char buf[1024*1024];
+    oneapi::tbb::fixed_pool my_pool(buf, 1024*1024);
+    void* my_ptr = my_pool.malloc(10);
+    my_pool.free(my_ptr);}
+

doc/main/reference/scalable_memory_pools/memory_pool_allocator_cls.rst

@@ -0,0 +1,117 @@
+.. _memory_pool_allocator_cls:
+
+memory_pool_allocator
+=====================
+
+.. note::
+   To enable this feature, set the ``TBB_PREVIEW_MEMORY_POOL`` macro to 1.
+
+A class template that provides a memory pool with a C++ allocator interface.
+
+.. contents::
+    :local:
+    :depth: 1
+
+Description
+***********
+
+``memory_pool_allocator`` meets the allocator requirements from the [allocator.requirements] ISO C++ Standard section
+It also provides a constructor to allocate and deallocate memory.
+This constructor is linked with an instance of either the ``memory_pool`` or the ``fixed_pool`` class.
+The class is mainly intended for enabling memory pools within STL containers.
+
+API
+***
+
+Header
+------
+
+.. code:: cpp
+
+    #include "oneapi/tbb/memory_pool.h"
+
+Synopsis
+--------
+
+.. code:: cpp
+
+    namespace oneapi {
+        namespace tbb {
+            template<typename T>
+            class memory_pool_allocator {
+            public:
+                using value_type = T;
+                using pointer = value_type*;
+                using const_pointer = const value_type*;
+                using reference = value_type&;
+                using const_reference = const value_type&;
+                using size_type = size_t;
+                using difference_type = ptrdiff_t;
+                template<typename U> struct rebind {
+                    using other = memory_pool_allocator<U>;
+                };
+                explicit memory_pool_allocator(memory_pool &pool) throw();
+                explicit memory_pool_allocator(fixed_pool &pool) throw();
+                memory_pool_allocator(const memory_pool_allocator& src) throw();
+                template<typename U>
+                memory_pool_allocator(const memory_pool_allocator<U,P>& src) throw();
+                pointer address(reference x) const;
+                const_pointer address(const_reference x) const;
+                pointer allocate(size_type n, const void* hint=0);
+                void deallocate(pointer p, size_type);
+                size_type max_size() const throw();
+                void construct(pointer p, const T& value);
+                void destroy(pointer p);
+            };
+
+            template<>
+            class memory_pool_allocator<void> {
+            public:
+                using pointer = void*;
+                using const_pointer = const void*;
+                using value_type = void;
+                template<typename U> struct rebind {
+                    using other = memory_pool_allocator<U>;
+                };
+                memory_pool_allocator(memory_pool &pool) throw();
+                memory_pool_allocator(fixed_pool &pool) throw();
+                memory_pool_allocator(const memory_pool_allocator& src) throw();
+                template<typename U>
+                memory_pool_allocator(const memory_pool_allocator<U>& src) throw();
+            };
+        } // namespace tbb
+    } // namespace oneapi
+
+    template<typename T, typename U>
+    inline bool operator==( const memory_pool_allocator<T>& a,
+                           const memory_pool_allocator<U>& b);
+    template<typename T, typename U>
+    inline bool operator!=( const memory_pool_allocator<T>& a,
+                            const memory_pool_allocator<U>& b);
+
+Member Functions
+----------------
+
+.. cpp:function:: explicit memory_pool_allocator(memory_pool &pool)
+
+    **Effects**: Constructs a memory pool allocator serviced by ``memory_pool`` instance pool.
+
+-------------------------------------------------------
+
+.. cpp:function:: explicit memory_pool_allocator(fixed_pool &pool)
+
+    **Effects**: Constructs a memory pool allocator serviced by ``fixed_pool`` instance pool.
+
+Examples
+********
+
+The code below provides a simple example of container construction with the use of a memory pool.
+
+.. code:: cpp
+
+    #define TBB_PREVIEW_MEMORY_POOL 1
+    #include "oneapi/tbb/memory_pool.h"
+    ...
+    typedef oneapi::tbb::memory_pool_allocator<int>
+    pool_allocator_t;
+    std::list<int, pool_allocator_t> my_list(pool_allocator_t( my_pool ));

doc/main/reference/scalable_memory_pools/memory_pool_cls.rst

@@ -0,0 +1,80 @@
+.. _memory_pool_cls:
+
+memory_pool
+===========
+
+.. note::
+   To enable this feature, set the ``TBB_PREVIEW_MEMORY_POOL`` macro to 1.
+
+A class template for scalable memory allocation from memory blocks provided by an underlying allocator.
+
+.. contents::
+    :local:
+    :depth: 1
+
+Description
+***********
+
+A ``memory_pool`` allocates and frees memory in a way that scales with the number of processors.
+The memory is obtained as big chunks from an underlying allocator specified by the template
+argument. The latter must satisfy the subset of the allocator requirements from the [allocator.requirements]
+ISO C++ Standard section. A ``memory_pool`` meet the :doc:`Memory Pool named requirement<../scalable_memory_pools>`.
+
+.. caution::
+
+    If the underlying allocator refers to another scalable memory pool, the inner pool (or pools)
+    must be destroyed before the outer pool is destroyed or recycled.
+
+API
+***
+
+Header
+------
+
+.. code:: cpp
+
+    #include "oneapi/tbb/memory_pool.h"
+
+Synopsis
+--------
+
+.. code:: cpp
+
+    namespace oneapi {
+        namespace tbb {
+            template <typename Alloc>
+            class memory_pool {
+            public:
+                explicit memory_pool(const Alloc &src = Alloc());
+                memory_pool(const memory_pool& other) = delete;
+                memory_pool& operator=(const memory_pool& other) = delete;
+                ~memory_pool();
+                void recycle();
+                void *malloc(size_t size);
+                void free(void* ptr);
+               void *realloc(void* ptr, size_t size);
+            };
+        }
+    }
+
+Member Functions
+----------------
+
+.. cpp:function:: explicit memory_pool(const Alloc &src = Alloc())
+
+    **Effects**: Constructs a memory pool with an instance of underlying memory allocator of type ``Alloc`` copied from ``src``.
+    Throws the ``bad_alloc`` exception if runtime fails to construct an instance of the class.
+
+Examples
+********
+
+The code below provides a simple example of allocation from an extensible memory pool.
+
+.. code:: cpp
+
+    #define TBB_PREVIEW_MEMORY_POOL 1
+    #include "oneapi/tbb/memory_pool.h"
+    ...
+    oneapi::tbb::memory_pool<std::allocator<char> > my_pool;
+    void* my_ptr = my_pool.malloc(10);
+    my_pool.free(my_ptr);

doc/main/reference/task_arena_extensions.rst

@@ -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` 

doc/main/reference/task_group_extensions.rst

@@ -0,0 +1,102 @@
+.. _task_group_extensions:
+
+task_group 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_group specification <https://spec.oneapi.com/versions/latest/elements/oneTBB/source/task_scheduler/task_group/task_group_cls.html>`_ with the following members:
+
+  - 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
+***
+
+Header
+------
+
+.. code:: cpp
+
+    #include <oneapi/tbb/task_group.h>
+
+Synopsis
+--------
+
+.. code:: cpp
+
+    namespace oneapi {
+        namespace tbb {
+   
+           class task_group {
+           public:
+               task_group(task_group_context& context);
+               
+               template<typename F>
+               task_handle defer(F&& f);
+                   
+               void run(task_handle&& h);
+
+               //only F return type requirements have changed              
+               template<typename F>
+               void run(F&& f);
+           }; 
+
+        } // 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)
+
+Creates a deferred task to compute ``f()`` and returns ``task_handle`` pointing to it.
+
+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.
+
+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 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.
+
+.. note::
+   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. 
+    
+               
+.. rubric:: See also
+
+* `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>`_
+* :doc:`oneapi::tbb::task_handle class <task_group_extensions/task_handle>`

doc/main/reference/task_group_extensions/task_handle.rst

@@ -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.
+   

doc/main/reference/this_task_arena_extensions.rst

@@ -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` 

doc/main/reference/type_specified_message_keys.rst

@@ -0,0 +1,69 @@
+.. _class_join_node_extension:
+
+Type-specified message keys for join_node
+=========================================
+
+.. note::
+    To enable this feature, define the ``TBB_PREVIEW_FLOW_GRAPH_FEATURES`` macro to 1.
+
+.. contents::
+    :local:
+    :depth: 1
+
+Description
+***********
+
+The extension allows a key matching ``join_node`` to obtain keys via functions associated with
+its input types. The extension simplifies the existing approach by removing the need to
+provide a function object for each input port of ``join_node``.
+
+API
+***
+
+Header
+------
+
+.. code:: cpp
+
+   #include "oneapi/tbb/flow_graph.h"
+
+Syntax
+------
+
+The extension adds a special constructor to the ``join_node`` interface when the
+``key_matching<typename K, class KHash=tbb_hash_compare>`` policy is
+used. The constructor has the following signature:
+
+.. code:: cpp
+
+   join_node( graph &g )
+
+When constructed this way, a ``join_node`` calls the
+``key_from_message`` function for each incoming message to obtain the key associated
+with it. The default implementation of ``key_from_message`` is the following
+
+.. code:: cpp
+
+   namespace oneapi {
+       namespace tbb {
+           namespace flow {
+               template <typename K, typename T>
+               K key_from_message( const T &t ) {
+                   return t.key();
+               }
+           }
+       }
+   }
+
+``T`` is one of the user-provided types in ``OutputTuple`` and is
+used to construct the ``join_node``, and ``K`` is the key type
+of the node.
+By default, the ``key()`` method defined in the message class will be called.
+Alternatively, the user can define its own ``key_from_message`` function in the
+same namespace with the message type. This function will be found via C++ argument-dependent
+lookup and used in place of the default implementation.
+
+See Also
+********
+
+`join_node Specification <https://spec.oneapi.com/versions/latest/elements/oneTBB/source/flow_graph/join_node_cls.html>`_

doc/main/tbb_userguide/Advanced_Example.rst

@@ -0,0 +1,96 @@
+.. _Advanced_Example:
+
+Advanced Example
+================
+
+
+An example of a more advanced associative operation is to find the index
+where ``Foo(i)`` is minimized. A serial version might look like this:
+
+
+::
+
+
+   long SerialMinIndexFoo( const float a[], size_t n ) {
+       float value_of_min = FLT_MAX;        // FLT_MAX from <climits>
+       long index_of_min = -1;
+       for( size_t i=0; i<n; ++i ) {
+           float value = Foo(a[i]);
+           if( value<value_of_min ) {
+               value_of_min = value;
+               index_of_min = i;
+           }
+       }  
+       return index_of_min;
+   }
+
+
+The loop works by keeping track of the minimum value found so far, and
+the index of this value. This is the only information carried between
+loop iterations. To convert the loop to use ``parallel_reduce``, the
+function object must keep track of the carried information, and how to
+merge this information when iterations are spread across multiple
+threads. Also, the function object must record a pointer to ``a`` to
+provide context.
+
+
+The following code shows the complete function object.
+
+
+::
+
+
+   class MinIndexFoo {
+       const float *const my_a;
+   public:
+       float value_of_min;
+       long index_of_min; 
+       void operator()( const blocked_range<size_t>& r ) {
+           const float *a = my_a;
+           for( size_t i=r.begin(); i!=r.end(); ++i ) {
+              float value = Foo(a[i]);    
+              if( value<value_of_min ) {
+                  value_of_min = value;
+                  index_of_min = i;
+              }
+           }
+       }
+    
+
+       MinIndexFoo( MinIndexFoo& x, split ) : 
+           my_a(x.my_a), 
+           value_of_min(FLT_MAX),    // FLT_MAX from <climits>
+           index_of_min(-1) 
+      {}
+    
+
+       void join( const SumFoo& y ) {
+           if( y.value_of_min<value_of_min ) {
+               value_of_min = y.value_of_min;
+               index_of_min = y.index_of_min;
+           }
+       }
+                
+
+       MinIndexFoo( const float a[] ) :
+           my_a(a), 
+           value_of_min(FLT_MAX),    // FLT_MAX from <climits>
+           index_of_min(-1),
+       {}
+   };
+
+
+Now ``SerialMinIndex`` can be rewritten using ``parallel_reduce`` as
+shown below:
+
+
+::
+
+
+   long ParallelMinIndexFoo( float a[], size_t n ) {
+       MinIndexFoo mif(a);
+       parallel_reduce(blocked_range<size_t>(0,n), mif );
+      
+
+    return mif.index_of_min;
+   }

doc/main/tbb_userguide/Advanced_Topic_Other_Kinds_of_Iteration_Spaces.rst

@@ -0,0 +1,81 @@
+.. _Advanced_Topic_Other_Kinds_of_Iteration_Spaces:
+
+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 (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:
+
+
+::
+
+
+   class R {
+       // True if range is empty
+       bool empty() const;
+       // True if range can be split into non-empty subranges
+       bool is_divisible() const;
+       // Splits r into subranges r and *this
+       R( R& r, split );
+       // 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;
+       ...
+   };
+       
+
+
+
+The method ``empty`` should return true if the range is empty. The
+method ``is_divisible`` should return true if the range can be split
+into two non-empty subspaces, and such a split is worth the overhead.
+The basic splitting constructor should take two arguments:
+
+
+-  The first of type ``R``
+
+
+-  The second of type oneapi::tbb::split
+
+
+The second argument is not used; it serves only to distinguish the
+constructor from an ordinary copy constructor. The basic splitting
+constructor should attempt to split ``r`` roughly into two halves, and
+update ``r`` to be the first half, and set the constructed object as the
+second half.
+
+
+Unlike the basic splitting constructor, the proportional splitting
+constructor is optional and takes the second argument of type
+``oneapi::tbb::proportional_split``. The type has methods ``left`` and ``right``
+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 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
+and the constructed object are not empty. The parallel algorithm
+templates call the splitting constructors on ``r`` only if
+``r.is_divisible`` is true.
+
+
+The iteration space does not have to be linear. Look at
+``oneapi/tbb/blocked_range2d.h`` for an example of a range that is
+two-dimensional. Its splitting constructor attempts to split the range
+along its longest axis. When used with ``parallel_for``, it causes the
+loop to be "recursively blocked" in a way that improves cache usage.
+This nice cache behavior means that using ``parallel_for`` over a
+``blocked_range2d<T>`` can make a loop run faster than the sequential
+equivalent, even on a single processor.

doc/main/tbb_userguide/Allocator_Configuration.rst

@@ -0,0 +1,42 @@
+.. _Allocator_Configuration:
+
+Configuring the Memory Allocator
+================================
+
+
+The oneTBB memory allocator provides the following API functions and
+environment variables to configure its behavior:
+
+
+-  the ``scalable_allocation_command`` function instructs the allocator
+   to perform a certain action, such as cleaning up its internal memory
+   buffers.
+
+
+-  the ``scalable_allocation_mode`` function allows an application to
+   set certain parameters for the memory allocator, such as an option to
+   map memory in huge pages or define a recommended heap size. These
+   settings take effect until modified by another call to
+   ``scalable_allocation_mode``.
+
+
+Some of the memory allocator parameters can also be set via system
+environment variables. It can be useful to adjust the behavior without
+modifying application source code, to ensure that a setting takes effect
+as early as possible, or to avoid explicit dependency on the oneTBB
+allocator binaries. The following environment variables are recognized:
+
+
+-  ``TBB_MALLOC_USE_HUGE_PAGES`` controls usage of huge pages for memory
+   mapping.
+
+
+-  ``TBB_MALLOC_SET_HUGE_OBJECT_THRESHOLD`` defines the lower bound for
+   the size (bytes), that is interpreted as huge and not released during
+   regular cleanup operations.
+
+
+These variables only take effect at the time the memory manager is
+initialized; later environment changes are ignored. A call to
+``scalable_allocation_mode`` overrides the effect of the corresponding
+environment variable.

doc/main/tbb_userguide/Automatic_Chunking.rst

@@ -0,0 +1,23 @@
+.. _Automatic_Chunking:
+
+Automatic Chunking
+==================
+
+
+A parallel loop construct incurs overhead cost for every chunk of work
+that it schedules. |full_name|
+chooses chunk sizes automatically, depending upon load balancing
+needs. The heuristic attempts to limit overheads while
+still providing ample opportunities for load balancing.
+
+
+.. CAUTION::
+   Typically a loop needs to take at least a million clock cycles to
+   make it worth using ``parallel_for``. For example, a loop that takes
+   at least 500 microseconds on a 2 GHz processor might benefit from
+   ``parallel_for``.
+
+
+The default automatic chunking is recommended for most uses. As with
+most heuristics, however, there are situations where controlling the
+chunk size more precisely might yield better performance.

doc/main/tbb_userguide/Automically_Replacing_malloc.rst

@@ -0,0 +1,22 @@
+.. _Automically_Replacing_malloc:
+
+Automatically Replacing ``malloc`` and Other C/C++ Functions for Dynamic Memory Allocation
+==========================================================================================
+
+
+On Windows*, Linux\* operating systems, it is possible to automatically
+replace all calls to standard functions for dynamic memory allocation
+(such as ``malloc``) with the |full_name| scalable equivalents.
+Doing so can sometimes improve application performance.
+
+
+Replacements are provided by the proxy library (the library names can be
+found in platform-specific sections below). A proxy library and a
+scalable memory allocator library should be taken from the same release
+of oneTBB, otherwise the libraries may be mutually incompatible.
+
+.. toctree::
+   :maxdepth: 4
+
+   ../tbb_userguide/Windows_C_Dynamic_Memory_Interface_Replacement
+   ../tbb_userguide/Linux_C_Dynamic_Memory_Interface_Replacement

doc/main/tbb_userguide/Bandwidth_and_Cache_Affinity.rst

@@ -0,0 +1,113 @@
+.. _Bandwidth_and_Cache_Affinity:
+
+Bandwidth and Cache Affinity
+============================
+
+
+For a sufficiently simple function ``Foo``, the examples might not show
+good speedup when written as parallel loops. The cause could be
+insufficient system bandwidth between the processors and memory. In that
+case, you may have to rethink your algorithm to take better advantage of
+cache. Restructuring to better utilize the cache usually benefits the
+parallel program as well as the serial program.
+
+
+An alternative to restructuring that works in some cases is
+``affinity_partitioner.`` It not only automatically chooses the
+grainsize, but also optimizes for cache affinity and tries to distribute
+the data uniformly among threads. Using ``affinity_partitioner`` can
+significantly improve performance when:
+
+
+-  The computation does a few operations per data access.
+
+
+-  The data acted upon by the loop fits in cache.
+
+
+-  The loop, or a similar loop, is re-executed over the same data.
+
+
+-  There are more than two hardware threads available (and especially if
+   the number of threads is not a power of two). If only two threads are
+   available, the default scheduling in |full_name| 
+   usually provides sufficient cache affinity.
+
+
+The following code shows how to use ``affinity_partitioner``.
+
+
+::
+
+
+   #include "oneapi/tbb.h"
+    
+
+   void ParallelApplyFoo( float a[], size_t n ) {
+       static affinity_partitioner ap;
+       parallel_for(blocked_range<size_t>(0,n), ApplyFoo(a), ap);
+   }
+    
+
+   void TimeStepFoo( float a[], size_t n, int steps ) {    
+       for( int t=0; t<steps; ++t )
+           ParallelApplyFoo( a, n );
+   }
+
+
+In the example, the ``affinity_partitioner`` object ``ap`` lives between
+loop iterations. It remembers where iterations of the loop ran, so that
+each iteration can be handed to the same thread that executed it before.
+The example code gets the lifetime of the partitioner right by declaring
+the ``affinity_partitioner`` as a local static object. Another approach
+would be to declare it at a scope outside the iterative loop in
+``TimeStepFoo``, and hand it down the call chain to ``parallel_for``.
+
+
+If the data does not fit across the system’s caches, there may be little
+benefit. The following figure shows the situations.
+
+
+.. container:: fignone
+   :name: fig3
+
+
+   Benefit of Affinity Determined by Relative Size of Data Set and Cache
+   |image0|
+
+
+The next figure shows how parallel speedup might vary with the size of a
+data set. The computation for the example is ``A[i]+=B[i]`` for ``i`` in
+the range [0,N). It was chosen for dramatic effect. You are unlikely to
+see quite this much variation in your code. The graph shows not much
+improvement at the extremes. For small N, parallel scheduling overhead
+dominates, resulting in little speedup. For large N, the data set is too
+large to be carried in cache between loop invocations. The peak in the
+middle is the sweet spot for affinity. Hence ``affinity_partitioner``
+should be considered a tool, not a cure-all, when there is a low ratio
+of computations to memory accesses.
+
+
+.. container:: fignone
+   :name: fig4
+
+
+   Improvement from Affinity Dependent on Array Size
+   |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
+   :width: 453px
+   :height: 178px
+.. |image1| image:: Images/image008.jpg
+   :width: 551px
+   :height: 192px
+

doc/main/tbb_userguide/Basic_Flow_Graph_concepts.rst

@@ -0,0 +1,16 @@
+.. _Basic_Flow_Graph_concepts:
+
+Basic Flow Graph Concepts
+=========================
+
+.. toctree::
+   :maxdepth: 4
+
+   ../tbb_userguide/Graph_Object
+   ../tbb_userguide/Nodes
+   ../tbb_userguide/Edges
+   ../tbb_userguide/Mapping_Nodes2Tasks
+   ../tbb_userguide/Flow_Graph_Message_Passing_Protocol
+   ../tbb_userguide/Flow_Graph_Single_Vs_Broadcast
+   ../tbb_userguide/Flow_Graph_Buffering_in_Nodes
+   ../tbb_userguide/Flow_Graph_Reservation

doc/main/tbb_userguide/Cancellation_Without_An_Exception.rst

@@ -0,0 +1,46 @@
+.. _Cancellation_Without_An_Exception:
+
+Cancellation Without An Exception
+=================================
+
+
+To cancel an algorithm but not throw an exception, use the expression ``current_context()->cancel_group_execution()``.
+The part ``current_context()`` references the ``task_group_context*`` of the currently executing task if any on the current thread.
+Calling ``cancel_group_execution()`` cancels all tasks in its ``task_group_context``, which is explained in more detail in :ref:`Cancellation_and_Nested_Parallelism`.
+The method returns ``true`` if it actually causes cancellation, ``false`` if the ``task_group_context`` was already cancelled.
+
+The example below shows how to use ``current_context()->cancel_group_execution()``.
+
+::
+
+   #include "oneapi/tbb.h"
+
+   #include <vector>
+   #include <iostream>
+    
+   using namespace oneapi::tbb;
+   using namespace std;
+    
+   vector<int> Data;
+    
+   struct Update {
+       void operator()( const blocked_range<int>& r ) const {
+           for( int i=r.begin(); i!=r.end(); ++i )
+               if( i<Data.size() ) {
+                   ++Data[i];
+               } else {
+                   // Cancel related tasks.
+                   if( current_context()->cancel_group_execution() )
+                       cout << "Index " << i << " caused cancellation\n";
+                   return;
+               }
+       }
+   };
+    
+
+   int main() {
+       Data.resize(1000);
+       parallel_for( blocked_range<int>(0, 2000), Update());
+       return 0;
+   }
+

doc/main/tbb_userguide/Cancellation_and_Nested_Parallelism.rst

@@ -0,0 +1,136 @@
+.. _Cancellation_and_Nested_Parallelism:
+
+Cancellation and Nested Parallelism
+===================================
+
+
+The discussion so far was simplified by assuming non-nested parallelism
+and skipping details of ``task_group_context``. This topic explains
+both.
+
+
+An |full_name| algorithm executes
+by creating ``task`` objects that execute the snippets of code that you
+supply to the algorithm template. By default, these ``task`` objects are
+associated with a ``task_group_context`` created by the algorithm.
+Nested oneTBB algorithms create a tree of these ``task_group_context``
+objects. Cancelling a ``task_group_context`` cancels all of its child
+``task_group_context`` objects, and transitively all its descendants.
+Hence an algorithm and all algorithms it called can be cancelled with a
+single request.
+
+
+Exceptions propagate upwards. Cancellation propagates downwards. The
+opposition interplays to cleanly stop a nested computation when an
+exception occurs. For example, consider the tree in the following
+figure. Imagine that each node represents an algorithm and its
+``task_group_context``.
+
+
+.. container:: fignone
+   :name: fig6
+
+
+   Tree of task_group_context
+   |image0|
+
+
+Suppose that the algorithm in C throws an exception and no node catches
+the exception. oneTBB propagates the exception upwards, cancelling
+related subtrees downwards, as follows:
+
+
+#. Handle exception in C:
+
+
+   a. Capture exception in C.
+
+
+   b. Cancel tasks in C.
+
+
+   c. Throw exception from C to B.
+
+
+#. Handle exception in B:
+
+
+   a. Capture exception in B.
+
+
+   b. Cancel tasks in B and, by downwards propagation, in D.
+
+
+   c. Throw an exception out of B to A.
+
+
+#. Handle exception in A:
+
+
+   a. Capture exception in A.
+
+
+   b. Cancel tasks in A and, by downwards propagation, in E, F, and G.
+
+
+   c. Throw an exception upwards out of A.
+
+
+If your code catches the exception at any level, then oneTBB does not
+propagate it any further. For example, an exception that does not escape
+outside the body of a ``parallel_for`` does not cause cancellation of
+other iterations.
+
+
+To prevent downwards propagation of cancellation into an algorithm,
+construct an 'isolated' ``task_group_context`` on the stack and pass it
+to the algorithm explicitly. The example uses C++11 lambda expressions for brevity.
+
+
+::
+
+
+   #include "oneapi/tbb.h"
+    
+
+   bool Data[1000][1000];
+    
+
+   int main() {
+       try {
+           parallel_for( 0, 1000, 1, 
+               []( int i ) {
+                   task_group_context root(task_group_context::isolated);
+                   parallel_for( 0, 1000, 1,
+                      []( int  ) {
+                          Data[i][j] = true;
+                      },
+                      root);
+                   throw "oops";
+               });
+       } catch(...) {
+       }
+       return 0;
+   }
+
+
+The example performs two parallel loops: an outer loop over ``i`` and
+inner loop over ``j``. The creation of the isolated
+``task_group_context`` ``root`` protects the inner loop from downwards
+propagation of cancellation from the ``i`` loop. When the exception
+propagates to the outer loop, any pending ``outer`` iterations are
+cancelled, but not inner iterations for an outer iteration that started.
+Hence when the program completes, each row of ``Data`` may be different,
+depending upon whether its iteration ``i`` ran at all, but within a row,
+the elements will be homogeneously ``false`` or ``true``, not a mixture.
+
+
+Removing the blue text would permit cancellation to propagate down into
+the inner loop. In that case, a row of ``Data`` might end up with both
+``true`` and ``false`` values.
+
+
+.. |image0| image:: Images/image013.jpg
+   :width: 261px
+   :height: 131px
+

doc/main/tbb_userguide/Concurrent_Queue_Classes.rst

@@ -0,0 +1,108 @@
+.. _Concurrent_Queue_Classes:
+
+Concurrent Queue Classes
+========================
+
+
+Template class ``concurrent_queue<T,Alloc>`` implements a concurrent
+queue with values of type ``T``. Multiple threads may simultaneously
+push and pop elements from the queue. The queue is unbounded and has no
+blocking operations. The fundamental operations on it are ``push`` and
+``try_pop``. The ``push`` operation works just like ``push`` for a
+std::queue. The operation ``try_pop`` pops an item if it is available.
+The check and popping have to be done in a single operation for sake of
+thread safety.
+
+
+For example, consider the following serial code:
+
+
+::
+
+
+           extern std::queue<T> MySerialQueue;
+           T item;
+           if( !MySerialQueue.empty() ) {
+               item = MySerialQueue.front(); 
+               MySerialQueue.pop_front();
+               ... process item...
+           }
+
+
+Even if each std::queue method were implemented in a thread-safe manner,
+the composition of those methods as shown in the example would not be
+thread safe if there were other threads also popping from the same
+queue. For example, ``MySerialQueue.empty()`` might return true just
+before another thread snatches the last item from ``MySerialQueue``.
+
+
+The equivalent thread-safe |full_name| code is:
+
+
+::
+
+
+           extern concurrent_queue<T> MyQueue;
+           T item;
+           if( MyQueue.try_pop(item) ) {
+               ...process item...
+           }            
+
+
+In a single-threaded program, a queue is a first-in first-out structure.
+But if multiple threads are pushing and popping concurrently, the
+definition of "first" is uncertain. Use of ``concurrent_queue``
+guarantees that if a thread pushes two values, and another thread pops
+those two values, they will be popped in the same order that they were
+pushed.
+
+
+Template class ``concurrent_queue`` is unbounded and has no methods that
+wait. It is up to the user to provide synchronization to avoid overflow,
+or to wait for the queue to become non-empty. Typically this is
+appropriate when the synchronization has to be done at a higher level.
+
+
+Template class ``concurrent_bounded_queue<T,Alloc>`` is a variant that
+adds blocking operations and the ability to specify a capacity. The
+methods of particular interest on it are:
+
+
+-  ``pop(item)`` waits until it can succeed.
+
+
+-  ``push(item)`` waits until it can succeed without exceeding the
+   queue's capacity.
+
+
+-  ``try_push(item)`` pushes ``item`` only if it would not exceed the
+   queue's capacity.
+
+
+-  size() returns a *signed* integer.
+
+
+The value of concurrent_queue::size() is defined as the number of push
+operations started minus the number of pop operations started. If pops
+outnumber pushes, ``size()`` becomes negative. For example, if a
+``concurrent_queue`` is empty, and there are ``n`` pending pop
+operations, ``size()`` returns -\ ``n``. This provides an easy way for
+producers to know how many consumers are waiting on the queue. Method
+``empty()`` is defined to be true if and only if ``size()`` is not
+positive.
+
+
+By default, a ``concurrent_bounded_queue`` is unbounded. It may hold any
+number of values, until memory runs out. It can be bounded by setting
+the queue capacity with method ``set_capacity``.Setting the capacity
+causes ``push`` to block until there is room in the queue. Bounded
+queues are slower than unbounded queues, so if there is a constraint
+elsewhere in your program that prevents the queue from becoming too
+large, it is better not to set the capacity. If you do not need the
+bounds or the blocking pop, consider using ``concurrent_queue`` instead.
+
+.. toctree::
+   :maxdepth: 4
+
+   ../tbb_userguide/Iterating_Over_a_Concurrent_Queue_for_Debugging
+   ../tbb_userguide/When_Not_to_Use_Queues

doc/main/tbb_userguide/Constraints.rst

@@ -0,0 +1,30 @@
+.. _Constraints:
+
+Constrained APIs
+================
+
+Starting from C++20, most of |full_name| APIs are constrained to
+enforce `named requirements <https://spec.oneapi.com/versions/latest/elements/oneTBB/source/named_requirements.html>`_ on
+template arguments types.
+
+The violations of these requirements are detected at a compile time during the template instantiation.
+
+.. rubric:: Example
+
+.. code:: cpp
+
+    // Call for body(oneapi::tbb::blocked_range) is ill-formed
+    // oneapi::tbb::parallel_for call results in constraint failure
+    auto body = [](const int& r) { /*...*/ };
+    oneapi::tbb::parallel_for(oneapi::tbb::blocked_range{1, 10}, body);
+
+    // Error example:
+    // error: no matching function to call to oneapi::tbb::parallel_for
+    // note: constraints not satisfied
+    // note: the required expression 'body(range)' is invalid
+            body(range);
+
+.. caution::
+
+    The code that violates named requirements but compiles successfully until C++20,
+    may not compile in C++20 mode due to early and strict constraints diagnostics.

doc/main/tbb_userguide/Containers.rst

@@ -0,0 +1,55 @@
+.. _Containers:
+
+Containers
+==========
+
+
+|full_name| provides highly concurrent
+container classes. These containers can be used with raw Windows\* OS or
+Linux\* OS threads, or in conjunction with task-based programming.
+
+
+A concurrent container allows multiple threads to concurrently access
+and update items in the container. Typical C++ STL containers do not
+permit concurrent update; attempts to modify them concurrently often
+result in corrupting the container. STL containers can be wrapped in a
+mutex to make them safe for concurrent access, by letting only one
+thread operate on the container at a time, but that approach eliminates
+concurrency, thus restricting parallel speedup.
+
+
+Containers provided by oneTBB offer a much higher level of concurrency,
+via one or both of the following methods:
+
+
+-  **Fine-grained locking:** Multiple threads operate on the container
+   by locking only those portions they really need to lock. As long as
+   different threads access different portions, they can proceed
+   concurrently.
+
+
+-  **Lock-free techniques:** Different threads account and correct for
+   the effects of other interfering threads.
+
+
+Notice that highly-concurrent containers come at a cost. They typically
+have higher overheads than regular STL containers. Operations on
+highly-concurrent containers may take longer than for STL containers.
+Therefore, use highly-concurrent containers when the speedup from the
+additional concurrency that they enable outweighs their slower
+sequential performance.
+
+
+.. CAUTION:: 
+   As with most objects in C++, the constructor or destructor of a
+   container object must not be invoked concurrently with another
+   operation on the same object. Otherwise the resulting race may cause
+   the operation to be executed on an undefined object.
+
+.. toctree::
+   :maxdepth: 4
+
+   ../tbb_userguide/concurrent_hash_map
+   ../tbb_userguide/concurrent_vector_ug
+   ../tbb_userguide/Concurrent_Queue_Classes
+   ../tbb_userguide/Summary_of_Containers

doc/main/tbb_userguide/Controlling_Chunking.rst

@@ -0,0 +1,175 @@
+.. _Controlling_Chunking:
+
+Controlling Chunking
+====================
+
+
+Chunking is controlled by a *partitioner* and a *grainsize.*\  To gain
+the most control over chunking, you specify both.
+
+
+-  Specify ``simple_partitioner()`` as the third argument to
+   ``parallel_for``. Doing so turns off automatic chunking.
+
+
+-  Specify the grainsize when constructing the range. The thread
+   argument form of the constructor is
+   ``blocked_range<T>(begin,end,grainsize)``. The default value of
+   ``grainsize`` is 1. It is in units of loop iterations per chunk.
+
+
+If the chunks are too small, the overhead may exceed the performance
+advantage.
+
+
+The following code is the last example from parallel_for, modified to
+use an explicit grainsize ``G``.
+
+
+::
+
+
+   #include "oneapi/tbb.h"
+    
+
+   void ParallelApplyFoo( float a[], size_t n ) {
+       parallel_for(blocked_range<size_t>(0,n,G), ApplyFoo(a), 
+                    simple_partitioner());
+   }
+
+
+The grainsize sets a minimum threshold for parallelization. The
+``parallel_for`` in the example invokes ``ApplyFoo::operator()`` on
+chunks, possibly of different sizes. Let *chunksize* be the number of
+iterations in a chunk. Using ``simple_partitioner`` guarantees that
+[G/2] <= *chunksize* <= G.
+
+
+There is also an intermediate level of control where you specify the
+grainsize for the range, but use an ``auto_partitioner`` and
+``affinity_partitioner``. An ``auto_partitioner`` is the default
+partitioner. Both partitioners implement the automatic grainsize
+heuristic described in :ref:`Automatic_Chunking`. An
+``affinity_partitioner`` implies an additional hint, as explained later
+in Section :ref:`Bandwidth_and_Cache_Affinity`. Though these partitioners
+may cause chunks to have more than G iterations, they never generate
+chunks with less than [G/2] iterations. Specifying a range with an
+explicit grainsize may occasionally be useful to prevent these
+partitioners from generating wastefully small chunks if their heuristics
+fail.
+
+
+Because of the impact of grainsize on parallel loops, it is worth
+reading the following material even if you rely on ``auto_partitioner``
+and ``affinity_partitioner`` to choose the grainsize automatically.
+
+
+.. container:: tablenoborder
+
+
+   .. list-table:: 
+      :header-rows: 1
+
+      * -     |image0|
+        -     |image1|
+      * -     Case A     
+        -     Case B     
+
+
+
+
+The above figure illustrates the impact of grainsize by showing the
+useful work as the gray area inside a brown border that represents
+overhead. Both Case A and Case B have the same total gray area. Case A
+shows how too small a grainsize leads to a relatively high proportion of
+overhead. Case B shows how a large grainsize reduces this proportion, at
+the cost of reducing potential parallelism. The overhead as a fraction
+of useful work depends upon the grainsize, not on the number of grains.
+Consider this relationship and not the total number of iterations or
+number of processors when setting a grainsize.
+
+
+A rule of thumb is that ``grainsize`` iterations of ``operator()``
+should take at least 100,000 clock cycles to execute. For example, if a
+single iteration takes 100 clocks, then the ``grainsize`` needs to be at
+least 1000 iterations. When in doubt, do the following experiment:
+
+
+#. Set the ``grainsize`` parameter higher than necessary. The grainsize
+   is specified in units of loop iterations. If you have no idea of how
+   many clock cycles an iteration might take, start with
+   ``grainsize``\ =100,000. The rationale is that each iteration
+   normally requires at least one clock per iteration. In most cases,
+   step 3 will guide you to a much smaller value.
+
+
+#. Run your algorithm.
+
+
+#. Iteratively halve the ``grainsize`` parameter and see how much the
+   algorithm slows down or speeds up as the value decreases.
+
+
+A drawback of setting a grainsize too high is that it can reduce
+parallelism. For example, if the grainsize is 1000 and the loop has 2000
+iterations, the ``parallel_for`` distributes the loop across only two
+processors, even if more are available. However, if you are unsure, err
+on the side of being a little too high instead of a little too low,
+because too low a value hurts serial performance, which in turns hurts
+parallel performance if there is other parallelism available higher up
+in the call tree.
+
+
+.. tip:: 
+   You do not have to set the grainsize too precisely.
+
+
+The next figure shows the typical "bathtub curve" for execution time
+versus grainsize, based on the floating point ``a[i]=b[i]*c``
+computation over a million indices. There is little work per iteration.
+The times were collected on a four-socket machine with eight hardware
+threads.
+
+
+.. container:: fignone
+   :name: fig2
+
+
+   Wall Clock Time Versus Grainsize
+   |image2|
+
+
+The scale is logarithmic. The downward slope on the left side indicates
+that with a grainsize of one, most of the overhead is parallel
+scheduling overhead, not useful work. An increase in grainsize brings a
+proportional decrease in parallel overhead. Then the curve flattens out
+because the parallel overhead becomes insignificant for a sufficiently
+large grainsize. At the end on the right, the curve turns up because the
+chunks are so large that there are fewer chunks than available hardware
+threads. Notice that a grainsize over the wide range 100-100,000 works
+quite well.
+
+
+.. tip:: 
+   A general rule of thumb for parallelizing loop nests is to
+   parallelize the outermost one possible. The reason is that each
+   iteration of an outer loop is likely to provide a bigger grain of
+   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
+   :height: 163px
+.. |image1| image:: Images/image004.jpg
+   :width: 157px
+   :height: 144px
+.. |image2| image:: Images/image006.jpg
+   :width: 462px
+   :height: 193px
+

doc/main/tbb_userguide/Cook_Until_Done_parallel_do.rst

@@ -0,0 +1,84 @@
+.. _Cook_Until_Done_parallel_do:
+
+Cook Until Done: parallel_for_each
+==================================
+
+
+For some loops, the end of the iteration space is not known in advance,
+or the loop body may add more iterations to do before the loop exits.
+You can deal with both situations using the template class ``oneapi::tbb::parallel_for_each``.
+
+
+A linked list is an example of an iteration space that is not known in
+advance. In parallel programming, it is usually better to use dynamic
+arrays instead of linked lists, because accessing items in a linked list
+is inherently serial. But if you are limited to linked lists, the items
+can be safely processed in parallel, and processing each item takes at
+least a few thousand instructions, you can use ``parallel_for_each`` to
+gain some parallelism.
+
+
+For example, consider the following serial code:
+
+
+::
+
+
+   void SerialApplyFooToList( const std::list<Item>& list ) {
+       for( std::list<Item>::const_iterator i=list.begin() i!=list.end(); ++i ) 
+           Foo(*i);
+   }
+
+
+If ``Foo`` takes at least a few thousand instructions to run, you can
+get parallel speedup by converting the loop to use
+``parallel_for_each``. To do so, define an object with a ``const``
+qualified ``operator()``. This is similar to a C++ function object from
+the C++ standard header ``<functional>``, except that ``operator()``
+must be ``const``.
+
+
+::
+
+
+   class ApplyFoo {
+   public:
+       void operator()( Item& item ) const {
+           Foo(item);
+       }
+   };
+
+
+The parallel form of ``SerialApplyFooToList`` is as follows:
+
+
+::
+
+
+   void ParallelApplyFooToList( const std::list<Item>& list ) {
+       parallel_for_each( list.begin(), list.end(), ApplyFoo() ); 
+   }
+
+
+An invocation of ``parallel_for_each`` never causes two threads to act
+on an input iterator concurrently. Thus typical definitions of input
+iterators for sequential programs work correctly. This convenience makes
+``parallel_for_each`` unscalable, because the fetching of work is
+serial. But in many situations, you still get useful speedup over doing
+things sequentially.
+
+
+There are two ways that ``parallel_for_each`` can acquire work scalably.
+
+
+-  The iterators can be random-access iterators.
+
+
+-  The body argument to ``parallel_for_each``, if it takes a second
+   argument *feeder* of type ``parallel_for_each<Item>&``, can add more
+   work by calling ``feeder.add(item)``. For example, suppose processing
+   a node in a tree is a prerequisite to processing its descendants.
+   With ``parallel_for_each``, after processing a node, you could use
+   ``feeder.add`` to add the descendant nodes. The instance of
+   ``parallel_for_each`` does not terminate until all items have been
+   processed.

doc/main/tbb_userguide/Data_Flow_Graph.rst

@@ -0,0 +1,199 @@
+.. _Data_Flow_Graph:
+
+Data Flow Graph
+===============
+
+
+In a data flow graph, nodes are computations that send and receive data
+messages. Some nodes may only send messages, others may only receive
+messages, and others may send messages in response to messages that they
+receive.
+
+
+In the following data flow graph, the left-most node generates the
+integer values from 1 to 10 and passes them to two successor nodes. One
+of the successors squares each value it receives and passes the result
+downstream. The second successor cubes each value it receives and passes
+the result downstream. The right-most node receives values from both of
+the middle nodes. As it receives each value, it adds it to a running sum
+of values. When the application is run to completion, the value of sum
+will be equal to the sum of the sequence of squares and cubes from 1 to
+10.
+
+
+.. container:: fignone
+   :name: simple_data_flow_title
+
+
+   Simple Data Flow Graph
+
+
+   .. container:: imagecenter
+
+
+      |image0|
+
+
+The following code snippet shows an implementation of the **Simple Data
+Flow Graph** shown above:
+
+
+::
+
+
+       int sum = 0;
+       graph g;
+       function_node< int, int > squarer( g, unlimited, [](const int &v) { 
+           return v*v; 
+       } );
+       function_node< int, int > cuber( g, unlimited, [](const int &v) { 
+           return v*v*v; 
+       } );
+       function_node< int, int > summer( g, 1, [&](const int &v ) -> int { 
+           return sum += v; 
+       } );
+       make_edge( squarer, summer );
+       make_edge( cuber, summer );
+
+
+       for ( int i = 1; i <= 10; ++i ) {
+         squarer.try_put(i);
+         cuber.try_put(i);
+       }
+       g.wait_for_all();
+
+
+       cout << "Sum is " << sum << "\n";
+
+
+In the implementation above, the following function_nodes are created:
+
+
+-  one to square values
+-  one to cube values
+-  one to add values to the global sum
+
+
+Since the squarer and cuber nodes are side-effect free, they are created
+with an unlimited concurrency. The summer node updates the sum through a
+reference to a global variable and therefore is not safe to execute in
+parallel. It is therefore created with a concurrency limit of 1. The
+node F from **Simple Data Flow Graph** above is implemented as a loop
+that puts messages to both the squarer and cuber node.
+
+
+A slight improvement over the first implementation is to introduce an
+additional node type, a ``broadcast_node``. A ``broadcast_node`` broadcasts any
+message it receives to all of its successors.
+
+
+This enables replacing the two ``try_put``'s in the loop with a single
+``try_put``:
+
+
+::
+
+
+       broadcast_node<int> b(g);
+       make_edge( b, squarer );
+       make_edge( b, cuber );
+       for ( int i = 1; i <= 10; ++i ) {
+         b.try_put(i);
+       }
+       g.wait_for_all();
+
+
+An even better option, which will make the implementation even more like
+the **Simple Data Flow Graph** above, is to introduce an ``input_node``. An
+``input_node``, as the name implies only sends messages and does not
+receive messages. Its constructor takes two arguments:
+
+
+::
+
+
+   template< typename Body > input_node( graph &g, Body body)
+
+The body is a function object, or lambda expression, that contains a
+function operator:
+
+
+::
+
+
+   Output Body::operator()( oneapi::tbb::flow_control &fc );
+
+
+You can replace the loop in the example with an ``input_node``
+
+
+::
+
+
+       input_node< int > src( g, src_body(10) );
+       make_edge( src, squarer );
+       make_edge( src, cuber );
+       src.activate();
+       g.wait_for_all();
+
+
+The runtime library will repeatedly invoke the function operator in
+``src_body`` until ``fc.stop()`` is invoked inside the body. You therefore
+need to create body that will act like the body of the loop in the **Simple Data Flow Graph**
+above. The final implementation after all of these changes is shown
+below:
+
+
+::
+
+
+       class src_body {
+           const int my_limit;
+           int my_next_value;
+       public:
+           src_body(int l) : my_limit(l), my_next_value(1) {}
+           int operator()( oneapi::tbb::flow_control& fc ) {
+               if ( my_next_value <= my_limit ) {
+                   return my_next_value++;
+               } else {
+                   fc.stop();
+                   return int();
+               }
+           }
+       };
+
+
+       int main() {
+         int sum = 0;
+         graph g;
+         function_node< int, int > squarer( g, unlimited, [](const int &v) { 
+             return v*v; 
+         } );
+         function_node< int, int > cuber( g, unlimited, [](const int &v) { 
+             return v*v*v; 
+         } );
+         function_node< int, int > summer( g, 1, [&](const int &v ) -> int { 
+             return sum += v; 
+         } );
+         make_edge( squarer, summer );
+         make_edge( cuber, summer );
+         input_node< int > src( g, src_body(10) );
+         make_edge( src, squarer );
+         make_edge( src, cuber );
+         src.activate();
+         g.wait_for_all();
+         cout << "Sum is " << sum << "\n";
+       }
+
+
+This final implementation has all of the nodes and edges from the
+**Simple Data Flow Graph** above. In this simple example, there is not
+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 `Creating a Token-Based
+System <create_token_based_system.html#create_token_based_system>`__
+
+
+.. |image0| image:: Images/flow_graph.jpg
+