diff --git a/R/build.R b/R/build.R
index 95cbf5e8..b57aef0e 100644
--- a/R/build.R
+++ b/R/build.R
@@ -1,6 +1,6 @@
 
 
-# Output the CXX flags. These flags are propagated to sourceCpp via the 
+# Output the CXX flags. These flags are propagated to sourceCpp via the
 # inlineCxxPlugin (defined below) and to packages via a line in Makevars[.win]
 # like this:
 #
@@ -12,7 +12,7 @@ CxxFlags <- function() {
 
 
 # Output the LD flags for building against TBB. These flags are propagated
-# to sourceCpp via the inlineCxxPlugin (defined below) and to packages 
+# to sourceCpp via the inlineCxxPlugin (defined below) and to packages
 # via a line in Makevars[.win] like this:
 #
 #   PKG_LIBS += $(shell "${R_HOME}/bin${R_ARCH_BIN}/Rscript.exe" -e "RcppParallel::LdFlags()")
@@ -41,13 +41,13 @@ inlineCxxPlugin <- function() {
 }
 
 tbbCxxFlags <- function() {
-   
+
    flags <- c()
-   
+
    # opt-in to TBB on Windows
    if (Sys.info()['sysname'] == "Windows")
       flags <- paste(flags, "-DRCPP_PARALLEL_USE_TBB=1")
-   
+
    flags
 }
 
@@ -66,8 +66,8 @@ tbbLdFlags <- function() {
 tbbLibPath <- function(suffix = "") {
    sysname <- Sys.info()['sysname']
    tbbSupported <- list(
-      "Darwin" = paste("libtbb", suffix, ".dylib", sep = ""), 
-      "Linux" = paste("libtbb", suffix, ".so.2", sep = ""), 
+      "Darwin" = paste("libtbb", suffix, ".dylib", sep = ""),
+      "Linux" = paste("libtbb", suffix, ".so.2", sep = ""),
       "Windows" = paste("tbb", suffix, ".dll", sep = ""),
       "SunOS" = paste("libtbb", suffix, ".so", sep = "")
    )
@@ -75,7 +75,7 @@ tbbLibPath <- function(suffix = "") {
       libDir <- "lib/"
       if (sysname == "Windows")
          libDir <- paste(libDir, .Platform$r_arch, "/", sep="")
-      system.file(paste(libDir, tbbSupported[[sysname]], sep = ""), 
+      system.file(paste(libDir, tbbSupported[[sysname]], sep = ""),
                   package = "RcppParallel")
    } else {
       NULL
diff --git a/inst/include/index.html b/inst/include/index.html
index b0962e01..c8698efb 100644
--- a/inst/include/index.html
+++ b/inst/include/index.html
@@ -15,7 +15,7 @@ <H2>Directories</H2>
 <HR>
 <A HREF="../index.html">Up to parent directory</A>
 <p></p>
-Copyright &copy; 2005-2017 Intel Corporation.  All Rights Reserved.
+Copyright &copy; 2005-2020 Intel Corporation.  All Rights Reserved.
 <P></P>
 Intel is a registered trademark or trademark of Intel Corporation
 or its subsidiaries in the United States and other countries.
diff --git a/inst/include/serial/tbb/parallel_for.h b/inst/include/serial/tbb/parallel_for.h
index e5959c22..4e6111b7 100644
--- a/inst/include/serial/tbb/parallel_for.h
+++ b/inst/include/serial/tbb/parallel_for.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2018 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,11 +12,18 @@
     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 "../../tbb/internal/_deprecated_header_message_guard.h"
 
+#if !defined(__TBB_show_deprecation_message_parallel_for_H) && defined(__TBB_show_deprecated_header_message)
+#define  __TBB_show_deprecation_message_parallel_for_H
+#pragma message("TBB Warning: serial/tbb/parallel_for.h is deprecated. For details, please see Deprecated Features appendix in the TBB reference manual.")
+#endif
 
-
-*/
+#if defined(__TBB_show_deprecated_header_message)
+#undef __TBB_show_deprecated_header_message
+#endif
 
 #ifndef __TBB_SERIAL_parallel_for_H
 #define __TBB_SERIAL_parallel_for_H
@@ -98,35 +105,35 @@ void start_for< Range, Body, Partitioner >::execute() {
 //! Parallel iteration over range with default partitioner.
 /** @ingroup algorithms **/
 template<typename Range, typename Body>
-void parallel_for( const Range& range, const Body& body ) {
+__TBB_DEPRECATED_IN_VERBOSE_MODE void parallel_for( const Range& range, const Body& body ) {
     serial::interface9::start_for<Range,Body,const __TBB_DEFAULT_PARTITIONER>::run(range,body,__TBB_DEFAULT_PARTITIONER());
 }
 
 //! Parallel iteration over range with simple partitioner.
 /** @ingroup algorithms **/
 template<typename Range, typename Body>
-void parallel_for( const Range& range, const Body& body, const simple_partitioner& partitioner ) {
+__TBB_DEPRECATED_IN_VERBOSE_MODE void parallel_for( const Range& range, const Body& body, const simple_partitioner& partitioner ) {
     serial::interface9::start_for<Range,Body,const simple_partitioner>::run(range,body,partitioner);
 }
 
 //! Parallel iteration over range with auto_partitioner.
 /** @ingroup algorithms **/
 template<typename Range, typename Body>
-void parallel_for( const Range& range, const Body& body, const auto_partitioner& partitioner ) {
+__TBB_DEPRECATED_IN_VERBOSE_MODE void parallel_for( const Range& range, const Body& body, const auto_partitioner& partitioner ) {
     serial::interface9::start_for<Range,Body,const auto_partitioner>::run(range,body,partitioner);
 }
 
 //! Parallel iteration over range with static_partitioner.
 /** @ingroup algorithms **/
 template<typename Range, typename Body>
-void parallel_for( const Range& range, const Body& body, const static_partitioner& partitioner ) {
+__TBB_DEPRECATED_IN_VERBOSE_MODE void parallel_for( const Range& range, const Body& body, const static_partitioner& partitioner ) {
     serial::interface9::start_for<Range,Body,const static_partitioner>::run(range,body,partitioner);
 }
 
 //! Parallel iteration over range with affinity_partitioner.
 /** @ingroup algorithms **/
 template<typename Range, typename Body>
-void parallel_for( const Range& range, const Body& body, affinity_partitioner& partitioner ) {
+__TBB_DEPRECATED_IN_VERBOSE_MODE void parallel_for( const Range& range, const Body& body, affinity_partitioner& partitioner ) {
     serial::interface9::start_for<Range,Body,affinity_partitioner>::run(range,body,partitioner);
 }
 
@@ -154,53 +161,53 @@ void parallel_for_impl(Index first, Index last, Index step, const Function& f, P
 
 //! Parallel iteration over a range of integers with explicit step and default partitioner
 template <typename Index, typename Function>
-void parallel_for(Index first, Index last, Index step, const Function& f) {
+__TBB_DEPRECATED_IN_VERBOSE_MODE void parallel_for(Index first, Index last, Index step, const Function& f) {
     parallel_for_impl<Index,Function,const auto_partitioner>(first, last, step, f, auto_partitioner());
 }
 //! Parallel iteration over a range of integers with explicit step and simple partitioner
 template <typename Index, typename Function>
-void parallel_for(Index first, Index last, Index step, const Function& f, const simple_partitioner& p) {
+__TBB_DEPRECATED_IN_VERBOSE_MODE void parallel_for(Index first, Index last, Index step, const Function& f, const simple_partitioner& p) {
     parallel_for_impl<Index,Function,const simple_partitioner>(first, last, step, f, p);
 }
 //! Parallel iteration over a range of integers with explicit step and auto partitioner
 template <typename Index, typename Function>
-void parallel_for(Index first, Index last, Index step, const Function& f, const auto_partitioner& p) {
+__TBB_DEPRECATED_IN_VERBOSE_MODE void parallel_for(Index first, Index last, Index step, const Function& f, const auto_partitioner& p) {
     parallel_for_impl<Index,Function,const auto_partitioner>(first, last, step, f, p);
 }
 //! Parallel iteration over a range of integers with explicit step and static partitioner
 template <typename Index, typename Function>
-void parallel_for(Index first, Index last, Index step, const Function& f, const static_partitioner& p) {
+__TBB_DEPRECATED_IN_VERBOSE_MODE void parallel_for(Index first, Index last, Index step, const Function& f, const static_partitioner& p) {
     parallel_for_impl<Index,Function,const static_partitioner>(first, last, step, f, p);
 }
 //! Parallel iteration over a range of integers with explicit step and affinity partitioner
 template <typename Index, typename Function>
-void parallel_for(Index first, Index last, Index step, const Function& f, affinity_partitioner& p) {
+__TBB_DEPRECATED_IN_VERBOSE_MODE void parallel_for(Index first, Index last, Index step, const Function& f, affinity_partitioner& p) {
     parallel_for_impl(first, last, step, f, p);
 }
 
 //! Parallel iteration over a range of integers with default step and default partitioner
 template <typename Index, typename Function>
-void parallel_for(Index first, Index last, const Function& f) {
+__TBB_DEPRECATED_IN_VERBOSE_MODE void parallel_for(Index first, Index last, const Function& f) {
     parallel_for_impl<Index,Function,const auto_partitioner>(first, last, static_cast<Index>(1), f, auto_partitioner());
 }
 //! Parallel iteration over a range of integers with default step and simple partitioner
 template <typename Index, typename Function>
-void parallel_for(Index first, Index last, const Function& f, const simple_partitioner& p) {
+__TBB_DEPRECATED_IN_VERBOSE_MODE void parallel_for(Index first, Index last, const Function& f, const simple_partitioner& p) {
     parallel_for_impl<Index,Function,const simple_partitioner>(first, last, static_cast<Index>(1), f, p);
 }
 //! Parallel iteration over a range of integers with default step and auto partitioner
 template <typename Index, typename Function>
-    void parallel_for(Index first, Index last, const Function& f, const auto_partitioner& p) {
+__TBB_DEPRECATED_IN_VERBOSE_MODE void parallel_for(Index first, Index last, const Function& f, const auto_partitioner& p) {
     parallel_for_impl<Index,Function,const auto_partitioner>(first, last, static_cast<Index>(1), f, p);
 }
 //! Parallel iteration over a range of integers with default step and static partitioner
 template <typename Index, typename Function>
-void parallel_for(Index first, Index last, const Function& f, const static_partitioner& p) {
+__TBB_DEPRECATED_IN_VERBOSE_MODE void parallel_for(Index first, Index last, const Function& f, const static_partitioner& p) {
     parallel_for_impl<Index,Function,const static_partitioner>(first, last, static_cast<Index>(1), f, p);
 }
 //! Parallel iteration over a range of integers with default step and affinity_partitioner
 template <typename Index, typename Function>
-void parallel_for(Index first, Index last, const Function& f, affinity_partitioner& p) {
+__TBB_DEPRECATED_IN_VERBOSE_MODE void parallel_for(Index first, Index last, const Function& f, affinity_partitioner& p) {
     parallel_for_impl(first, last, static_cast<Index>(1), f, p);
 }
 
diff --git a/inst/include/serial/tbb/tbb_annotate.h b/inst/include/serial/tbb/tbb_annotate.h
index c16defea..3e67e4c4 100644
--- a/inst/include/serial/tbb/tbb_annotate.h
+++ b/inst/include/serial/tbb/tbb_annotate.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2018 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_annotate_H
diff --git a/inst/include/tbb/aggregator.h b/inst/include/tbb/aggregator.h
index 6aecbb74..786c52c8 100644
--- a/inst/include/tbb/aggregator.h
+++ b/inst/include/tbb/aggregator.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,15 +12,14 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB__aggregator_H
 #define __TBB__aggregator_H
 
+#define __TBB_aggregator_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #if !TBB_PREVIEW_AGGREGATOR
 #error Set TBB_PREVIEW_AGGREGATOR before including aggregator.h
 #endif
@@ -199,4 +198,7 @@ using interface6::aggregator_operation;
 
 } // namespace tbb
 
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_aggregator_H_include_area
+
 #endif  // __TBB__aggregator_H
diff --git a/inst/include/tbb/aligned_space.h b/inst/include/tbb/aligned_space.h
index 56fd85f3..1b047f97 100644
--- a/inst/include/tbb/aligned_space.h
+++ b/inst/include/tbb/aligned_space.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,15 +12,25 @@
     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 "internal/_deprecated_header_message_guard.h"
 
+#if !defined(__TBB_show_deprecation_message_aligned_space_H) && defined(__TBB_show_deprecated_header_message)
+#define  __TBB_show_deprecation_message_aligned_space_H
+#pragma message("TBB Warning: tbb/aligned_space.h is deprecated. For details, please see Deprecated Features appendix in the TBB reference manual.")
+#endif
 
-
-*/
+#if defined(__TBB_show_deprecated_header_message)
+#undef __TBB_show_deprecated_header_message
+#endif
 
 #ifndef __TBB_aligned_space_H
 #define __TBB_aligned_space_H
 
+#define __TBB_aligned_space_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #include "tbb_stddef.h"
 #include "tbb_machine.h"
 
@@ -30,18 +40,21 @@ namespace tbb {
 /** The elements are not constructed or destroyed by this class.
     @ingroup memory_allocation */
 template<typename T,size_t N=1>
-class aligned_space {
+class __TBB_DEPRECATED_IN_VERBOSE_MODE_MSG("tbb::aligned_space is deprecated, use std::aligned_storage") aligned_space {
 private:
     typedef __TBB_TypeWithAlignmentAtLeastAsStrict(T) element_type;
     element_type array[(sizeof(T)*N+sizeof(element_type)-1)/sizeof(element_type)];
 public:
     //! Pointer to beginning of array
-    T* begin() {return internal::punned_cast<T*>(this);}
+    T* begin() const {return internal::punned_cast<T*>(this);}
 
     //! Pointer to one past last element in array.
-    T* end() {return begin()+N;}
+    T* end() const {return begin()+N;}
 };
 
 } // namespace tbb
 
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_aligned_space_H_include_area
+
 #endif /* __TBB_aligned_space_H */
diff --git a/inst/include/tbb/atomic.h b/inst/include/tbb/atomic.h
index 72ec534e..e602306f 100644
--- a/inst/include/tbb/atomic.h
+++ b/inst/include/tbb/atomic.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,15 +12,25 @@
     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 "internal/_deprecated_header_message_guard.h"
 
+#if !defined(__TBB_show_deprecation_message_atomic_H) && defined(__TBB_show_deprecated_header_message)
+#define  __TBB_show_deprecation_message_atomic_H
+#pragma message("TBB Warning: tbb/atomic.h is deprecated. For details, please see Deprecated Features appendix in the TBB reference manual.")
+#endif
 
-
-*/
+#if defined(__TBB_show_deprecated_header_message)
+#undef __TBB_show_deprecated_header_message
+#endif
 
 #ifndef __TBB_atomic_H
 #define __TBB_atomic_H
 
+#define __TBB_atomic_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #include <cstddef>
 
 #if _MSC_VER
@@ -404,10 +414,12 @@ struct atomic_impl_with_arithmetic: atomic_impl<I> {
 /** See the Reference for details.
     @ingroup synchronization */
 template<typename T>
-struct atomic: internal::atomic_impl<T> {
+struct __TBB_DEPRECATED_IN_VERBOSE_MODE_MSG("tbb::atomic is deprecated, use std::atomic")
+atomic: internal::atomic_impl<T> {
 #if __TBB_ATOMIC_CTORS
     atomic() = default;
     constexpr atomic(T arg): internal::atomic_impl<T>(arg) {}
+    constexpr atomic<T>(const atomic<T>& rhs): internal::atomic_impl<T>(rhs) {}
 #endif
     T operator=( T rhs ) {
         // "this" required here in strict ISO C++ because store_with_release is a dependent name
@@ -418,16 +430,20 @@ struct atomic: internal::atomic_impl<T> {
 
 #if __TBB_ATOMIC_CTORS
     #define __TBB_DECL_ATOMIC(T)                                                                    \
-        template<> struct atomic<T>: internal::atomic_impl_with_arithmetic<T,T,char> {              \
+        template<> struct __TBB_DEPRECATED_IN_VERBOSE_MODE_MSG("tbb::atomic is deprecated, use std::atomic")  \
+        atomic<T>: internal::atomic_impl_with_arithmetic<T,T,char> {                                \
             atomic() = default;                                                                     \
             constexpr atomic(T arg): internal::atomic_impl_with_arithmetic<T,T,char>(arg) {}        \
+            constexpr atomic<T>(const atomic<T>& rhs):                                              \
+                      internal::atomic_impl_with_arithmetic<T,T,char>(rhs) {}                       \
                                                                                                     \
             T operator=( T rhs ) {return store_with_release(rhs);}                                  \
             atomic<T>& operator=( const atomic<T>& rhs ) {store_with_release(rhs); return *this;}   \
         };
 #else
     #define __TBB_DECL_ATOMIC(T)                                                                    \
-        template<> struct atomic<T>: internal::atomic_impl_with_arithmetic<T,T,char> {              \
+        template<> struct __TBB_DEPRECATED_IN_VERBOSE_MODE_MSG("tbb::atomic is deprecated, use std::atomic")  \
+        atomic<T>: internal::atomic_impl_with_arithmetic<T,T,char> {                                \
             T operator=( T rhs ) {return store_with_release(rhs);}                                  \
             atomic<T>& operator=( const atomic<T>& rhs ) {store_with_release(rhs); return *this;}   \
         };
@@ -451,15 +467,20 @@ __TBB_DECL_ATOMIC(unsigned long)
    type synonyms on the platform.  Type U should be the wider variant of T from the
    perspective of /Wp64. */
 #define __TBB_DECL_ATOMIC_ALT(T,U) \
-    template<> struct atomic<T>: internal::atomic_impl_with_arithmetic<T,T,char> {             \
+    template<> struct __TBB_DEPRECATED_IN_VERBOSE_MODE_MSG("tbb::atomic is deprecated, use std::atomic") \
+    atomic<T>: internal::atomic_impl_with_arithmetic<T,T,char> {                               \
         atomic() = default ;                                                                   \
         constexpr atomic(T arg): internal::atomic_impl_with_arithmetic<T,T,char>(arg) {}       \
+        constexpr atomic<T>(const atomic<T>& rhs):                                             \
+                  internal::atomic_impl_with_arithmetic<T,T,char>(rhs) {}                      \
+                                                                                               \
         T operator=( U rhs ) {return store_with_release(T(rhs));}                              \
         atomic<T>& operator=( const atomic<T>& rhs ) {store_with_release(rhs); return *this;}  \
     };
 #else
 #define __TBB_DECL_ATOMIC_ALT(T,U) \
-    template<> struct atomic<T>: internal::atomic_impl_with_arithmetic<T,T,char> {             \
+    template<> struct __TBB_DEPRECATED_IN_VERBOSE_MODE_MSG("tbb::atomic is deprecated, use std::atomic") \
+    atomic<T>: internal::atomic_impl_with_arithmetic<T,T,char> {                               \
         T operator=( U rhs ) {return store_with_release(T(rhs));}                              \
         atomic<T>& operator=( const atomic<T>& rhs ) {store_with_release(rhs); return *this;}  \
     };
@@ -482,10 +503,12 @@ __TBB_DECL_ATOMIC(wchar_t)
 #endif /* _MSC_VER||!defined(_NATIVE_WCHAR_T_DEFINED) */
 
 //! Specialization for atomic<T*> with arithmetic and operator->.
-template<typename T> struct atomic<T*>: internal::atomic_impl_with_arithmetic<T*,ptrdiff_t,T> {
+template<typename T> struct __TBB_DEPRECATED_IN_VERBOSE_MODE_MSG("tbb::atomic is deprecated, use std::atomic")
+atomic<T*>: internal::atomic_impl_with_arithmetic<T*,ptrdiff_t,T> {
 #if __TBB_ATOMIC_CTORS
     atomic() = default ;
     constexpr atomic(T* arg): internal::atomic_impl_with_arithmetic<T*,ptrdiff_t,T>(arg) {}
+    constexpr atomic(const atomic<T*>& rhs): internal::atomic_impl_with_arithmetic<T*,ptrdiff_t,T>(rhs) {}
 #endif
     T* operator=( T* rhs ) {
         // "this" required here in strict ISO C++ because store_with_release is a dependent name
@@ -500,10 +523,12 @@ template<typename T> struct atomic<T*>: internal::atomic_impl_with_arithmetic<T*
 };
 
 //! Specialization for atomic<void*>, for sake of not allowing arithmetic or operator->.
-template<> struct atomic<void*>: internal::atomic_impl<void*> {
+template<> struct __TBB_DEPRECATED_IN_VERBOSE_MODE_MSG("tbb::atomic is deprecated, use std::atomic")
+atomic<void*>: internal::atomic_impl<void*> {
 #if __TBB_ATOMIC_CTORS
     atomic() = default ;
     constexpr atomic(void* arg): internal::atomic_impl<void*>(arg) {}
+    constexpr atomic(const atomic<void*>& rhs): internal::atomic_impl<void*>(rhs) {}
 #endif
     void* operator=( void* rhs ) {
         // "this" required here in strict ISO C++ because store_with_release is a dependent name
@@ -555,4 +580,7 @@ inline atomic<T>& as_atomic( T& t ) {
     #pragma warning (pop)
 #endif // warnings are restored
 
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_atomic_H_include_area
+
 #endif /* __TBB_atomic_H */
diff --git a/inst/include/tbb/blocked_range.h b/inst/include/tbb/blocked_range.h
index 9f24cd2b..b77e7e0a 100644
--- a/inst/include/tbb/blocked_range.h
+++ b/inst/include/tbb/blocked_range.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_blocked_range_H
@@ -25,6 +21,15 @@
 
 namespace tbb {
 
+namespace internal {
+
+// blocked_rangeNd_impl forward declaration in tbb::internal namespace to
+// name it as a friend for a tbb::blocked_range.
+template<typename Value, unsigned int N, typename>
+class blocked_rangeNd_impl;
+
+} // namespace internal
+
 /** \page range_req Requirements on range concept
     Class \c R implementing the concept of range must define:
     - \code R::R( const R& ); \endcode               Copy constructor
@@ -47,9 +52,11 @@ class blocked_range {
     //! Type for size of a range
     typedef std::size_t size_type;
 
-    //! Construct range with default-constructed values for begin and end.
+#if __TBB_DEPRECATED_BLOCKED_RANGE_DEFAULT_CTOR
+    //! Construct range with default-constructed values for begin, end, and grainsize.
     /** Requires that Value have a default constructor. */
-    blocked_range() : my_end(), my_begin() {}
+    blocked_range() : my_end(), my_begin(), my_grainsize() {}
+#endif
 
     //! Construct range over half-open interval [begin,end), with the given grainsize.
     blocked_range( Value begin_, Value end_, size_type grainsize_=1 ) :
@@ -115,13 +122,12 @@ class blocked_range {
 #endif /* __TBB_USE_PROPORTIONAL_SPLIT_IN_BLOCKED_RANGES */
 
 private:
-    /** NOTE: my_end MUST be declared before my_begin, otherwise the forking constructor will break. */
+    /** NOTE: my_end MUST be declared before my_begin, otherwise the splitting constructor will break. */
     Value my_end;
     Value my_begin;
     size_type my_grainsize;
 
-    //! Auxiliary function used by forking constructor.
-    /** Using this function lets us not require that Value support assignment or default construction. */
+    //! Auxiliary function used by the splitting constructor.
     static Value do_split( blocked_range& r, split )
     {
         __TBB_ASSERT( r.is_divisible(), "cannot split blocked_range that is not divisible" );
@@ -152,6 +158,9 @@ class blocked_range {
 
     template<typename RowValue, typename ColValue, typename PageValue>
     friend class blocked_range3d;
+
+    template<typename DimValue, unsigned int N, typename>
+    friend class internal::blocked_rangeNd_impl;
 };
 
 } // namespace tbb
diff --git a/inst/include/tbb/blocked_range2d.h b/inst/include/tbb/blocked_range2d.h
index f1b9f35d..2498e046 100644
--- a/inst/include/tbb/blocked_range2d.h
+++ b/inst/include/tbb/blocked_range2d.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_blocked_range2d_H
@@ -45,19 +41,17 @@ class blocked_range2d {
                      ColValue col_begin, ColValue col_end, typename col_range_type::size_type col_grainsize ) :
         my_rows(row_begin,row_end,row_grainsize),
         my_cols(col_begin,col_end,col_grainsize)
-    {
-    }
+    {}
 
     blocked_range2d( RowValue row_begin, RowValue row_end,
                      ColValue col_begin, ColValue col_end ) :
         my_rows(row_begin,row_end),
         my_cols(col_begin,col_end)
-    {
-    }
+    {}
 
     //! True if range is empty
     bool empty() const {
-        // Yes, it is a logical OR here, not AND.
+        // Range is empty if at least one dimension is empty.
         return my_rows.empty() || my_cols.empty();
     }
 
@@ -86,6 +80,14 @@ class blocked_range2d {
     }
 #endif /* __TBB_USE_PROPORTIONAL_SPLIT_IN_BLOCKED_RANGES */
 
+    //! The rows of the iteration space
+    const row_range_type& rows() const {return my_rows;}
+
+    //! The columns of the iteration space
+    const col_range_type& cols() const {return my_cols;}
+
+private:
+
     template <typename Split>
     void do_split( blocked_range2d& r, Split& split_obj )
     {
@@ -95,12 +97,6 @@ class blocked_range2d {
             my_rows.my_begin = row_range_type::do_split(r.my_rows, split_obj);
         }
     }
-
-    //! The rows of the iteration space
-    const row_range_type& rows() const {return my_rows;}
-
-    //! The columns of the iteration space
-    const col_range_type& cols() const {return my_cols;}
 };
 
 } // namespace tbb
diff --git a/inst/include/tbb/blocked_range3d.h b/inst/include/tbb/blocked_range3d.h
index c62565ee..15f93130 100644
--- a/inst/include/tbb/blocked_range3d.h
+++ b/inst/include/tbb/blocked_range3d.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_blocked_range3d_H
@@ -49,8 +45,7 @@ class blocked_range3d {
         my_pages(page_begin,page_end),
         my_rows(row_begin,row_end),
         my_cols(col_begin,col_end)
-    {
-    }
+    {}
 
     blocked_range3d( PageValue page_begin, PageValue page_end, typename page_range_type::size_type page_grainsize,
                      RowValue  row_begin,  RowValue row_end,   typename row_range_type::size_type row_grainsize,
@@ -58,12 +53,11 @@ class blocked_range3d {
         my_pages(page_begin,page_end,page_grainsize),
         my_rows(row_begin,row_end,row_grainsize),
         my_cols(col_begin,col_end,col_grainsize)
-    {
-    }
+    {}
 
     //! True if range is empty
     bool empty() const {
-        // Yes, it is a logical OR here, not AND.
+        // Range is empty if at least one dimension is empty.
         return my_pages.empty() || my_rows.empty() || my_cols.empty();
     }
 
@@ -94,6 +88,17 @@ class blocked_range3d {
     }
 #endif /* __TBB_USE_PROPORTIONAL_SPLIT_IN_BLOCKED_RANGES */
 
+    //! The pages of the iteration space
+    const page_range_type& pages() const {return my_pages;}
+
+    //! The rows of the iteration space
+    const row_range_type& rows() const {return my_rows;}
+
+    //! The columns of the iteration space
+    const col_range_type& cols() const {return my_cols;}
+
+private:
+
     template <typename Split>
     void do_split( blocked_range3d& r, Split& split_obj)
     {
@@ -103,7 +108,7 @@ class blocked_range3d {
             } else {
                 my_rows.my_begin = row_range_type::do_split(r.my_rows, split_obj);
             }
-	} else {
+        } else {
             if ( my_pages.size()*double(my_cols.grainsize()) < my_cols.size()*double(my_pages.grainsize()) ) {
                 my_cols.my_begin = col_range_type::do_split(r.my_cols, split_obj);
             } else {
@@ -111,16 +116,6 @@ class blocked_range3d {
             }
         }
     }
-
-    //! The pages of the iteration space
-    const page_range_type& pages() const {return my_pages;}
-
-    //! The rows of the iteration space
-    const row_range_type& rows() const {return my_rows;}
-
-    //! The columns of the iteration space
-    const col_range_type& cols() const {return my_cols;}
-
 };
 
 } // namespace tbb
diff --git a/inst/include/tbb/blocked_rangeNd.h b/inst/include/tbb/blocked_rangeNd.h
new file mode 100644
index 00000000..922c77c6
--- /dev/null
+++ b/inst/include/tbb/blocked_rangeNd.h
@@ -0,0 +1,150 @@
+/*
+    Copyright (c) 2017-2020 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.
+*/
+
+#ifndef __TBB_blocked_rangeNd_H
+#define __TBB_blocked_rangeNd_H
+
+#if ! TBB_PREVIEW_BLOCKED_RANGE_ND
+    #error Set TBB_PREVIEW_BLOCKED_RANGE_ND to include blocked_rangeNd.h
+#endif
+
+#include "tbb_config.h"
+
+// tbb::blocked_rangeNd requires C++11 support
+#if __TBB_CPP11_PRESENT && __TBB_CPP11_ARRAY_PRESENT && __TBB_CPP11_TEMPLATE_ALIASES_PRESENT
+
+#include "internal/_template_helpers.h" // index_sequence, make_index_sequence
+
+#include <array>
+#include <algorithm>    // std::any_of
+#include <type_traits>  // std::is_same, std::enable_if
+
+#include "tbb/blocked_range.h"
+
+namespace tbb {
+namespace internal {
+
+/*
+    The blocked_rangeNd_impl uses make_index_sequence<N> to automatically generate a ctor with
+    exactly N arguments of the type tbb::blocked_range<Value>. Such ctor provides an opportunity
+    to use braced-init-list parameters to initialize each dimension.
+    Use of parameters, whose representation is a braced-init-list, but they're not
+    std::initializer_list or a reference to one, produces a non-deduced context
+    within template argument deduction.
+
+    NOTE: blocked_rangeNd must be exactly a templated alias to the blocked_rangeNd_impl
+    (and not e.g. a derived class), otherwise it would need to declare its own ctor
+    facing the same problem that the impl class solves.
+*/
+
+template<typename Value, unsigned int N, typename = make_index_sequence<N>>
+class blocked_rangeNd_impl;
+
+template<typename Value, unsigned int N, std::size_t... Is>
+class blocked_rangeNd_impl<Value, N, index_sequence<Is...>> {
+public:
+    //! Type of a value.
+    using value_type = Value;
+
+private:
+
+    //! Helper type to construct range with N tbb::blocked_range<value_type> objects.
+    template<std::size_t>
+    using dim_type_helper = tbb::blocked_range<value_type>;
+
+public:
+    blocked_rangeNd_impl() = delete;
+
+    //! Constructs N-dimensional range over N half-open intervals each represented as tbb::blocked_range<Value>.
+    blocked_rangeNd_impl(const dim_type_helper<Is>&... args) : my_dims{ {args...} } {}
+
+    //! Dimensionality of a range.
+    static constexpr unsigned int ndims() { return N; }
+
+    //! Range in certain dimension.
+    const tbb::blocked_range<value_type>& dim(unsigned int dimension) const {
+        __TBB_ASSERT(dimension < N, "out of bound");
+        return my_dims[dimension];
+    }
+
+    //------------------------------------------------------------------------
+    // Methods that implement Range concept
+    //------------------------------------------------------------------------
+
+    //! True if at least one dimension is empty.
+    bool empty() const {
+        return std::any_of(my_dims.begin(), my_dims.end(), [](const tbb::blocked_range<value_type>& d) {
+            return d.empty();
+        });
+    }
+
+    //! True if at least one dimension is divisible.
+    bool is_divisible() const {
+        return std::any_of(my_dims.begin(), my_dims.end(), [](const tbb::blocked_range<value_type>& d) {
+            return d.is_divisible();
+        });
+    }
+
+#if __TBB_USE_PROPORTIONAL_SPLIT_IN_BLOCKED_RANGES
+    //! Static field to support proportional split.
+    static const bool is_splittable_in_proportion = true;
+
+    blocked_rangeNd_impl(blocked_rangeNd_impl& r, proportional_split proportion) : my_dims(r.my_dims) {
+        do_split(r, proportion);
+    }
+#endif
+
+    blocked_rangeNd_impl(blocked_rangeNd_impl& r, split proportion) : my_dims(r.my_dims) {
+        do_split(r, proportion);
+    }
+
+private:
+    __TBB_STATIC_ASSERT(N != 0, "zero dimensional blocked_rangeNd can't be constructed");
+
+    //! Ranges in each dimension.
+    std::array<tbb::blocked_range<value_type>, N> my_dims;
+
+    template<typename split_type>
+    void do_split(blocked_rangeNd_impl& r, split_type proportion) {
+        __TBB_STATIC_ASSERT((is_same_type<split_type, split>::value
+                            || is_same_type<split_type, proportional_split>::value),
+                            "type of split object is incorrect");
+        __TBB_ASSERT(r.is_divisible(), "can't split not divisible range");
+
+        auto my_it = std::max_element(my_dims.begin(), my_dims.end(), [](const tbb::blocked_range<value_type>& first, const tbb::blocked_range<value_type>& second) {
+            return (first.size() * second.grainsize() < second.size() * first.grainsize());
+        });
+
+        auto r_it = r.my_dims.begin() + (my_it - my_dims.begin());
+
+        my_it->my_begin = tbb::blocked_range<value_type>::do_split(*r_it, proportion);
+
+        // (!(my_it->my_begin < r_it->my_end) && !(r_it->my_end < my_it->my_begin)) equals to
+        // (my_it->my_begin == r_it->my_end), but we can't use operator== due to Value concept
+        __TBB_ASSERT(!(my_it->my_begin < r_it->my_end) && !(r_it->my_end < my_it->my_begin),
+                     "blocked_range has been split incorrectly");
+    }
+};
+
+} // namespace internal
+
+template<typename Value, unsigned int N>
+using blocked_rangeNd = internal::blocked_rangeNd_impl<Value, N>;
+
+} // namespace tbb
+
+#endif /* __TBB_CPP11_PRESENT && __TBB_CPP11_ARRAY_PRESENT && __TBB_CPP11_TEMPLATE_ALIASES_PRESENT */
+#endif /* __TBB_blocked_rangeNd_H */
diff --git a/inst/include/tbb/cache_aligned_allocator.h b/inst/include/tbb/cache_aligned_allocator.h
index d435e785..5b4897c4 100644
--- a/inst/include/tbb/cache_aligned_allocator.h
+++ b/inst/include/tbb/cache_aligned_allocator.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_cache_aligned_allocator_H
@@ -24,7 +20,11 @@
 #include <new>
 #include "tbb_stddef.h"
 #if __TBB_ALLOCATOR_CONSTRUCT_VARIADIC
- #include <utility> // std::forward
+#include <utility> // std::forward
+#endif
+
+#if __TBB_CPP17_MEMORY_RESOURCE_PRESENT
+#include <memory_resource>
 #endif
 
 namespace tbb {
@@ -69,7 +69,6 @@ class cache_aligned_allocator {
     template<typename U> struct rebind {
         typedef cache_aligned_allocator<U> other;
     };
-
     cache_aligned_allocator() throw() {}
     cache_aligned_allocator( const cache_aligned_allocator& ) throw() {}
     template<typename U> cache_aligned_allocator(const cache_aligned_allocator<U>&) throw() {}
@@ -132,6 +131,79 @@ inline bool operator==( const cache_aligned_allocator<T>&, const cache_aligned_a
 template<typename T, typename U>
 inline bool operator!=( const cache_aligned_allocator<T>&, const cache_aligned_allocator<U>& ) {return false;}
 
+#if __TBB_CPP17_MEMORY_RESOURCE_PRESENT
+
+//! C++17 memory resource wrapper to ensure cache line size alignment
+class cache_aligned_resource : public std::pmr::memory_resource {
+public:
+    cache_aligned_resource() : cache_aligned_resource(std::pmr::get_default_resource()) {}
+    explicit cache_aligned_resource(std::pmr::memory_resource* upstream) : m_upstream(upstream) {}
+
+    std::pmr::memory_resource* upstream_resource() const {
+        return m_upstream;
+    }
+
+private:
+    //! We don't know what memory resource set. Use padding to guarantee alignment
+    void* do_allocate(size_t bytes, size_t alignment) override {
+        size_t cache_line_alignment = correct_alignment(alignment);
+        uintptr_t base = (uintptr_t)m_upstream->allocate(correct_size(bytes) + cache_line_alignment);
+        __TBB_ASSERT(base != 0, "Upstream resource returned NULL.");
+#if _MSC_VER && !defined(__INTEL_COMPILER)
+    // unary minus operator applied to unsigned type, result still unsigned
+    #pragma warning(push)
+    #pragma warning(disable: 4146 4706)
+#endif
+        // Round up to the next cache line (align the base address)
+        uintptr_t result = (base + cache_line_alignment) & -cache_line_alignment;
+#if _MSC_VER && !defined(__INTEL_COMPILER)
+    #pragma warning(pop)
+#endif
+        // Record where block actually starts.
+        ((uintptr_t*)result)[-1] = base;
+        return (void*)result;
+    }
+
+    void do_deallocate(void* ptr, size_t bytes, size_t alignment) override {
+        if (ptr) {
+            // Recover where block actually starts
+            uintptr_t base = ((uintptr_t*)ptr)[-1];
+            m_upstream->deallocate((void*)base, correct_size(bytes) + correct_alignment(alignment));
+        }
+    }
+
+    bool do_is_equal(const std::pmr::memory_resource& other) const noexcept override {
+        if (this == &other) { return true; }
+#if __TBB_USE_OPTIONAL_RTTI
+        const cache_aligned_resource* other_res = dynamic_cast<const cache_aligned_resource*>(&other);
+        return other_res && (this->upstream_resource() == other_res->upstream_resource());
+#else
+        return false;
+#endif
+    }
+
+    size_t correct_alignment(size_t alignment) {
+        __TBB_ASSERT(tbb::internal::is_power_of_two(alignment), "Alignment is not a power of 2");
+#if __TBB_CPP17_HW_INTERFERENCE_SIZE_PRESENT
+        size_t cache_line_size = std::hardware_destructive_interference_size;
+#else
+        size_t cache_line_size = internal::NFS_GetLineSize();
+#endif
+        return alignment < cache_line_size ? cache_line_size : alignment;
+    }
+
+    size_t correct_size(size_t bytes) {
+        // To handle the case, when small size requested. There could be not
+        // enough space to store the original pointer.
+        return bytes < sizeof(uintptr_t) ? sizeof(uintptr_t) : bytes;
+    }
+
+    std::pmr::memory_resource* m_upstream;
+};
+
+#endif /* __TBB_CPP17_MEMORY_RESOURCE_PRESENT */
+
 } // namespace tbb
 
 #endif /* __TBB_cache_aligned_allocator_H */
+
diff --git a/inst/include/tbb/combinable.h b/inst/include/tbb/combinable.h
index 0063dbb4..aa8d24b1 100644
--- a/inst/include/tbb/combinable.h
+++ b/inst/include/tbb/combinable.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,15 +12,14 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_combinable_H
 #define __TBB_combinable_H
 
+#define __TBB_combinable_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #include "enumerable_thread_specific.h"
 #include "cache_aligned_allocator.h"
 
@@ -82,4 +81,8 @@ namespace tbb {
 
     };
 } // namespace tbb
+
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_combinable_H_include_area
+
 #endif /* __TBB_combinable_H */
diff --git a/inst/include/tbb/compat/condition_variable b/inst/include/tbb/compat/condition_variable
index 43edfc03..a6967817 100644
--- a/inst/include/tbb/compat/condition_variable
+++ b/inst/include/tbb/compat/condition_variable
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,21 +12,31 @@
     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 "../internal/_deprecated_header_message_guard.h"
 
+#if !defined(__TBB_show_deprecation_message_condition_variable_H) && defined(__TBB_show_deprecated_header_message)
+#define  __TBB_show_deprecation_message_condition_variable_H
+#pragma message("TBB Warning: tbb/compat/condition_variable is deprecated. For details, please see Deprecated Features appendix in the TBB reference manual.")
+#endif
 
-
-*/
+#if defined(__TBB_show_deprecated_header_message)
+#undef __TBB_show_deprecated_header_message
+#endif
 
 #ifndef __TBB_condition_variable_H
 #define __TBB_condition_variable_H
 
+#define __TBB_condition_variable_H_include_area
+#include "../internal/_warning_suppress_enable_notice.h"
+
 #if _WIN32||_WIN64
 #include "../machine/windows_api.h"
 
-namespace tbb { 
+namespace tbb {
 namespace interface5 {
-namespace internal { 
+namespace internal {
 struct condition_variable_using_event
 {
     //! Event for blocking waiting threads.
@@ -69,17 +79,17 @@ namespace interface5 {
 
 // C++0x standard working draft 30.4.3
 // Lock tag types
-struct defer_lock_t { }; //! do not acquire ownership of the mutex
-struct try_to_lock_t { }; //! try to acquire ownership of the mutex without blocking
-struct adopt_lock_t { }; //! assume the calling thread has already
-const defer_lock_t defer_lock = {};
-const try_to_lock_t try_to_lock = {};
-const adopt_lock_t adopt_lock = {};
+struct __TBB_DEPRECATED_IN_VERBOSE_MODE defer_lock_t { }; //! do not acquire ownership of the mutex
+struct __TBB_DEPRECATED_IN_VERBOSE_MODE try_to_lock_t { }; //! try to acquire ownership of the mutex without blocking
+struct __TBB_DEPRECATED_IN_VERBOSE_MODE adopt_lock_t { }; //! assume the calling thread has already
+__TBB_DEPRECATED_IN_VERBOSE_MODE const defer_lock_t defer_lock = {};
+__TBB_DEPRECATED_IN_VERBOSE_MODE const try_to_lock_t try_to_lock = {};
+__TBB_DEPRECATED_IN_VERBOSE_MODE const adopt_lock_t adopt_lock = {};
 
 // C++0x standard working draft 30.4.3.1
-//! lock_guard 
+//! lock_guard
 template<typename M>
-class lock_guard : tbb::internal::no_copy {
+class __TBB_DEPRECATED_IN_VERBOSE_MODE lock_guard : tbb::internal::no_copy {
 public:
     //! mutex type
     typedef M mutex_type;
@@ -88,7 +98,7 @@ public:
     /** precondition: If mutex_type is not a recursive mutex, the calling thread
         does not own the mutex m. */
     explicit lock_guard(mutex_type& m) : pm(m) {m.lock();}
-    
+
     //! Adopt_lock constructor
     /** precondition: the calling thread owns the mutex m. */
     lock_guard(mutex_type& m, adopt_lock_t) : pm(m) {}
@@ -100,9 +110,9 @@ private:
 };
 
 // C++0x standard working draft 30.4.3.2
-//! unique_lock 
+//! unique_lock
 template<typename M>
-class unique_lock : tbb::internal::no_copy {
+class __TBB_DEPRECATED_IN_VERBOSE_MODE unique_lock : tbb::internal::no_copy {
     friend class condition_variable;
 public:
     typedef M mutex_type;
@@ -136,7 +146,7 @@ public:
     unique_lock(mutex_type& m, adopt_lock_t) : pm(&m), owns(true) {}
 
     //! Timed unique_lock acquisition.
-    /** To avoid requiring support for namespace chrono, this method deviates from the working draft in that 
+    /** To avoid requiring support for namespace chrono, this method deviates from the working draft in that
         it uses tbb::tick_count::interval_t to specify the time duration. */
     unique_lock(mutex_type& m, const tick_count::interval_t &i) : pm(&m) {owns = try_lock_for( i );}
 
@@ -169,14 +179,14 @@ public:
             if( !owns ) {
                 pm->lock();
                 owns = true;
-            } else 
+            } else
                 throw_exception_v4( tbb::internal::eid_possible_deadlock );
-        } else 
+        } else
             throw_exception_v4( tbb::internal::eid_operation_not_permitted );
         __TBB_ASSERT( owns, NULL );
     }
 
-    //! Try to lock the mutex. 
+    //! Try to lock the mutex.
     /** If successful, note that this lock owns it. Otherwise, set it false. */
     bool try_lock() {
         if( pm ) {
@@ -184,17 +194,17 @@ public:
                 owns = pm->try_lock();
             else
                 throw_exception_v4( tbb::internal::eid_possible_deadlock );
-        } else 
+        } else
             throw_exception_v4( tbb::internal::eid_operation_not_permitted );
         return owns;
     }
- 
-    //! Try to lock the mutex. 
+
+    //! Try to lock the mutex.
     bool try_lock_for( const tick_count::interval_t &i );
 
     //! Unlock the mutex
     /** And note that this lock no longer owns it. */
-    void unlock() { 
+    void unlock() {
         if( owns ) {
             pm->unlock();
             owns = false;
@@ -212,10 +222,10 @@ public:
 
     //! Release control over the mutex.
     mutex_type* release() {
-        mutex_type* o_pm = pm; 
-        pm = NULL; 
-        owns = false; 
-        return o_pm; 
+        mutex_type* o_pm = pm;
+        pm = NULL;
+        owns = false;
+        return o_pm;
     }
 
     // 30.4.3.2.4 observers
@@ -235,12 +245,12 @@ private:
 };
 
 template<typename M>
-bool unique_lock<M>::try_lock_for( const tick_count::interval_t &i)
-{ 
+__TBB_DEPRECATED_IN_VERBOSE_MODE bool unique_lock<M>::try_lock_for( const tick_count::interval_t &i)
+{
     const int unique_lock_tick = 100; /* microseconds; 0.1 milliseconds */
     // the smallest wait-time is 0.1 milliseconds.
     bool res = pm->try_lock();
-    int duration_in_micro; 
+    int duration_in_micro;
     if( !res && (duration_in_micro=int(i.seconds()*1e6))>unique_lock_tick ) {
         tick_count::interval_t i_100( double(unique_lock_tick)/1e6 /* seconds */); // 100 microseconds = 0.1*10E-3
         do {
@@ -252,7 +262,7 @@ bool unique_lock<M>::try_lock_for( const tick_count::interval_t &i)
     return (owns=res);
 }
 
-//! Swap the two unique locks that have the mutexes of same type 
+//! Swap the two unique locks that have the mutexes of same type
 template<typename M>
 void swap(unique_lock<M>& x, unique_lock<M>& y) { x.swap( y ); }
 
@@ -277,24 +287,24 @@ typedef pthread_cond_t condvar_impl_t;
 
 //! cv_status
 /** C++0x standard working draft 30.5 */
-enum cv_status { no_timeout, timeout }; 
+enum cv_status { no_timeout, timeout };
 
 //! condition variable
-/** C++0x standard working draft 30.5.1 
+/** C++0x standard working draft 30.5.1
     @ingroup synchronization */
-class condition_variable : tbb::internal::no_copy {
+class __TBB_DEPRECATED_IN_VERBOSE_MODE condition_variable : tbb::internal::no_copy {
 public:
     //! Constructor
-    condition_variable() { 
+    condition_variable() {
 #if _WIN32||_WIN64
-        internal_initialize_condition_variable( my_cv ); 
+        internal_initialize_condition_variable( my_cv );
 #else
         pthread_cond_init( &my_cv, NULL );
 #endif
     }
 
     //! Destructor
-    ~condition_variable() { 
+    ~condition_variable() {
         //precondition: There shall be no thread blocked on *this.
 #if _WIN32||_WIN64
         internal_destroy_condition_variable( my_cv );
@@ -304,18 +314,18 @@ public:
     }
 
     //! Notify one thread and wake it up
-    void notify_one() { 
+    void notify_one() {
 #if _WIN32||_WIN64
-        internal_condition_variable_notify_one( my_cv ); 
+        internal_condition_variable_notify_one( my_cv );
 #else
         pthread_cond_signal( &my_cv );
 #endif
     }
 
-    //! Notify all threads 
-    void notify_all() { 
+    //! Notify all threads
+    void notify_all() {
 #if _WIN32||_WIN64
-        internal_condition_variable_notify_all( my_cv ); 
+        internal_condition_variable_notify_all( my_cv );
 #else
         pthread_cond_broadcast( &my_cv );
 #endif
@@ -449,7 +459,7 @@ inline cv_status condition_variable::wait_for( unique_lock<mutex>& lock, const t
 
 __TBB_DEFINE_PROFILING_SET_NAME(interface5::condition_variable)
 
-} // namespace tbb 
+} // namespace tbb
 
 #if TBB_IMPLEMENT_CPP0X
 
@@ -469,8 +479,11 @@ using tbb::interface5::cv_status;
 using tbb::interface5::timeout;
 using tbb::interface5::no_timeout;
 
-} // namespace std 
+} // namespace std
 
 #endif /* TBB_IMPLEMENT_CPP0X */
 
+#include "../internal/_warning_suppress_disable_notice.h"
+#undef __TBB_condition_variable_H_include_area
+
 #endif /* __TBB_condition_variable_H */
diff --git a/inst/include/tbb/compat/ppl.h b/inst/include/tbb/compat/ppl.h
index 840dfb22..f441b038 100644
--- a/inst/include/tbb/compat/ppl.h
+++ b/inst/include/tbb/compat/ppl.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,15 +12,25 @@
     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 "../internal/_deprecated_header_message_guard.h"
 
+#if !defined(__TBB_show_deprecation_message_ppl_H) && defined(__TBB_show_deprecated_header_message)
+#define  __TBB_show_deprecation_message_ppl_H
+#pragma message("TBB Warning: tbb/compat/ppl.h is deprecated. For details, please see Deprecated Features appendix in the TBB reference manual.")
+#endif
 
-
-*/
+#if defined(__TBB_show_deprecated_header_message)
+#undef __TBB_show_deprecated_header_message
+#endif
 
 #ifndef __TBB_compat_ppl_H
 #define __TBB_compat_ppl_H
 
+#define __TBB_ppl_H_include_area
+#include "../internal/_warning_suppress_enable_notice.h"
+
 #include "../task_group.h"
 #include "../parallel_invoke.h"
 #include "../parallel_for_each.h"
@@ -59,4 +69,7 @@ namespace Concurrency {
 
 } // namespace Concurrency
 
+#include "../internal/_warning_suppress_disable_notice.h"
+#undef __TBB_ppl_H_include_area
+
 #endif /* __TBB_compat_ppl_H */
diff --git a/inst/include/tbb/compat/thread b/inst/include/tbb/compat/thread
index 0edd9289..8b8a13d7 100644
--- a/inst/include/tbb/compat/thread
+++ b/inst/include/tbb/compat/thread
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,15 +12,25 @@
     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 "../internal/_deprecated_header_message_guard.h"
 
+#if !defined(__TBB_show_deprecation_message_thread_H) && defined(__TBB_show_deprecated_header_message)
+#define  __TBB_show_deprecation_message_thread_H
+#pragma message("TBB Warning: tbb/compat/thread is deprecated. For details, please see Deprecated Features appendix in the TBB reference manual.")
+#endif
 
-
-*/
+#if defined(__TBB_show_deprecated_header_message)
+#undef __TBB_show_deprecated_header_message
+#endif
 
 #ifndef __TBB_thread_H
 #define __TBB_thread_H
 
+#define __TBB_thread_H_include_area
+#include "../internal/_warning_suppress_enable_notice.h"
+
 #include "../tbb_config.h"
 
 #if TBB_IMPLEMENT_CPP0X
@@ -35,7 +45,7 @@ namespace this_thread {
     using tbb::this_tbb_thread::get_id;
     using tbb::this_tbb_thread::yield;
 
-    inline void sleep_for(const tbb::tick_count::interval_t& rel_time) {
+    __TBB_DEPRECATED_IN_VERBOSE_MODE inline void sleep_for(const tbb::tick_count::interval_t& rel_time) {
         tbb::internal::thread_sleep_v3( rel_time );
     }
 }
@@ -50,6 +60,9 @@ namespace this_thread {
 
 #endif /* TBB_IMPLEMENT_CPP0X */
 
+#include "../internal/_warning_suppress_disable_notice.h"
+#undef __TBB_thread_H_include_area
+
 #else /* __TBB_thread_H */
 
 #if __TBB_COMPAT_THREAD_RECURSION_PROTECTOR
diff --git a/inst/include/tbb/compat/tuple b/inst/include/tbb/compat/tuple
index 5767c49e..c568ef3d 100644
--- a/inst/include/tbb/compat/tuple
+++ b/inst/include/tbb/compat/tuple
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,15 +12,25 @@
     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 "../internal/_deprecated_header_message_guard.h"
 
+#if !defined(__TBB_show_deprecation_message_tuple_H) && defined(__TBB_show_deprecated_header_message)
+#define  __TBB_show_deprecation_message_tuple_H
+#pragma message("TBB Warning: tbb/compat/tuple is deprecated. For details, please see Deprecated Features appendix in the TBB reference manual.")
+#endif
 
-
-*/
+#if defined(__TBB_show_deprecated_header_message)
+#undef __TBB_show_deprecated_header_message
+#endif
 
 #ifndef __TBB_tuple_H
 #define __TBB_tuple_H
 
+#define __TBB_tuple_H_include_area
+#include "../internal/_warning_suppress_enable_notice.h"
+
 #include <utility>
 #include "../tbb_stddef.h"
 
@@ -214,7 +224,7 @@ struct cons{
     typedef __HT head_type;
     typedef __TT tail_type;
 
-    head_type head; 
+    head_type head;
     tail_type tail;
 
     static const int length = 1 + tail_type::length;
@@ -276,12 +286,12 @@ struct cons{
 
 
 template <typename __HT>
-struct cons<__HT,null_type> { 
+struct cons<__HT,null_type> {
 
     typedef __HT head_type;
     typedef null_type tail_type;
 
-    head_type head; 
+    head_type head;
 
     static const int length = 1;
 
@@ -350,7 +360,7 @@ inline const __T wrap_dcons(__T*) { return __T(); }
 
 // tuple definition
 template<typename __T0, typename __T1, typename __T2, typename __T3, typename __T4 __TBB_TYPENAME_T_PACK >
-class tuple : public internal::tuple_traits<__T0, __T1, __T2, __T3, __T4 __TBB_T_PACK >::U {
+class __TBB_DEPRECATED_IN_VERBOSE_MODE tuple : public internal::tuple_traits<__T0, __T1, __T2, __T3, __T4 __TBB_T_PACK >::U {
     // friends
     template <typename __T> friend class tuple_size;
     template<int __N, typename __T> friend struct tuple_element;
@@ -366,7 +376,7 @@ class tuple : public internal::tuple_traits<__T0, __T1, __T2, __T3, __T4 __TBB_T
     typedef typename internal::tuple_traits<__T0,__T1,__T2,__T3, __T4 __TBB_T_PACK >::U my_cons;
 
 public:
-    tuple(const __T0& t0=internal::wrap_dcons((__T0*)NULL)
+    __TBB_DEPRECATED_IN_VERBOSE_MODE tuple(const __T0& t0=internal::wrap_dcons((__T0*)NULL)
           ,const __T1& t1=internal::wrap_dcons((__T1*)NULL)
           ,const __T2& t2=internal::wrap_dcons((__T2*)NULL)
           ,const __T3& t3=internal::wrap_dcons((__T3*)NULL)
@@ -425,7 +435,7 @@ public:
 
 // empty tuple
 template<>
-class tuple<null_type, null_type, null_type, null_type, null_type __TBB_NULL_TYPE_PACK > : public null_type {
+class __TBB_DEPRECATED_IN_VERBOSE_MODE tuple<null_type, null_type, null_type, null_type, null_type __TBB_NULL_TYPE_PACK > : public null_type {
 };
 
 // helper classes
@@ -437,7 +447,7 @@ public:
 };
 
 template <>
-class tuple_size<tuple<> > { 
+class tuple_size<tuple<> > {
 public:
     static const size_t value = 0;
 };
@@ -484,5 +494,8 @@ namespace tbb {
 #undef __TBB_CONST_REF_T_PARAM_PACK
 #undef __TBB_T_PARAM_LIST_PACK
 #undef __TBB_CONST_NULL_REF_PACK
- 
+
+#include "../internal/_warning_suppress_disable_notice.h"
+#undef __TBB_tuple_H_include_area
+
 #endif /* __TBB_tuple_H */
diff --git a/inst/include/tbb/concurrent_hash_map.h b/inst/include/tbb/concurrent_hash_map.h
index 8497c838..80bad97b 100644
--- a/inst/include/tbb/concurrent_hash_map.h
+++ b/inst/include/tbb/concurrent_hash_map.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,39 +12,29 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_concurrent_hash_map_H
 #define __TBB_concurrent_hash_map_H
 
-#include "tbb_stddef.h"
-
-#if !TBB_USE_EXCEPTIONS && _MSC_VER
-    // Suppress "C++ exception handler used, but unwind semantics are not enabled" warning in STL headers
-    #pragma warning (push)
-    #pragma warning (disable: 4530)
-#endif
+#define __TBB_concurrent_hash_map_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
 
+#include "tbb_stddef.h"
 #include <iterator>
 #include <utility>      // Need std::pair
 #include <cstring>      // Need std::memset
 #include __TBB_STD_SWAP_HEADER
 
-#if !TBB_USE_EXCEPTIONS && _MSC_VER
-    #pragma warning (pop)
-#endif
-
-#include "cache_aligned_allocator.h"
 #include "tbb_allocator.h"
 #include "spin_rw_mutex.h"
 #include "atomic.h"
 #include "tbb_exception.h"
 #include "tbb_profiling.h"
+#include "aligned_space.h"
 #include "internal/_tbb_hash_compare_impl.h"
+#include "internal/_template_helpers.h"
+#include "internal/_allocator_traits.h"
 #if __TBB_INITIALIZER_LISTS_PRESENT
 #include <initializer_list>
 #endif
@@ -54,12 +44,17 @@
 #if __TBB_STATISTICS
 #include <stdio.h>
 #endif
+#if __TBB_CPP11_RVALUE_REF_PRESENT && __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT && __TBB_CPP11_TUPLE_PRESENT
+// Definition of __TBB_CPP11_RVALUE_REF_PRESENT includes __TBB_CPP11_TUPLE_PRESENT
+// for most of platforms, tuple present macro was added for logical correctness
+#include <tuple>
+#endif
 
 namespace tbb {
 
 namespace interface5 {
 
-    template<typename Key, typename T, typename HashCompare = tbb_hash_compare<Key>, typename A = tbb_allocator<std::pair<Key, T> > >
+    template<typename Key, typename T, typename HashCompare = tbb_hash_compare<Key>, typename A = tbb_allocator<std::pair<const Key, T> > >
     class concurrent_hash_map;
 
     //! @cond INTERNAL
@@ -130,9 +125,10 @@ namespace interface5 {
 #endif
         //! Constructor
         hash_map_base() {
-            std::memset( (void*) this, 0, pointers_per_table*sizeof(segment_ptr_t) // 32*4=128   or 64*8=512
-                + sizeof(my_size) + sizeof(my_mask)  // 4+4 or 8+8
-                + embedded_buckets*sizeof(bucket) ); // n*8 or n*16
+            std::memset(my_table, 0, sizeof(my_table));
+            my_mask = 0;
+            my_size = 0;
+            std::memset(my_embedded_segment, 0, sizeof(my_embedded_segment));
             for( size_type i = 0; i < embedded_block; i++ ) // fill the table
                 my_table[i] = my_embedded_segment + segment_base(i);
             my_mask = embedded_buckets - 1;
@@ -166,7 +162,7 @@ namespace interface5 {
 
         //! Initialize buckets
         static void init_buckets( segment_ptr_t ptr, size_type sz, bool is_initial ) {
-            if( is_initial ) std::memset((void*) ptr, 0, sz*sizeof(bucket) );
+            if( is_initial ) std::memset( static_cast<void*>(ptr), 0, sz*sizeof(bucket) );
             else for(size_type i = 0; i < sz; i++, ptr++) {
                 *reinterpret_cast<intptr_t*>(&ptr->mutex) = 0;
                 ptr->node_list = rehash_req;
@@ -190,22 +186,25 @@ namespace interface5 {
         };
 
         //! Enable segment
-        void enable_segment( segment_index_t k, bool is_initial = false ) {
+        template<typename Allocator>
+        void enable_segment( segment_index_t k, const Allocator& allocator, bool is_initial = false ) {
+            typedef typename tbb::internal::allocator_rebind<Allocator, bucket>::type bucket_allocator_type;
+            typedef tbb::internal::allocator_traits<bucket_allocator_type> bucket_allocator_traits;
+            bucket_allocator_type bucket_allocator(allocator);
             __TBB_ASSERT( k, "Zero segment must be embedded" );
             enable_segment_failsafe watchdog( my_table, k );
-            cache_aligned_allocator<bucket> alloc;
             size_type sz;
             __TBB_ASSERT( !is_valid(my_table[k]), "Wrong concurrent assignment");
             if( k >= first_block ) {
                 sz = segment_size( k );
-                segment_ptr_t ptr = alloc.allocate( sz );
+                segment_ptr_t ptr = bucket_allocator_traits::allocate(bucket_allocator, sz);
                 init_buckets( ptr, sz, is_initial );
                 itt_hide_store_word( my_table[k], ptr );
                 sz <<= 1;// double it to get entire capacity of the container
             } else { // the first block
                 __TBB_ASSERT( k == embedded_block, "Wrong segment index" );
                 sz = segment_size( first_block );
-                segment_ptr_t ptr = alloc.allocate( sz - embedded_buckets );
+                segment_ptr_t ptr = bucket_allocator_traits::allocate(bucket_allocator, sz - embedded_buckets);
                 init_buckets( ptr, sz - embedded_buckets, is_initial );
                 ptr -= segment_base(embedded_block);
                 for(segment_index_t i = embedded_block; i < first_block; i++) // calc the offsets
@@ -215,6 +214,22 @@ namespace interface5 {
             watchdog.my_segment_ptr = 0;
         }
 
+        template<typename Allocator>
+        void delete_segment(segment_index_t s, const Allocator& allocator) {
+            typedef typename tbb::internal::allocator_rebind<Allocator, bucket>::type bucket_allocator_type;
+            typedef tbb::internal::allocator_traits<bucket_allocator_type> bucket_allocator_traits;
+            bucket_allocator_type bucket_allocator(allocator);
+            segment_ptr_t buckets_ptr = my_table[s];
+            size_type sz = segment_size( s ? s : 1 );
+
+            if( s >= first_block) // the first segment or the next
+                bucket_allocator_traits::deallocate(bucket_allocator, buckets_ptr, sz);
+            else if( s == embedded_block && embedded_block != first_block )
+                bucket_allocator_traits::deallocate(bucket_allocator, buckets_ptr,
+                                                    segment_size(first_block) - embedded_buckets);
+            if( s >= embedded_block ) my_table[s] = 0;
+        }
+
         //! Get bucket by (masked) hashcode
         bucket *get_bucket( hashcode_t h ) const throw() { // TODO: add throw() everywhere?
             segment_index_t s = segment_index_of( h );
@@ -283,11 +298,12 @@ namespace interface5 {
         }
 
         //! Prepare enough segments for number of buckets
-        void reserve(size_type buckets) {
+        template<typename Allocator>
+        void reserve(size_type buckets, const Allocator& allocator) {
             if( !buckets-- ) return;
             bool is_initial = !my_size;
             for( size_type m = my_mask; buckets > m; m = my_mask )
-                enable_segment( segment_index_of( m+1 ), is_initial );
+                enable_segment( segment_index_of( m+1 ), allocator, is_initial );
         }
         //! Swap hash_map_bases
         void internal_swap(hash_map_base &table) {
@@ -299,6 +315,25 @@ namespace interface5 {
             for(size_type i = embedded_block; i < pointers_per_table; i++)
                 swap(this->my_table[i], table.my_table[i]);
         }
+
+#if __TBB_CPP11_RVALUE_REF_PRESENT
+        void internal_move(hash_map_base&& other) {
+            my_mask = other.my_mask;
+            other.my_mask = embedded_buckets - 1;
+            my_size = other.my_size;
+            other.my_size = 0;
+
+            for(size_type i = 0; i < embedded_buckets; ++i) {
+                my_embedded_segment[i].node_list = other.my_embedded_segment[i].node_list;
+                other.my_embedded_segment[i].node_list = NULL;
+            }
+
+            for(size_type i = embedded_block; i < pointers_per_table; ++i) {
+                my_table[i] = other.my_table[i];
+                other.my_table[i] = NULL;
+            }
+        }
+#endif // __TBB_CPP11_RVALUE_REF_PRESENT
     };
 
     template<typename Iterator>
@@ -376,9 +411,17 @@ namespace interface5 {
             my_bucket(other.my_bucket),
             my_node(other.my_node)
         {}
+
+        hash_map_iterator& operator=( const hash_map_iterator<Container,typename Container::value_type> &other ) {
+            my_map = other.my_map;
+            my_index = other.my_index;
+            my_bucket = other.my_bucket;
+            my_node = other.my_node;
+            return *this;
+        }
         Value& operator*() const {
             __TBB_ASSERT( hash_map_base::is_valid(my_node), "iterator uninitialized or at end of container?" );
-            return my_node->item;
+            return my_node->value();
         }
         Value* operator->() const {return &operator*();}
         hash_map_iterator& operator++();
@@ -564,62 +607,80 @@ class concurrent_hash_map : protected internal::hash_map_base {
 
 protected:
     friend class const_accessor;
-    struct node;
-    typedef typename Allocator::template rebind<node>::other node_allocator_type;
+    class node;
+    typedef typename tbb::internal::allocator_rebind<Allocator, node>::type node_allocator_type;
+    typedef tbb::internal::allocator_traits<node_allocator_type> node_allocator_traits;
     node_allocator_type my_allocator;
     HashCompare my_hash_compare;
 
-    struct node : public node_base {
-        value_type item;
-        node( const Key &key ) : item(key, T()) {}
-        node( const Key &key, const T &t ) : item(key, t) {}
-#if __TBB_CPP11_RVALUE_REF_PRESENT
-        node( const Key &key, T &&t ) : item(key, std::move(t)) {}
-        node( value_type&& i ) : item(std::move(i)){}
-#if __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT
-        template<typename... Args>
-        node( Args&&... args ) : item(std::forward<Args>(args)...) {}
-#if __TBB_COPY_FROM_NON_CONST_REF_BROKEN
-        node( value_type& i ) : item(const_cast<const value_type&>(i)) {}
-#endif //__TBB_COPY_FROM_NON_CONST_REF_BROKEN
-#endif //__TBB_CPP11_VARIADIC_TEMPLATES_PRESENT
-#endif //__TBB_CPP11_RVALUE_REF_PRESENT
-        node( const value_type& i ) : item(i) {}
-
-        // exception-safe allocation, see C++ Standard 2003, clause 5.3.4p17
-        void *operator new( size_t /*size*/, node_allocator_type &a ) {
-            void *ptr = a.allocate(1);
-            if(!ptr)
-                tbb::internal::throw_exception(tbb::internal::eid_bad_alloc);
-            return ptr;
-        }
-        // match placement-new form above to be called if exception thrown in constructor
-        void operator delete( void *ptr, node_allocator_type &a ) { a.deallocate(static_cast<node*>(ptr),1); }
+    class node : public node_base {
+        tbb::aligned_space<value_type> my_value;
+    public:
+        value_type* storage() { return my_value.begin(); }
+        value_type& value() { return *storage(); }
     };
 
     void delete_node( node_base *n ) {
-        my_allocator.destroy( static_cast<node*>(n) );
-        my_allocator.deallocate( static_cast<node*>(n), 1);
+        node_allocator_traits::destroy(my_allocator, static_cast<node*>(n)->storage());
+        node_allocator_traits::destroy(my_allocator, static_cast<node*>(n));
+        node_allocator_traits::deallocate(my_allocator, static_cast<node*>(n), 1);
+    }
+
+    struct node_scoped_guard : tbb::internal::no_copy {
+        node* my_node;
+        node_allocator_type& my_alloc;
+
+        node_scoped_guard(node* n, node_allocator_type& alloc) : my_node(n), my_alloc(alloc) {}
+        ~node_scoped_guard() {
+            if(my_node) {
+                node_allocator_traits::destroy(my_alloc, my_node);
+                node_allocator_traits::deallocate(my_alloc, my_node, 1);
+            }
+        }
+        void dismiss() { my_node = NULL; }
+    };
+
+#if __TBB_CPP11_RVALUE_REF_PRESENT && __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT
+    template<typename... Args>
+    static node* create_node(node_allocator_type& allocator, Args&&... args)
+#else
+    template<typename Arg1, typename Arg2>
+    static node* create_node(node_allocator_type& allocator, __TBB_FORWARDING_REF(Arg1) arg1, __TBB_FORWARDING_REF(Arg2) arg2)
+#endif
+    {
+        node* node_ptr = node_allocator_traits::allocate(allocator, 1);
+        node_scoped_guard guard(node_ptr, allocator);
+        node_allocator_traits::construct(allocator, node_ptr);
+#if __TBB_CPP11_RVALUE_REF_PRESENT && __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT
+        node_allocator_traits::construct(allocator, node_ptr->storage(), std::forward<Args>(args)...);
+#else
+        node_allocator_traits::construct(allocator, node_ptr->storage(), tbb::internal::forward<Arg1>(arg1), tbb::internal::forward<Arg2>(arg2));
+#endif
+        guard.dismiss();
+        return node_ptr;
     }
 
     static node* allocate_node_copy_construct(node_allocator_type& allocator, const Key &key, const T * t){
-        return  new( allocator ) node(key, *t);
+        return create_node(allocator, key, *t);
     }
 
 #if __TBB_CPP11_RVALUE_REF_PRESENT
     static node* allocate_node_move_construct(node_allocator_type& allocator, const Key &key, const T * t){
-        return  new( allocator ) node(key, std::move(*const_cast<T*>(t)));
+        return create_node(allocator, key, std::move(*const_cast<T*>(t)));
     }
-#if __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT
-    template<typename... Args>
-    static node* allocate_node_emplace_construct(node_allocator_type& allocator, Args&&... args){
-        return  new( allocator ) node(std::forward<Args>(args)...);
-    }
-#endif //#if __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT
 #endif
 
     static node* allocate_node_default_construct(node_allocator_type& allocator, const Key &key, const T * ){
-        return  new( allocator ) node(key);
+#if __TBB_CPP11_RVALUE_REF_PRESENT && __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT && __TBB_CPP11_TUPLE_PRESENT
+        // Emplace construct an empty T object inside the pair
+        return create_node(allocator, std::piecewise_construct,
+                           std::forward_as_tuple(key), std::forward_as_tuple());
+#else
+        // Use of a temporary object is impossible, because create_node takes a non-const reference.
+        // copy-initialization is possible because T is already required to be CopyConstructible.
+        T obj = T();
+        return create_node(allocator, key, tbb::internal::move(obj));
+#endif
     }
 
     static node* do_not_allocate_node(node_allocator_type& , const Key &, const T * ){
@@ -629,7 +690,7 @@ class concurrent_hash_map : protected internal::hash_map_base {
 
     node *search_bucket( const key_type &key, bucket *b ) const {
         node *n = static_cast<node*>( b->node_list );
-        while( is_valid(n) && !my_hash_compare.equal(key, n->item.first) )
+        while( is_valid(n) && !my_hash_compare.equal(key, n->value().first) )
             n = static_cast<node*>( n->next );
         __TBB_ASSERT(n != internal::rehash_req, "Search can be executed only for rehashed bucket");
         return n;
@@ -674,7 +735,7 @@ class concurrent_hash_map : protected internal::hash_map_base {
         __TBB_ASSERT( (mask&(mask+1))==0 && (h & mask) == h, NULL );
     restart:
         for( node_base **p = &b_old()->node_list, *n = __TBB_load_with_acquire(*p); is_valid(n); n = *p ) {
-            hashcode_t c = my_hash_compare.hash( static_cast<node*>(n)->item.first );
+            hashcode_t c = my_hash_compare.hash( static_cast<node*>(n)->value().first );
 #if TBB_USE_ASSERT
             hashcode_t bmask = h & (mask>>1);
             bmask = bmask==0? 1 : ( 1u<<(__TBB_Log2( bmask )+1 ) ) - 1; // minimal mask of parent bucket
@@ -726,7 +787,7 @@ class concurrent_hash_map : protected internal::hash_map_base {
         //! Return reference to associated value in hash table.
         const_reference operator*() const {
             __TBB_ASSERT( my_node, "attempt to dereference empty accessor" );
-            return my_node->item;
+            return my_node->value();
         }
 
         //! Return pointer to associated value in hash table.
@@ -756,7 +817,7 @@ class concurrent_hash_map : protected internal::hash_map_base {
         //! Return reference to associated value in hash table.
         reference operator*() const {
             __TBB_ASSERT( this->my_node, "attempt to dereference empty accessor" );
-            return this->my_node->item;
+            return this->my_node->value();
         }
 
         //! Return pointer to associated value in hash table.
@@ -770,18 +831,39 @@ class concurrent_hash_map : protected internal::hash_map_base {
         : internal::hash_map_base(), my_allocator(a)
     {}
 
+    explicit concurrent_hash_map( const HashCompare& compare, const allocator_type& a = allocator_type() )
+        : internal::hash_map_base(), my_allocator(a), my_hash_compare(compare)
+    {}
+
     //! Construct empty table with n preallocated buckets. This number serves also as initial concurrency level.
     concurrent_hash_map( size_type n, const allocator_type &a = allocator_type() )
-        : my_allocator(a)
+        : internal::hash_map_base(), my_allocator(a)
+    {
+        reserve( n, my_allocator );
+    }
+
+    concurrent_hash_map( size_type n, const HashCompare& compare, const allocator_type& a = allocator_type() )
+        : internal::hash_map_base(), my_allocator(a), my_hash_compare(compare)
     {
-        reserve( n );
+        reserve( n, my_allocator );
     }
 
     //! Copy constructor
-    concurrent_hash_map( const concurrent_hash_map &table, const allocator_type &a = allocator_type() )
+    concurrent_hash_map( const concurrent_hash_map &table )
+        : internal::hash_map_base(),
+          my_allocator(node_allocator_traits::select_on_container_copy_construction(table.get_allocator()))
+    {
+        call_clear_on_leave scope_guard(this);
+        internal_copy(table);
+        scope_guard.dismiss();
+    }
+
+    concurrent_hash_map( const concurrent_hash_map &table, const allocator_type &a)
         : internal::hash_map_base(), my_allocator(a)
     {
+        call_clear_on_leave scope_guard(this);
         internal_copy(table);
+        scope_guard.dismiss();
     }
 
 #if __TBB_CPP11_RVALUE_REF_PRESENT
@@ -789,7 +871,7 @@ class concurrent_hash_map : protected internal::hash_map_base {
     concurrent_hash_map( concurrent_hash_map &&table )
         : internal::hash_map_base(), my_allocator(std::move(table.get_allocator()))
     {
-        swap(table);
+        internal_move(std::move(table));
     }
 
     //! Move constructor
@@ -797,10 +879,10 @@ class concurrent_hash_map : protected internal::hash_map_base {
         : internal::hash_map_base(), my_allocator(a)
     {
         if (a == table.get_allocator()){
-            this->swap(table);
+            internal_move(std::move(table));
         }else{
             call_clear_on_leave scope_guard(this);
-            internal_copy(std::make_move_iterator(table.begin()), std::make_move_iterator(table.end()));
+            internal_copy(std::make_move_iterator(table.begin()), std::make_move_iterator(table.end()), table.size());
             scope_guard.dismiss();
         }
     }
@@ -809,19 +891,38 @@ class concurrent_hash_map : protected internal::hash_map_base {
     //! Construction with copying iteration range and given allocator instance
     template<typename I>
     concurrent_hash_map( I first, I last, const allocator_type &a = allocator_type() )
-        : my_allocator(a)
+        : internal::hash_map_base(), my_allocator(a)
+    {
+        call_clear_on_leave scope_guard(this);
+        internal_copy(first, last, std::distance(first, last));
+        scope_guard.dismiss();
+    }
+
+    template<typename I>
+    concurrent_hash_map( I first, I last, const HashCompare& compare, const allocator_type& a = allocator_type() )
+        : internal::hash_map_base(), my_allocator(a), my_hash_compare(compare)
     {
-        reserve( std::distance(first, last) ); // TODO: load_factor?
-        internal_copy(first, last);
+        call_clear_on_leave scope_guard(this);
+        internal_copy(first, last, std::distance(first, last));
+        scope_guard.dismiss();
     }
 
 #if __TBB_INITIALIZER_LISTS_PRESENT
     //! Construct empty table with n preallocated buckets. This number serves also as initial concurrency level.
     concurrent_hash_map( std::initializer_list<value_type> il, const allocator_type &a = allocator_type() )
-        : my_allocator(a)
+        : internal::hash_map_base(), my_allocator(a)
     {
-        reserve(il.size());
-        internal_copy(il.begin(), il.end());
+        call_clear_on_leave scope_guard(this);
+        internal_copy(il.begin(), il.end(), il.size());
+        scope_guard.dismiss();
+    }
+
+    concurrent_hash_map( std::initializer_list<value_type> il, const HashCompare& compare, const allocator_type& a = allocator_type() )
+        : internal::hash_map_base(), my_allocator(a), my_hash_compare(compare)
+    {
+        call_clear_on_leave scope_guard(this);
+        internal_copy(il.begin(), il.end(), il.size());
+        scope_guard.dismiss();
     }
 
 #endif //__TBB_INITIALIZER_LISTS_PRESENT
@@ -829,7 +930,9 @@ class concurrent_hash_map : protected internal::hash_map_base {
     //! Assignment
     concurrent_hash_map& operator=( const concurrent_hash_map &table ) {
         if( this!=&table ) {
+            typedef typename node_allocator_traits::propagate_on_container_copy_assignment pocca_type;
             clear();
+            tbb::internal::allocator_copy_assignment(my_allocator, table.my_allocator, pocca_type());
             internal_copy(table);
         }
         return *this;
@@ -838,17 +941,9 @@ class concurrent_hash_map : protected internal::hash_map_base {
 #if __TBB_CPP11_RVALUE_REF_PRESENT
     //! Move Assignment
     concurrent_hash_map& operator=( concurrent_hash_map &&table ) {
-        if(this != &table){
-            typedef typename tbb::internal::allocator_traits<allocator_type>::propagate_on_container_move_assignment pocma_t;
-            if(pocma_t::value || this->my_allocator == table.my_allocator) {
-                concurrent_hash_map trash (std::move(*this));
-                //TODO: swapping allocators here may be a problem, replace with single direction moving iff pocma is set
-                this->swap(table);
-            } else {
-                //do per element move
-                concurrent_hash_map moved_copy(std::move(table), this->my_allocator);
-                this->swap(moved_copy);
-            }
+        if(this != &table) {
+            typedef typename node_allocator_traits::propagate_on_container_move_assignment pocma_type;
+            internal_move_assign(std::move(table), pocma_type());
         }
         return *this;
     }
@@ -858,8 +953,7 @@ class concurrent_hash_map : protected internal::hash_map_base {
     //! Assignment
     concurrent_hash_map& operator=( std::initializer_list<value_type> il ) {
         clear();
-        reserve(il.size());
-        internal_copy(il.begin(), il.end());
+        internal_copy(il.begin(), il.end(), il.size());
         return *this;
     }
 #endif //__TBB_INITIALIZER_LISTS_PRESENT
@@ -1067,8 +1161,8 @@ class concurrent_hash_map : protected internal::hash_map_base {
     template<typename Accessor, typename... Args>
     bool generic_emplace( Accessor && result, Args &&... args ) {
         result.release();
-        node * node_ptr = allocate_node_emplace_construct(my_allocator, std::forward<Args>(args)...);
-        return lookup(/*insert*/true, node_ptr->item.first, NULL, accessor_location(result), is_write_access_needed(result), &do_not_allocate_node, node_ptr );
+        node * node_ptr = create_node(my_allocator, std::forward<Args>(args)...);
+        return lookup(/*insert*/true, node_ptr->value().first, NULL, accessor_location(result), is_write_access_needed(result), &do_not_allocate_node, node_ptr );
     }
 #endif //__TBB_CPP11_VARIADIC_TEMPLATES_PRESENT
 #endif //__TBB_CPP11_RVALUE_REF_PRESENT
@@ -1084,7 +1178,24 @@ class concurrent_hash_map : protected internal::hash_map_base {
     void internal_copy( const concurrent_hash_map& source );
 
     template<typename I>
-    void internal_copy( I first, I last );
+    void internal_copy( I first, I last, size_type reserve_size );
+
+#if __TBB_CPP11_RVALUE_REF_PRESENT
+    // A compile-time dispatch to allow move assignment of containers with non-movable value_type if POCMA is true_type
+    void internal_move_assign(concurrent_hash_map&& other, tbb::internal::traits_true_type) {
+        tbb::internal::allocator_move_assignment(my_allocator, other.my_allocator, tbb::internal::traits_true_type());
+        internal_move(std::move(other));
+    }
+
+    void internal_move_assign(concurrent_hash_map&& other, tbb::internal::traits_false_type) {
+        if (this->my_allocator == other.my_allocator) {
+            internal_move(std::move(other));
+        } else {
+            //do per element move
+            internal_copy(std::make_move_iterator(other.begin()), std::make_move_iterator(other.end()), other.size());
+        }
+    }
+#endif
 
     //! Fast find when no concurrent erasure is used. For internal use inside TBB only!
     /** Return pointer to item with given key, or NULL if no such item exists.
@@ -1109,13 +1220,40 @@ class concurrent_hash_map : protected internal::hash_map_base {
         }
         n = search_bucket( key, b );
         if( n )
-            return &n->item;
+            return n->storage();
         else if( check_mask_race( h, m ) )
             goto restart;
         return 0;
     }
 };
 
+#if __TBB_CPP17_DEDUCTION_GUIDES_PRESENT
+namespace internal {
+using namespace tbb::internal;
+
+template<template<typename...> typename Map, typename Key, typename T, typename... Args>
+using hash_map_t = Map<
+    Key, T,
+    std::conditional_t< (sizeof...(Args)>0) && !is_allocator_v< pack_element_t<0, Args...> >,
+                        pack_element_t<0, Args...>, tbb_hash_compare<Key> >,
+    std::conditional_t< (sizeof...(Args)>0) && is_allocator_v< pack_element_t<sizeof...(Args)-1, Args...> >,
+                         pack_element_t<sizeof...(Args)-1, Args...>, tbb_allocator<std::pair<const Key, T> > >
+>;
+}
+
+// Deduction guide for the constructor from two iterators and hash_compare/ allocator
+template<typename I, typename... Args>
+concurrent_hash_map(I, I, Args...)
+-> internal::hash_map_t<concurrent_hash_map, internal::iterator_key_t<I>,internal::iterator_mapped_t<I>, Args...>;
+
+// Deduction guide for the constructor from an initializer_list and hash_compare/ allocator
+// Deduction guide for an initializer_list, hash_compare and allocator is implicit
+template<typename Key, typename T, typename CompareOrAllocator>
+concurrent_hash_map(std::initializer_list<std::pair<const Key, T>>, CompareOrAllocator)
+-> internal::hash_map_t<concurrent_hash_map, Key, T, CompareOrAllocator>;
+
+#endif /* __TBB_CPP17_DEDUCTION_GUIDES_PRESENT */
+
 template<typename Key, typename T, typename HashCompare, typename A>
 bool concurrent_hash_map<Key,T,HashCompare,A>::lookup( bool op_insert, const Key &key, const T *t, const_accessor *result, bool write, node* (*allocate_node)(node_allocator_type& , const Key&, const T*), node *tmp_n ) {
     __TBB_ASSERT( !result || !result->my_node, NULL );
@@ -1188,7 +1326,7 @@ bool concurrent_hash_map<Key,T,HashCompare,A>::lookup( bool op_insert, const Key
 #if __TBB_STATISTICS
         my_info_resizes++; // concurrent ones
 #endif
-        enable_segment( grow_segment );
+        enable_segment( grow_segment, my_allocator );
     }
     if( tmp_n ) // if op_insert only
         delete_node( tmp_n );
@@ -1256,7 +1394,7 @@ bool concurrent_hash_map<Key,T,HashCompare,A>::erase( const Key &key ) {
     search:
         node_base **p = &b()->node_list;
         n = *p;
-        while( is_valid(n) && !my_hash_compare.equal(key, static_cast<node*>(n)->item.first ) ) {
+        while( is_valid(n) && !my_hash_compare.equal(key, static_cast<node*>(n)->value().first ) ) {
             p = &n->next;
             n = *p;
         }
@@ -1283,16 +1421,18 @@ bool concurrent_hash_map<Key,T,HashCompare,A>::erase( const Key &key ) {
 
 template<typename Key, typename T, typename HashCompare, typename A>
 void concurrent_hash_map<Key,T,HashCompare,A>::swap(concurrent_hash_map<Key,T,HashCompare,A> &table) {
-    //TODO: respect C++11 allocator_traits<A>::propogate_on_constainer_swap
-    using std::swap;
-    swap(this->my_allocator, table.my_allocator);
-    swap(this->my_hash_compare, table.my_hash_compare);
-    internal_swap(table);
+    typedef typename node_allocator_traits::propagate_on_container_swap pocs_type;
+    if (this != &table && (pocs_type::value || my_allocator == table.my_allocator)) {
+        using std::swap;
+        tbb::internal::allocator_swap(this->my_allocator, table.my_allocator, pocs_type());
+        swap(this->my_hash_compare, table.my_hash_compare);
+        internal_swap(table);
+    }
 }
 
 template<typename Key, typename T, typename HashCompare, typename A>
 void concurrent_hash_map<Key,T,HashCompare,A>::rehash(size_type sz) {
-    reserve( sz ); // TODO: add reduction of number of buckets as well
+    reserve( sz, my_allocator ); // TODO: add reduction of number of buckets as well
     hashcode_t mask = my_mask;
     hashcode_t b = (mask+1)>>1; // size or first index of the last segment
     __TBB_ASSERT((b&(b-1))==0, NULL); // zero or power of 2
@@ -1311,7 +1451,7 @@ void concurrent_hash_map<Key,T,HashCompare,A>::rehash(size_type sz) {
             // now h - is index of the root rehashed bucket b_old
             mark_rehashed_levels( h ); // mark all non-rehashed children recursively across all segments
             for( node_base **p = &b_old->node_list, *q = *p; is_valid(q); q = *p ) {
-                hashcode_t c = my_hash_compare.hash( static_cast<node*>(q)->item.first );
+                hashcode_t c = my_hash_compare.hash( static_cast<node*>(q)->value().first );
                 if( (c & mask) != h ) { // should be rehashed
                     *p = q->next; // exclude from b_old
                     bucket *b_new = get_bucket( c & mask );
@@ -1338,7 +1478,7 @@ void concurrent_hash_map<Key,T,HashCompare,A>::rehash(size_type sz) {
 #endif
 #if TBB_USE_ASSERT
         for( ; is_valid(n); n = n->next ) {
-            hashcode_t h = my_hash_compare.hash( static_cast<node*>(n)->item.first ) & mask;
+            hashcode_t h = my_hash_compare.hash( static_cast<node*>(n)->value().first ) & mask;
             __TBB_ASSERT( h == b, "hash() function changed for key in table or internal error" );
         }
 #endif
@@ -1385,7 +1525,7 @@ void concurrent_hash_map<Key,T,HashCompare,A>::clear() {
 #endif
 #if __TBB_EXTRA_DEBUG
         for(; is_valid(n); n = n->next ) {
-            hashcode_t h = my_hash_compare.hash( static_cast<node*>(n)->item.first );
+            hashcode_t h = my_hash_compare.hash( static_cast<node*>(n)->value().first );
             h &= m;
             __TBB_ASSERT( h == b || get_bucket(h)->node_list == internal::rehash_req, "hash() function changed for key in table or internal error" );
         }
@@ -1415,11 +1555,10 @@ void concurrent_hash_map<Key,T,HashCompare,A>::clear() {
         reported = true;
     }
 #endif
-#endif//TBB_USE_ASSERT || TBB_USE_PERFORMANCE_WARNINGS || __TBB_STATISTICS
+#endif // TBB_USE_ASSERT || TBB_USE_PERFORMANCE_WARNINGS || __TBB_STATISTICS
     my_size = 0;
     segment_index_t s = segment_index_of( m );
     __TBB_ASSERT( s+1 == pointers_per_table || !my_table[s+1], "wrong mask or concurrent grow" );
-    cache_aligned_allocator<bucket> alloc;
     do {
         __TBB_ASSERT( is_valid( my_table[s] ), "wrong mask or concurrent grow" );
         segment_ptr_t buckets_ptr = my_table[s];
@@ -1429,20 +1568,16 @@ void concurrent_hash_map<Key,T,HashCompare,A>::clear() {
                 buckets_ptr[i].node_list = n->next;
                 delete_node( n );
             }
-        if( s >= first_block) // the first segment or the next
-            alloc.deallocate( buckets_ptr, sz );
-        else if( s == embedded_block && embedded_block != first_block )
-            alloc.deallocate( buckets_ptr, segment_size(first_block)-embedded_buckets );
-        if( s >= embedded_block ) my_table[s] = 0;
+        delete_segment(s, my_allocator);
     } while(s-- > 0);
     my_mask = embedded_buckets - 1;
 }
 
 template<typename Key, typename T, typename HashCompare, typename A>
 void concurrent_hash_map<Key,T,HashCompare,A>::internal_copy( const concurrent_hash_map& source ) {
-    reserve( source.my_size ); // TODO: load_factor?
     hashcode_t mask = source.my_mask;
     if( my_mask == mask ) { // optimized version
+        reserve( source.my_size, my_allocator ); // TODO: load_factor?
         bucket *dst = 0, *src = 0;
         bool rehash_required = false;
         for( hashcode_t k = 0; k <= mask; k++ ) {
@@ -1454,24 +1589,26 @@ void concurrent_hash_map<Key,T,HashCompare,A>::internal_copy( const concurrent_h
                 rehash_required = true;
                 dst->node_list = internal::rehash_req;
             } else for(; n; n = static_cast<node*>( n->next ) ) {
-                add_to_bucket( dst, new( my_allocator ) node(n->item.first, n->item.second) );
+                node* node_ptr = create_node(my_allocator, n->value().first, n->value().second);
+                add_to_bucket( dst, node_ptr);
                 ++my_size; // TODO: replace by non-atomic op
             }
         }
         if( rehash_required ) rehash();
-    } else internal_copy( source.begin(), source.end() );
+    } else internal_copy( source.begin(), source.end(), source.my_size );
 }
 
 template<typename Key, typename T, typename HashCompare, typename A>
 template<typename I>
-void concurrent_hash_map<Key,T,HashCompare,A>::internal_copy(I first, I last) {
+void concurrent_hash_map<Key,T,HashCompare,A>::internal_copy(I first, I last, size_type reserve_size) {
+    reserve( reserve_size, my_allocator ); // TODO: load_factor?
     hashcode_t m = my_mask;
     for(; first != last; ++first) {
         hashcode_t h = my_hash_compare.hash( (*first).first );
         bucket *b = get_bucket( h & m );
         __TBB_ASSERT( b->node_list != internal::rehash_req, "Invalid bucket in destination table");
-        node *n = new( my_allocator ) node(*first);
-        add_to_bucket( b, n );
+        node* node_ptr = create_node(my_allocator, (*first).first, (*first).second);
+        add_to_bucket( b, node_ptr );
         ++my_size; // TODO: replace by non-atomic op
     }
 }
@@ -1507,4 +1644,7 @@ inline void swap(concurrent_hash_map<Key, T, HashCompare, A> &a, concurrent_hash
 
 } // namespace tbb
 
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_concurrent_hash_map_H_include_area
+
 #endif /* __TBB_concurrent_hash_map_H */
diff --git a/inst/include/tbb/concurrent_lru_cache.h b/inst/include/tbb/concurrent_lru_cache.h
index 8aacf241..a18dbf29 100644
--- a/inst/include/tbb/concurrent_lru_cache.h
+++ b/inst/include/tbb/concurrent_lru_cache.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,23 +12,27 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_concurrent_lru_cache_H
 #define __TBB_concurrent_lru_cache_H
 
+#define __TBB_concurrent_lru_cache_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #if ! TBB_PREVIEW_CONCURRENT_LRU_CACHE
     #error Set TBB_PREVIEW_CONCURRENT_LRU_CACHE to include concurrent_lru_cache.h
 #endif
 
+#include "tbb_stddef.h"
+
 #include <map>
 #include <list>
+#include <algorithm> // std::find
+#if __TBB_CPP11_RVALUE_REF_PRESENT
+#include <utility> // std::move
+#endif
 
-#include "tbb_stddef.h"
 #include "atomic.h"
 #include "internal/_aggregator_impl.h"
 
@@ -99,37 +103,84 @@ class concurrent_lru_cache : internal::no_assign{
     }
 
 private:
+#if !__TBB_CPP11_RVALUE_REF_PRESENT
     struct handle_move_t:no_assign{
         concurrent_lru_cache & my_cache_ref;
         typename map_storage_type::reference my_map_record_ref;
         handle_move_t(concurrent_lru_cache & cache_ref, typename map_storage_type::reference value_ref):my_cache_ref(cache_ref),my_map_record_ref(value_ref) {};
     };
+#endif
     class handle_object {
         concurrent_lru_cache * my_cache_pointer;
-        typename map_storage_type::reference my_map_record_ref;
+        typename map_storage_type::pointer my_map_record_ptr;
     public:
-        handle_object(concurrent_lru_cache & cache_ref, typename map_storage_type::reference value_ref):my_cache_pointer(&cache_ref), my_map_record_ref(value_ref) {}
-        handle_object(handle_move_t m):my_cache_pointer(&m.my_cache_ref), my_map_record_ref(m.my_map_record_ref){}
-        operator handle_move_t(){ return move(*this);}
+        handle_object() : my_cache_pointer(), my_map_record_ptr() {}
+        handle_object(concurrent_lru_cache& cache_ref, typename map_storage_type::reference value_ref) : my_cache_pointer(&cache_ref), my_map_record_ptr(&value_ref) {}
+        operator bool() const {
+            return (my_cache_pointer && my_map_record_ptr);
+        }
+#if __TBB_CPP11_RVALUE_REF_PRESENT
+        // TODO: add check for double moved objects by special dedicated field
+        handle_object(handle_object&& src) : my_cache_pointer(src.my_cache_pointer), my_map_record_ptr(src.my_map_record_ptr) {
+            __TBB_ASSERT((src.my_cache_pointer && src.my_map_record_ptr) || (!src.my_cache_pointer && !src.my_map_record_ptr), "invalid state of moving object?");
+            src.my_cache_pointer = NULL;
+            src.my_map_record_ptr = NULL;
+        }
+        handle_object& operator=(handle_object&& src) {
+            __TBB_ASSERT((src.my_cache_pointer && src.my_map_record_ptr) || (!src.my_cache_pointer && !src.my_map_record_ptr), "invalid state of moving object?");
+            if (my_cache_pointer) {
+                my_cache_pointer->signal_end_of_usage(*my_map_record_ptr);
+            }
+            my_cache_pointer = src.my_cache_pointer;
+            my_map_record_ptr = src.my_map_record_ptr;
+            src.my_cache_pointer = NULL;
+            src.my_map_record_ptr = NULL;
+            return *this;
+        }
+#else
+        handle_object(handle_move_t m) : my_cache_pointer(&m.my_cache_ref), my_map_record_ptr(&m.my_map_record_ref) {}
+        handle_object& operator=(handle_move_t m) {
+            if (my_cache_pointer) {
+                my_cache_pointer->signal_end_of_usage(*my_map_record_ptr);
+            }
+            my_cache_pointer = &m.my_cache_ref;
+            my_map_record_ptr = &m.my_map_record_ref;
+            return *this;
+        }
+        operator handle_move_t(){
+            return move(*this);
+        }
+#endif // __TBB_CPP11_RVALUE_REF_PRESENT
         value_type& value(){
-            __TBB_ASSERT(my_cache_pointer,"get value from moved from object?");
-            return my_map_record_ref.second.my_value;
+            __TBB_ASSERT(my_cache_pointer,"get value from already moved object?");
+            __TBB_ASSERT(my_map_record_ptr,"get value from an invalid or already moved object?");
+            return my_map_record_ptr->second.my_value;
         }
         ~handle_object(){
             if (my_cache_pointer){
-                my_cache_pointer->signal_end_of_usage(my_map_record_ref);
+                my_cache_pointer->signal_end_of_usage(*my_map_record_ptr);
             }
         }
     private:
+#if __TBB_CPP11_RVALUE_REF_PRESENT
+        // For source compatibility with C++03
+        friend handle_object&& move(handle_object& h){
+            return std::move(h);
+        }
+#else
         friend handle_move_t move(handle_object& h){
             return handle_object::move(h);
         }
+        // TODO: add check for double moved objects by special dedicated field
         static handle_move_t move(handle_object& h){
-            __TBB_ASSERT(h.my_cache_pointer,"move from the same object twice ?");
+            __TBB_ASSERT((h.my_cache_pointer && h.my_map_record_ptr) || (!h.my_cache_pointer && !h.my_map_record_ptr), "invalid state of moving object?");
             concurrent_lru_cache * cache_pointer = h.my_cache_pointer;
+            typename map_storage_type::pointer map_record_ptr = h.my_map_record_ptr;
             h.my_cache_pointer = NULL;
-            return handle_move_t(*cache_pointer,h.my_map_record_ref);
+            h.my_map_record_ptr = NULL;
+            return handle_move_t(*cache_pointer, *map_record_ptr);
         }
+#endif // __TBB_CPP11_RVALUE_REF_PRESENT
     private:
         void operator=(handle_object&);
 #if __SUNPRO_CC
@@ -232,4 +283,8 @@ class concurrent_lru_cache : internal::no_assign{
 using interface6::concurrent_lru_cache;
 
 } // namespace tbb
+
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_concurrent_lru_cache_H_include_area
+
 #endif //__TBB_concurrent_lru_cache_H
diff --git a/inst/include/tbb/concurrent_map.h b/inst/include/tbb/concurrent_map.h
new file mode 100644
index 00000000..32fbe684
--- /dev/null
+++ b/inst/include/tbb/concurrent_map.h
@@ -0,0 +1,389 @@
+/*
+    Copyright (c) 2019-2020 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.
+*/
+
+#ifndef __TBB_concurrent_map_H
+#define __TBB_concurrent_map_H
+
+#define __TBB_concurrent_map_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
+#if !TBB_PREVIEW_CONCURRENT_ORDERED_CONTAINERS
+#error Set TBB_PREVIEW_CONCURRENT_ORDERED_CONTAINERS to include concurrent_map.h
+#endif
+
+#include "tbb_config.h"
+
+// concurrent_map requires C++11 support
+#if __TBB_CONCURRENT_ORDERED_CONTAINERS_PRESENT
+
+#include "internal/_concurrent_skip_list_impl.h"
+
+namespace tbb {
+
+namespace interface10 {
+
+template<typename Key, typename Value, typename KeyCompare, typename RandomGenerator,
+         size_t MAX_LEVELS, typename Allocator, bool AllowMultimapping>
+class map_traits {
+public:
+    static constexpr size_t MAX_LEVEL = MAX_LEVELS;
+    using random_level_generator_type = RandomGenerator;
+    using key_type = Key;
+    using mapped_type = Value;
+    using compare_type = KeyCompare;
+    using value_type = std::pair<const key_type, mapped_type>;
+    using reference = value_type&;
+    using const_reference = const value_type&;
+    using allocator_type = Allocator;
+    using mutex_type = tbb::spin_mutex;
+    using node_type = tbb::internal::node_handle<key_type, value_type, internal::skip_list_node<value_type, mutex_type>, allocator_type>;
+
+    static const bool allow_multimapping = AllowMultimapping;
+
+    class value_compare {
+    public:
+        // TODO: these member types are deprecated in C++17, do we need to let them
+        using result_type = bool;
+        using first_argument_type = value_type;
+        using second_argument_type = value_type;
+
+        bool operator()(const value_type& lhs, const value_type& rhs) const {
+            return comp(lhs.first, rhs.first);
+        }
+
+    protected:
+        value_compare(compare_type c) : comp(c) {}
+
+        friend class map_traits;
+
+        compare_type comp;
+    };
+
+    static value_compare value_comp(compare_type comp) { return value_compare(comp); }
+
+    static const key_type& get_key(const_reference val) {
+        return val.first;
+    }
+}; // class map_traits
+
+template <typename Key, typename Value, typename Comp, typename Allocator>
+class concurrent_multimap;
+
+template <typename Key, typename Value, typename Comp = std::less<Key>, typename Allocator = tbb_allocator<std::pair<const Key, Value>>>
+class concurrent_map
+    : public internal::concurrent_skip_list<map_traits<Key, Value, Comp, internal::concurrent_geometric_level_generator<64>, 64, Allocator, false>> {
+    using traits_type = map_traits<Key, Value, Comp, internal::concurrent_geometric_level_generator<64>, 64, Allocator, false>;
+    using base_type = internal::concurrent_skip_list<traits_type>;
+#if __TBB_EXTRA_DEBUG
+public:
+#endif
+    using base_type::allow_multimapping;
+public:
+    using key_type = Key;
+    using mapped_type = Value;
+    using value_type = typename traits_type::value_type;
+    using size_type = typename base_type::size_type;
+    using difference_type = typename base_type::difference_type;
+    using key_compare = Comp;
+    using value_compare = typename base_type::value_compare;
+    using allocator_type = Allocator;
+
+    using reference = typename base_type::reference;
+    using const_reference = typename base_type::const_reference;
+    using pointer = typename base_type::pointer;
+    using const_pointer = typename base_type::pointer;
+
+    using iterator = typename base_type::iterator;
+    using const_iterator = typename base_type::const_iterator;
+    using reverse_iterator = typename base_type::reverse_iterator;
+    using const_reverse_iterator = typename base_type::const_reverse_iterator;
+
+    using node_type = typename base_type::node_type;
+
+    using base_type::end;
+    using base_type::find;
+    using base_type::emplace;
+    using base_type::insert;
+
+    concurrent_map() = default;
+
+    explicit concurrent_map(const key_compare& comp, const allocator_type& alloc = allocator_type()) : base_type(comp, alloc) {}
+
+    explicit concurrent_map(const allocator_type& alloc) : base_type(key_compare(), alloc) {}
+
+    template< class InputIt >
+    concurrent_map(InputIt first, InputIt last, const key_compare& comp = Comp(), const allocator_type& alloc = allocator_type())
+        : base_type(first, last, comp, alloc) {}
+
+    template< class InputIt >
+    concurrent_map(InputIt first, InputIt last, const allocator_type& alloc) : base_type(first, last, key_compare(), alloc) {}
+
+    /** Copy constructor */
+    concurrent_map(const concurrent_map&) = default;
+
+    concurrent_map(const concurrent_map& other, const allocator_type& alloc) : base_type(other, alloc) {}
+
+    concurrent_map(concurrent_map&&) = default;
+
+    concurrent_map(concurrent_map&& other, const allocator_type& alloc) : base_type(std::move(other), alloc) {}
+
+    concurrent_map(std::initializer_list<value_type> init, const key_compare& comp = Comp(), const allocator_type& alloc = allocator_type())
+        : base_type(comp, alloc) {
+        insert(init);
+    }
+
+    concurrent_map(std::initializer_list<value_type> init, const allocator_type& alloc)
+        : base_type(key_compare(), alloc) {
+        insert(init);
+    }
+
+    concurrent_map& operator=(const concurrent_map& other) {
+        return static_cast<concurrent_map&>(base_type::operator=(other));
+    }
+
+    concurrent_map& operator=(concurrent_map&& other) {
+        return static_cast<concurrent_map&>(base_type::operator=(std::move(other)));
+    }
+
+    mapped_type& at(const key_type& key) {
+        iterator it = find(key);
+
+        if (it == end()) {
+            tbb::internal::throw_exception(tbb::internal::eid_invalid_key);
+        }
+
+        return it->second;
+    }
+
+    const mapped_type& at(const key_type& key) const {
+        const_iterator it = find(key);
+
+        if (it == end()) {
+            tbb::internal::throw_exception(tbb::internal::eid_invalid_key);
+        }
+
+        return it->second;
+    }
+
+    mapped_type& operator[](const key_type& key) {
+        iterator it = find(key);
+
+        if (it == end()) {
+            it = emplace(std::piecewise_construct, std::forward_as_tuple(key), std::tuple<>()).first;
+        }
+
+        return it->second;
+    }
+
+    mapped_type& operator[](key_type&& key) {
+        iterator it = find(key);
+
+        if (it == end()) {
+            it = emplace(std::piecewise_construct, std::forward_as_tuple(std::move(key)), std::tuple<>()).first;
+        }
+
+        return it->second;
+    }
+
+    template<typename P, typename std::enable_if<std::is_constructible<value_type, P&&>::value>::type>
+    std::pair<iterator, bool> insert(P&& value) {
+        return emplace(std::forward<P>(value));
+    }
+
+    template<typename P, typename std::enable_if<std::is_constructible<value_type, P&&>::value>::type>
+    iterator insert(const_iterator hint, P&& value) {
+            return emplace_hint(hint, std::forward<P>(value));
+        return end();
+    }
+
+    template<typename C2>
+    void merge(concurrent_map<key_type, mapped_type, C2, Allocator>& source) {
+        this->internal_merge(source);
+    }
+
+    template<typename C2>
+    void merge(concurrent_map<key_type, mapped_type, C2, Allocator>&& source) {
+        this->internal_merge(std::move(source));
+    }
+
+    template<typename C2>
+    void merge(concurrent_multimap<key_type, mapped_type, C2, Allocator>& source) {
+        this->internal_merge(source);
+    }
+
+    template<typename C2>
+    void merge(concurrent_multimap<key_type, mapped_type, C2, Allocator>&& source) {
+        this->internal_merge(std::move(source));
+    }
+}; // class concurrent_map
+
+#if __TBB_CPP17_DEDUCTION_GUIDES_PRESENT
+
+namespace internal {
+
+using namespace tbb::internal;
+
+template<template<typename...> typename Map, typename Key, typename T, typename... Args>
+using c_map_t = Map<Key, T,
+                    std::conditional_t< (sizeof...(Args) > 0) && !is_allocator_v<pack_element_t<0, Args...> >,
+                                        pack_element_t<0, Args...>, std::less<Key> >,
+                    std::conditional_t< (sizeof...(Args) > 0) && is_allocator_v<pack_element_t<sizeof...(Args)-1, Args...> >,
+                                        pack_element_t<sizeof...(Args)-1, Args...>, tbb_allocator<std::pair<const Key, T> > > >;
+} // namespace internal
+
+template<typename It, typename... Args>
+concurrent_map(It, It, Args...)
+-> internal::c_map_t<concurrent_map, internal::iterator_key_t<It>, internal::iterator_mapped_t<It>, Args...>;
+
+template<typename Key, typename T, typename... Args>
+concurrent_map(std::initializer_list<std::pair<const Key, T>>, Args...)
+-> internal::c_map_t<concurrent_map, Key, T, Args...>;
+
+#endif // __TBB_CPP17_DEDUCTION_GUIDES_PRESENT
+
+template <typename Key, typename Value, typename Comp = std::less<Key>, typename Allocator = tbb_allocator<std::pair<const Key, Value>>>
+class concurrent_multimap
+    : public internal::concurrent_skip_list<map_traits<Key, Value, Comp, internal::concurrent_geometric_level_generator<64>, 64, Allocator, true>> {
+    using traits_type = map_traits<Key, Value, Comp, internal::concurrent_geometric_level_generator<64>, 64, Allocator, true>;
+    using base_type = internal::concurrent_skip_list<traits_type>;
+#if __TBB_EXTRA_DEBUG
+public:
+#endif
+    using base_type::allow_multimapping;
+public:
+    using key_type = Key;
+    using mapped_type = Value;
+    using value_type = typename traits_type::value_type;
+    using size_type = typename base_type::size_type;
+    using difference_type = typename base_type::difference_type;
+    using key_compare = Comp;
+    using value_compare = typename base_type::value_compare;
+    using allocator_type = Allocator;
+
+    using reference = typename base_type::reference;
+    using const_reference = typename base_type::const_reference;
+    using pointer = typename base_type::pointer;
+    using const_pointer = typename base_type::pointer;
+
+    using iterator = typename base_type::iterator;
+    using const_iterator = typename base_type::const_iterator;
+    using reverse_iterator = typename base_type::reverse_iterator;
+    using const_reverse_iterator = typename base_type::const_reverse_iterator;
+
+    using node_type = typename base_type::node_type;
+
+    using base_type::end;
+    using base_type::find;
+    using base_type::emplace;
+    using base_type::insert;
+
+    concurrent_multimap() = default;
+
+    explicit concurrent_multimap(const key_compare& comp, const allocator_type& alloc = allocator_type()) : base_type(comp, alloc) {}
+
+    explicit concurrent_multimap(const allocator_type& alloc) : base_type(key_compare(), alloc) {}
+
+    template< class InputIt >
+    concurrent_multimap(InputIt first, InputIt last, const key_compare& comp = Comp(), const allocator_type& alloc = allocator_type())
+        : base_type(first, last, comp, alloc) {}
+
+    template< class InputIt >
+    concurrent_multimap(InputIt first, InputIt last, const allocator_type& alloc) : base_type(first, last, key_compare(), alloc) {}
+
+    /** Copy constructor */
+    concurrent_multimap(const concurrent_multimap&) = default;
+
+    concurrent_multimap(const concurrent_multimap& other, const allocator_type& alloc) : base_type(other, alloc) {}
+
+    concurrent_multimap(concurrent_multimap&&) = default;
+
+    concurrent_multimap(concurrent_multimap&& other, const allocator_type& alloc) : base_type(std::move(other), alloc) {}
+
+    concurrent_multimap(std::initializer_list<value_type> init, const key_compare& comp = Comp(), const allocator_type& alloc = allocator_type())
+        : base_type(comp, alloc) {
+        insert(init);
+    }
+
+    concurrent_multimap(std::initializer_list<value_type> init, const allocator_type& alloc)
+        : base_type(key_compare(), alloc) {
+        insert(init);
+    }
+
+    concurrent_multimap& operator=(const concurrent_multimap& other) {
+        return static_cast<concurrent_multimap&>(base_type::operator=(other));
+    }
+
+    concurrent_multimap& operator=(concurrent_multimap&& other) {
+        return static_cast<concurrent_multimap&>(base_type::operator=(std::move(other)));
+    }
+
+    template<typename P, typename std::enable_if<std::is_constructible<value_type, P&&>::value>::type>
+    std::pair<iterator, bool> insert(P&& value) {
+        return emplace(std::forward<P>(value));
+    }
+
+    template<typename P, typename std::enable_if<std::is_constructible<value_type, P&&>::value>::type>
+    iterator insert(const_iterator hint, P&& value) {
+            return emplace_hint(hint, std::forward<P>(value));
+        return end();
+    }
+
+    template<typename C2>
+    void merge(concurrent_multimap<key_type, mapped_type, C2, Allocator>& source) {
+        this->internal_merge(source);
+    }
+
+    template<typename C2>
+    void merge(concurrent_multimap<key_type, mapped_type, C2, Allocator>&& source) {
+        this->internal_merge(std::move(source));
+    }
+
+    template<typename C2>
+    void merge(concurrent_map<key_type, mapped_type, C2, Allocator>& source) {
+        this->internal_merge(source);
+    }
+
+    template<typename C2>
+    void merge(concurrent_map<key_type, mapped_type, C2, Allocator>&& source) {
+        this->internal_merge(std::move(source));
+    }
+
+}; // class concurrent_multimap
+
+#if __TBB_CPP17_DEDUCTION_GUIDES_PRESENT
+
+template<typename It, typename... Args>
+concurrent_multimap(It, It, Args...)
+-> internal::c_map_t<concurrent_multimap, internal::iterator_key_t<It>, internal::iterator_mapped_t<It>, Args...>;
+
+template<typename Key, typename T, typename... Args>
+concurrent_multimap(std::initializer_list<std::pair<const Key, T>>, Args...)
+-> internal::c_map_t<concurrent_multimap, Key, T, Args...>;
+
+#endif // __TBB_CPP17_DEDUCTION_GUIDES_PRESENT
+
+} // namespace interface10
+
+using interface10::concurrent_map;
+using interface10::concurrent_multimap;
+
+} // namespace tbb
+
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_concurrent_map_H_include_area
+
+#endif // __TBB_CONCURRENT_ORDERED_CONTAINERS_PRESENT
+#endif // __TBB_concurrent_map_H
diff --git a/inst/include/tbb/concurrent_priority_queue.h b/inst/include/tbb/concurrent_priority_queue.h
index 89297d85..9c70098b 100644
--- a/inst/include/tbb/concurrent_priority_queue.h
+++ b/inst/include/tbb/concurrent_priority_queue.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,21 +12,22 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_concurrent_priority_queue_H
 #define __TBB_concurrent_priority_queue_H
 
+#define __TBB_concurrent_priority_queue_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #include "atomic.h"
 #include "cache_aligned_allocator.h"
 #include "tbb_exception.h"
 #include "tbb_stddef.h"
 #include "tbb_profiling.h"
 #include "internal/_aggregator_impl.h"
+#include "internal/_template_helpers.h"
+#include "internal/_allocator_traits.h"
 #include <vector>
 #include <iterator>
 #include <functional>
@@ -85,14 +86,28 @@ class concurrent_priority_queue {
     typedef A allocator_type;
 
     //! Constructs a new concurrent_priority_queue with default capacity
-    explicit concurrent_priority_queue(const allocator_type& a = allocator_type()) : mark(0), my_size(0), data(a)
+    explicit concurrent_priority_queue(const allocator_type& a = allocator_type()) : mark(0), my_size(0), compare(), data(a)
+    {
+        my_aggregator.initialize_handler(my_functor_t(this));
+    }
+
+    //! Constructs a new concurrent_priority_queue with default capacity
+    explicit concurrent_priority_queue(const Compare& c, const allocator_type& a = allocator_type()) : mark(0), my_size(0), compare(c), data(a)
     {
         my_aggregator.initialize_handler(my_functor_t(this));
     }
 
     //! Constructs a new concurrent_priority_queue with init_sz capacity
     explicit concurrent_priority_queue(size_type init_capacity, const allocator_type& a = allocator_type()) :
-        mark(0), my_size(0), data(a)
+        mark(0), my_size(0), compare(), data(a)
+    {
+        data.reserve(init_capacity);
+        my_aggregator.initialize_handler(my_functor_t(this));
+    }
+
+    //! Constructs a new concurrent_priority_queue with init_sz capacity
+    explicit concurrent_priority_queue(size_type init_capacity, const Compare& c, const allocator_type& a = allocator_type()) :
+        mark(0), my_size(0), compare(c), data(a)
     {
         data.reserve(init_capacity);
         my_aggregator.initialize_handler(my_functor_t(this));
@@ -101,7 +116,17 @@ class concurrent_priority_queue {
     //! [begin,end) constructor
     template<typename InputIterator>
     concurrent_priority_queue(InputIterator begin, InputIterator end, const allocator_type& a = allocator_type()) :
-        mark(0), data(begin, end, a)
+        mark(0), compare(), data(begin, end, a)
+    {
+        my_aggregator.initialize_handler(my_functor_t(this));
+        heapify();
+        my_size = data.size();
+    }
+
+    //! [begin,end) constructor
+    template<typename InputIterator>
+    concurrent_priority_queue(InputIterator begin, InputIterator end, const Compare& c, const allocator_type& a = allocator_type()) :
+        mark(0), compare(c), data(begin, end, a)
     {
         my_aggregator.initialize_handler(my_functor_t(this));
         heapify();
@@ -111,7 +136,16 @@ class concurrent_priority_queue {
 #if __TBB_INITIALIZER_LISTS_PRESENT
     //! Constructor from std::initializer_list
     concurrent_priority_queue(std::initializer_list<T> init_list, const allocator_type &a = allocator_type()) :
-        mark(0),data(init_list.begin(), init_list.end(), a)
+        mark(0), compare(), data(init_list.begin(), init_list.end(), a)
+    {
+        my_aggregator.initialize_handler(my_functor_t(this));
+        heapify();
+        my_size = data.size();
+    }
+
+    //! Constructor from std::initializer_list
+    concurrent_priority_queue(std::initializer_list<T> init_list, const Compare& c, const allocator_type &a = allocator_type()) :
+        mark(0), compare(c), data(init_list.begin(), init_list.end(), a)
     {
         my_aggregator.initialize_handler(my_functor_t(this));
         heapify();
@@ -121,7 +155,7 @@ class concurrent_priority_queue {
 
     //! Copy constructor
     /** This operation is unsafe if there are pending concurrent operations on the src queue. */
-    explicit concurrent_priority_queue(const concurrent_priority_queue& src) : mark(src.mark),
+    concurrent_priority_queue(const concurrent_priority_queue& src) : mark(src.mark),
         my_size(src.my_size), data(src.data.begin(), src.data.end(), src.data.get_allocator())
     {
         my_aggregator.initialize_handler(my_functor_t(this));
@@ -481,10 +515,38 @@ class concurrent_priority_queue {
     }
 };
 
+#if __TBB_CPP17_DEDUCTION_GUIDES_PRESENT
+namespace internal {
+
+template<typename T, typename... Args>
+using priority_queue_t = concurrent_priority_queue<
+    T,
+    std::conditional_t< (sizeof...(Args)>0) && !is_allocator_v< pack_element_t<0, Args...> >,
+                        pack_element_t<0, Args...>, std::less<T> >,
+    std::conditional_t< (sizeof...(Args)>0) && is_allocator_v< pack_element_t<sizeof...(Args)-1, Args...> >,
+                         pack_element_t<sizeof...(Args)-1, Args...>, cache_aligned_allocator<T> >
+>;
+}
+
+// Deduction guide for the constructor from two iterators
+template<typename InputIterator,
+         typename T = typename std::iterator_traits<InputIterator>::value_type,
+         typename... Args
+> concurrent_priority_queue(InputIterator, InputIterator, Args...)
+-> internal::priority_queue_t<T, Args...>;
+
+template<typename T, typename CompareOrAllocalor>
+concurrent_priority_queue(std::initializer_list<T> init_list, CompareOrAllocalor)
+-> internal::priority_queue_t<T, CompareOrAllocalor>;
+
+#endif /* __TBB_CPP17_DEDUCTION_GUIDES_PRESENT */
 } // namespace interface5
 
 using interface5::concurrent_priority_queue;
 
 } // namespace tbb
 
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_concurrent_priority_queue_H_include_area
+
 #endif /* __TBB_concurrent_priority_queue_H */
diff --git a/inst/include/tbb/concurrent_queue.h b/inst/include/tbb/concurrent_queue.h
index 81db58a3..122f98e5 100644
--- a/inst/include/tbb/concurrent_queue.h
+++ b/inst/include/tbb/concurrent_queue.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,16 +12,16 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_concurrent_queue_H
 #define __TBB_concurrent_queue_H
 
+#define __TBB_concurrent_queue_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #include "internal/_concurrent_queue_impl.h"
+#include "internal/_allocator_traits.h"
 
 namespace tbb {
 
@@ -36,7 +36,7 @@ class concurrent_queue: public internal::concurrent_queue_base_v3<T> {
     template<typename Container, typename Value> friend class internal::concurrent_queue_iterator;
 
     //! Allocator type
-    typedef typename A::template rebind<char>::other page_allocator_type;
+    typedef typename tbb::internal::allocator_rebind<A, char>::type page_allocator_type;
     page_allocator_type my_allocator;
 
     //! Allocates a block of size n (bytes)
@@ -177,6 +177,15 @@ class concurrent_queue: public internal::concurrent_queue_base_v3<T> {
     const_iterator unsafe_end() const {return const_iterator();}
 } ;
 
+#if __TBB_CPP17_DEDUCTION_GUIDES_PRESENT
+// Deduction guide for the constructor from two iterators
+template<typename InputIterator,
+         typename T = typename std::iterator_traits<InputIterator>::value_type,
+         typename A = cache_aligned_allocator<T>
+> concurrent_queue(InputIterator, InputIterator, const A& = A())
+-> concurrent_queue<T, A>;
+#endif /* __TBB_CPP17_DEDUCTION_GUIDES_PRESENT */
+
 template<typename T, class A>
 concurrent_queue<T,A>::~concurrent_queue() {
     clear();
@@ -200,9 +209,9 @@ void concurrent_queue<T,A>::clear() {
 template<typename T, class A = cache_aligned_allocator<T> >
 class concurrent_bounded_queue: public internal::concurrent_queue_base_v8 {
     template<typename Container, typename Value> friend class internal::concurrent_queue_iterator;
+    typedef typename tbb::internal::allocator_rebind<A, char>::type page_allocator_type;
 
     //! Allocator type
-    typedef typename A::template rebind<char>::other page_allocator_type;
     page_allocator_type my_allocator;
 
     typedef typename concurrent_queue_base_v3::padded_page<T> padded_page;
@@ -439,6 +448,15 @@ class concurrent_bounded_queue: public internal::concurrent_queue_base_v8 {
 
 };
 
+#if __TBB_CPP17_DEDUCTION_GUIDES_PRESENT
+// guide for concurrent_bounded_queue(InputIterator, InputIterator, ...)
+template<typename InputIterator,
+         typename T = typename std::iterator_traits<InputIterator>::value_type,
+         typename A = cache_aligned_allocator<T>
+> concurrent_bounded_queue(InputIterator, InputIterator, const A& = A())
+-> concurrent_bounded_queue<T, A>;
+#endif /* __TBB_CPP17_DEDUCTION_GUIDES_PRESENT */
+
 template<typename T, class A>
 concurrent_bounded_queue<T,A>::~concurrent_bounded_queue() {
     clear();
@@ -455,4 +473,7 @@ using strict_ppl::concurrent_queue;
 
 } // namespace tbb
 
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_concurrent_queue_H_include_area
+
 #endif /* __TBB_concurrent_queue_H */
diff --git a/inst/include/tbb/concurrent_set.h b/inst/include/tbb/concurrent_set.h
new file mode 100644
index 00000000..ecb21624
--- /dev/null
+++ b/inst/include/tbb/concurrent_set.h
@@ -0,0 +1,304 @@
+/*
+    Copyright (c) 2019-2020 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.
+*/
+
+#ifndef __TBB_concurrent_set_H
+#define __TBB_concurrent_set_H
+
+#define __TBB_concurrent_set_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
+#if !TBB_PREVIEW_CONCURRENT_ORDERED_CONTAINERS
+#error Set TBB_PREVIEW_CONCURRENT_ORDERED_CONTAINERS to include concurrent_set.h
+#endif
+
+#include "tbb/tbb_config.h"
+
+// concurrent_set requires C++11 support
+#if __TBB_CONCURRENT_ORDERED_CONTAINERS_PRESENT
+
+#include "internal/_concurrent_skip_list_impl.h"
+
+namespace tbb {
+namespace interface10 {
+
+// TODO: test this class
+template<typename Key, typename KeyCompare, typename RandomGenerator, size_t MAX_LEVELS, typename Allocator, bool AllowMultimapping>
+class set_traits {
+public:
+    static constexpr size_t MAX_LEVEL = MAX_LEVELS;
+    using random_level_generator_type = RandomGenerator;
+    using key_type = Key;
+    using value_type = key_type;
+    using compare_type = KeyCompare;
+    using value_compare = compare_type;
+    using reference = value_type & ;
+    using const_reference = const value_type&;
+    using allocator_type = Allocator;
+    using mutex_type = tbb::spin_mutex;
+    using node_type = tbb::internal::node_handle<key_type, value_type, internal::skip_list_node<value_type, mutex_type>, allocator_type>;
+
+    static const bool allow_multimapping = AllowMultimapping;
+
+    static const key_type& get_key(const_reference val) {
+        return val;
+    }
+
+    static value_compare value_comp(compare_type comp) { return comp; }
+};
+
+template <typename Key, typename Comp, typename Allocator>
+class concurrent_multiset;
+
+template <typename Key, typename Comp = std::less<Key>, typename Allocator = tbb_allocator<Key>>
+class concurrent_set
+    : public internal::concurrent_skip_list<set_traits<Key, Comp, internal::concurrent_geometric_level_generator<64>, 64, Allocator, false>> {
+    using traits_type = set_traits<Key, Comp, internal::concurrent_geometric_level_generator<64>, 64, Allocator, false>;
+    using base_type = internal::concurrent_skip_list<traits_type>;
+#if __TBB_EXTRA_DEBUG
+public:
+#endif
+    using base_type::allow_multimapping;
+public:
+    using key_type = Key;
+    using value_type = typename traits_type::value_type;
+    using size_type = typename base_type::size_type;
+    using difference_type = typename base_type::difference_type;
+    using key_compare = Comp;
+    using value_compare = typename base_type::value_compare;
+    using allocator_type = Allocator;
+
+    using reference = typename base_type::reference;
+    using const_reference = typename base_type::const_reference;
+    using pointer = typename base_type::pointer;
+    using const_pointer = typename base_type::pointer;
+
+    using iterator = typename base_type::iterator;
+    using const_iterator = typename base_type::const_iterator;
+    using reverse_iterator = typename base_type::reverse_iterator;
+    using const_reverse_iterator = typename base_type::const_reverse_iterator;
+
+    using node_type = typename base_type::node_type;
+
+    using base_type::insert;
+
+    concurrent_set() = default;
+
+    explicit concurrent_set(const key_compare& comp, const allocator_type& alloc = allocator_type()) : base_type(comp, alloc) {}
+
+    explicit concurrent_set(const allocator_type& alloc) : base_type(key_compare(), alloc) {}
+
+    template< class InputIt >
+    concurrent_set(InputIt first, InputIt last, const key_compare& comp = Comp(), const allocator_type& alloc = allocator_type())
+        : base_type(first, last, comp, alloc) {}
+
+    template< class InputIt >
+    concurrent_set(InputIt first, InputIt last, const allocator_type& alloc) : base_type(first, last, key_compare(), alloc) {}
+
+    /** Copy constructor */
+    concurrent_set(const concurrent_set&) = default;
+
+    concurrent_set(const concurrent_set& other, const allocator_type& alloc) : base_type(other, alloc) {}
+
+    concurrent_set(concurrent_set&&) = default;
+
+    concurrent_set(concurrent_set&& other, const allocator_type& alloc) : base_type(std::move(other), alloc) {}
+
+    concurrent_set(std::initializer_list<value_type> init, const key_compare& comp = Comp(), const allocator_type& alloc = allocator_type())
+        : base_type(comp, alloc) {
+        insert(init);
+    }
+
+    concurrent_set(std::initializer_list<value_type> init, const allocator_type& alloc)
+        : base_type(key_compare(), alloc) {
+        insert(init);
+    }
+
+    concurrent_set& operator=(const concurrent_set& other) {
+        return static_cast<concurrent_set&>(base_type::operator=(other));
+    }
+
+    concurrent_set& operator=(concurrent_set&& other) {
+        return static_cast<concurrent_set&>(base_type::operator=(std::move(other)));
+    }
+
+    template<typename C2>
+    void merge(concurrent_set<key_type, C2, Allocator>& source) {
+        this->internal_merge(source);
+    }
+
+    template<typename C2>
+    void merge(concurrent_set<key_type, C2, Allocator>&& source) {
+        this->internal_merge(std::move(source));
+    }
+
+    template<typename C2>
+    void merge(concurrent_multiset<key_type, C2, Allocator>& source) {
+        this->internal_merge(source);
+    }
+
+    template<typename C2>
+    void merge(concurrent_multiset<key_type, C2, Allocator>&& source) {
+        this->internal_merge(std::move(source));
+    }
+}; // class concurrent_set
+
+#if __TBB_CPP17_DEDUCTION_GUIDES_PRESENT
+
+namespace internal {
+
+using namespace tbb::internal;
+
+template<template<typename...> typename Set, typename Key, typename... Args>
+using c_set_t = Set<Key,
+                    std::conditional_t< (sizeof...(Args) > 0) && !is_allocator_v<pack_element_t<0, Args...> >,
+                                        pack_element_t<0, Args...>, std::less<Key> >,
+                    std::conditional_t< (sizeof...(Args) > 0) && is_allocator_v<pack_element_t<sizeof...(Args)-1, Args...> >,
+                                        pack_element_t<sizeof...(Args)-1, Args...>, tbb_allocator<Key> > >;
+} // namespace internal
+
+template<typename It, typename... Args>
+concurrent_set(It, It, Args...)
+-> internal::c_set_t<concurrent_set, internal::iterator_value_t<It>, Args...>;
+
+template<typename Key, typename... Args>
+concurrent_set(std::initializer_list<Key>, Args...)
+-> internal::c_set_t<concurrent_set, Key, Args...>;
+
+#endif // __TBB_CPP17_DEDUCTION_GUIDES_PRESENT
+
+template <typename Key, typename Comp = std::less<Key>, typename Allocator = tbb_allocator<Key>>
+class concurrent_multiset
+    : public internal::concurrent_skip_list<set_traits<Key, Comp, internal::concurrent_geometric_level_generator<64>, 64, Allocator, true>> {
+    using traits_type = set_traits<Key, Comp, internal::concurrent_geometric_level_generator<64>, 64, Allocator, true>;
+    using base_type = internal::concurrent_skip_list<traits_type>;
+#if __TBB_EXTRA_DEBUG
+public:
+#endif
+    using base_type::allow_multimapping;
+public:
+    using key_type = Key;
+    using value_type = typename traits_type::value_type;
+    using size_type = typename base_type::size_type;
+    using difference_type = typename base_type::difference_type;
+    using key_compare = Comp;
+    using value_compare = typename base_type::value_compare;
+    using allocator_type = Allocator;
+
+    using reference = typename base_type::reference;
+    using const_reference = typename base_type::const_reference;
+    using pointer = typename base_type::pointer;
+    using const_pointer = typename base_type::pointer;
+
+    using iterator = typename base_type::iterator;
+    using const_iterator = typename base_type::const_iterator;
+    using reverse_iterator = typename base_type::reverse_iterator;
+    using const_reverse_iterator = typename base_type::const_reverse_iterator;
+
+    using node_type = typename base_type::node_type;
+
+    using base_type::insert;
+
+    concurrent_multiset() = default;
+
+    explicit concurrent_multiset(const key_compare& comp, const allocator_type& alloc = allocator_type()) : base_type(comp, alloc) {}
+
+    explicit concurrent_multiset(const allocator_type& alloc) : base_type(key_compare(), alloc) {}
+
+    template< class InputIt >
+    concurrent_multiset(InputIt first, InputIt last, const key_compare& comp = Comp(), const allocator_type& alloc = allocator_type())
+        : base_type(comp, alloc) {
+        insert(first, last);
+    }
+
+    template< class InputIt >
+    concurrent_multiset(InputIt first, InputIt last, const allocator_type& alloc) : base_type(key_compare(), alloc) {
+        insert(first, last);
+    }
+
+    /** Copy constructor */
+    concurrent_multiset(const concurrent_multiset&) = default;
+
+    concurrent_multiset(const concurrent_multiset& other, const allocator_type& alloc) : base_type(other, alloc) {}
+
+    concurrent_multiset(concurrent_multiset&&) = default;
+
+    concurrent_multiset(concurrent_multiset&& other, const allocator_type& alloc) : base_type(std::move(other), alloc) {}
+
+    concurrent_multiset(std::initializer_list<value_type> init, const key_compare& comp = Comp(), const allocator_type& alloc = allocator_type())
+        : base_type(comp, alloc) {
+        insert(init);
+    }
+
+    concurrent_multiset(std::initializer_list<value_type> init, const allocator_type& alloc)
+        : base_type(key_compare(), alloc) {
+        insert(init);
+    }
+
+    concurrent_multiset& operator=(const concurrent_multiset& other) {
+        return static_cast<concurrent_multiset&>(base_type::operator=(other));
+    }
+
+    concurrent_multiset& operator=(concurrent_multiset&& other) {
+        return static_cast<concurrent_multiset&>(base_type::operator=(std::move(other)));
+    }
+
+    template<typename C2>
+    void merge(concurrent_set<key_type, C2, Allocator>& source) {
+        this->internal_merge(source);
+    }
+
+    template<typename C2>
+    void merge(concurrent_set<key_type, C2, Allocator>&& source) {
+        this->internal_merge(std::move(source));
+    }
+
+    template<typename C2>
+    void merge(concurrent_multiset<key_type, C2, Allocator>& source) {
+        this->internal_merge(source);
+    }
+
+    template<typename C2>
+    void merge(concurrent_multiset<key_type, C2, Allocator>&& source) {
+        this->internal_merge(std::move(source));
+    }
+}; // class concurrent_multiset
+
+#if __TBB_CPP17_DEDUCTION_GUIDES_PRESENT
+
+
+template<typename It, typename... Args>
+concurrent_multiset(It, It, Args...)
+-> internal::c_set_t<concurrent_multiset, internal::iterator_value_t<It>, Args...>;
+
+template<typename Key, typename... Args>
+concurrent_multiset(std::initializer_list<Key>, Args...)
+-> internal::c_set_t<concurrent_multiset, Key, Args...>;
+
+#endif // __TBB_CPP17_DEDUCTION_GUIDES_PRESENT
+
+} // namespace interface10
+
+using interface10::concurrent_set;
+using interface10::concurrent_multiset;
+
+} // namespace tbb
+
+#endif // __TBB_CONCURRENT_ORDERED_CONTAINERS_PRESENT
+
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_concurrent_set_H_include_area
+
+#endif // __TBB_concurrent_set_H
diff --git a/inst/include/tbb/concurrent_unordered_map.h b/inst/include/tbb/concurrent_unordered_map.h
index c959a7ec..a9d8df8a 100644
--- a/inst/include/tbb/concurrent_unordered_map.h
+++ b/inst/include/tbb/concurrent_unordered_map.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 /* Container implementations in this header are based on PPL implementations
@@ -24,6 +20,9 @@
 #ifndef __TBB_concurrent_unordered_map_H
 #define __TBB_concurrent_unordered_map_H
 
+#define __TBB_concurrent_unordered_map_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #include "internal/_concurrent_unordered_impl.h"
 
 namespace tbb
@@ -39,7 +38,13 @@ class concurrent_unordered_map_traits
     typedef std::pair<const Key, T> value_type;
     typedef Key key_type;
     typedef Hash_compare hash_compare;
-    typedef typename Allocator::template rebind<value_type>::other allocator_type;
+    typedef typename tbb::internal::allocator_rebind<Allocator, value_type>::type allocator_type;
+#if __TBB_UNORDERED_NODE_HANDLE_PRESENT
+    typedef tbb::internal::node_handle<key_type, value_type,
+                                  typename internal::split_ordered_list<value_type, allocator_type>::node,
+                                  allocator_type> node_type;
+#endif // __TBB_UNORDERED_NODE_HANDLE_PRESENT
+
     enum { allow_multimapping = Allow_multimapping };
 
     concurrent_unordered_map_traits() : my_hash_compare() {}
@@ -53,6 +58,9 @@ class concurrent_unordered_map_traits
     hash_compare my_hash_compare; // the comparator predicate for keys
 };
 
+template<typename Key, typename T, typename Hasher, typename Key_equality, typename Allocator>
+class concurrent_unordered_multimap;
+
 template <typename Key, typename T, typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>,
          typename Allocator = tbb::tbb_allocator<std::pair<const Key, T> > >
 class concurrent_unordered_map :
@@ -93,12 +101,23 @@ class concurrent_unordered_map :
     typedef typename base_type::const_iterator const_iterator;
     typedef typename base_type::iterator local_iterator;
     typedef typename base_type::const_iterator const_local_iterator;
+#if __TBB_UNORDERED_NODE_HANDLE_PRESENT
+    typedef typename base_type::node_type node_type;
+#endif // __TBB_UNORDERED_NODE_HANDLE_PRESENT
 
     // Construction/destruction/copying
     explicit concurrent_unordered_map(size_type n_of_buckets = base_type::initial_bucket_number,
-        const hasher& _Hasher = hasher(), const key_equal& _Key_equality = key_equal(),
+        const hasher& a_hasher = hasher(), const key_equal& a_keyeq = key_equal(),
         const allocator_type& a = allocator_type())
-        : base_type(n_of_buckets, key_compare(_Hasher, _Key_equality), a)
+        : base_type(n_of_buckets, key_compare(a_hasher, a_keyeq), a)
+    {}
+
+    concurrent_unordered_map(size_type n_of_buckets, const allocator_type& a)
+        : base_type(n_of_buckets, key_compare(hasher(), key_equal()), a)
+    {}
+
+    concurrent_unordered_map(size_type n_of_buckets, const hasher& a_hasher, const allocator_type& a)
+        : base_type(n_of_buckets, key_compare(a_hasher, key_equal()), a)
     {}
 
     explicit concurrent_unordered_map(const Allocator& a) : base_type(base_type::initial_bucket_number, key_compare(), a)
@@ -106,9 +125,24 @@ class concurrent_unordered_map :
 
     template <typename Iterator>
     concurrent_unordered_map(Iterator first, Iterator last, size_type n_of_buckets = base_type::initial_bucket_number,
-        const hasher& _Hasher = hasher(), const key_equal& _Key_equality = key_equal(),
+        const hasher& a_hasher = hasher(), const key_equal& a_keyeq = key_equal(),
         const allocator_type& a = allocator_type())
-        : base_type(n_of_buckets, key_compare(_Hasher, _Key_equality), a)
+        : base_type(n_of_buckets, key_compare(a_hasher, a_keyeq), a)
+    {
+        insert(first, last);
+    }
+
+    template <typename Iterator>
+    concurrent_unordered_map(Iterator first, Iterator last, size_type n_of_buckets, const allocator_type& a)
+        : base_type(n_of_buckets, key_compare(hasher(), key_equal()), a)
+    {
+        insert(first, last);
+    }
+
+    template <typename Iterator>
+    concurrent_unordered_map(Iterator first, Iterator last, size_type n_of_buckets, const hasher& a_hasher,
+        const allocator_type& a)
+        : base_type(n_of_buckets, key_compare(a_hasher, key_equal()), a)
     {
         insert(first, last);
     }
@@ -116,16 +150,30 @@ class concurrent_unordered_map :
 #if __TBB_INITIALIZER_LISTS_PRESENT
     //! Constructor from initializer_list
     concurrent_unordered_map(std::initializer_list<value_type> il, size_type n_of_buckets = base_type::initial_bucket_number,
-        const hasher& _Hasher = hasher(), const key_equal& _Key_equality = key_equal(),
+        const hasher& a_hasher = hasher(), const key_equal& a_keyeq = key_equal(),
         const allocator_type& a = allocator_type())
-        : base_type(n_of_buckets, key_compare(_Hasher, _Key_equality), a)
+        : base_type(n_of_buckets, key_compare(a_hasher, a_keyeq), a)
+    {
+        insert(il.begin(),il.end());
+    }
+
+    concurrent_unordered_map(std::initializer_list<value_type> il, size_type n_of_buckets, const allocator_type& a)
+        : base_type(n_of_buckets, key_compare(hasher(), key_equal()), a)
+    {
+        insert(il.begin(), il.end());
+    }
+
+    concurrent_unordered_map(std::initializer_list<value_type> il, size_type n_of_buckets, const hasher& a_hasher,
+        const allocator_type& a)
+        : base_type(n_of_buckets, key_compare(a_hasher, key_equal()), a)
     {
-        this->insert(il.begin(),il.end());
+        insert(il.begin(), il.end());
     }
+
 #endif //# __TBB_INITIALIZER_LISTS_PRESENT
 
-#if __TBB_CPP11_RVALUE_REF_PRESENT
-#if !__TBB_IMPLICIT_MOVE_PRESENT
+
+#if __TBB_CPP11_RVALUE_REF_PRESENT && !__TBB_IMPLICIT_MOVE_PRESENT
     concurrent_unordered_map(const concurrent_unordered_map& table)
         : base_type(table)
     {}
@@ -143,11 +191,31 @@ class concurrent_unordered_map :
     {
         return static_cast<concurrent_unordered_map&>(base_type::operator=(std::move(table)));
     }
-#endif //!__TBB_IMPLICIT_MOVE_PRESENT
+#endif //__TBB_CPP11_RVALUE_REF_PRESENT && !__TBB_IMPLICIT_MOVE_PRESENT
 
+#if __TBB_CPP11_RVALUE_REF_PRESENT
     concurrent_unordered_map(concurrent_unordered_map&& table, const Allocator& a) : base_type(std::move(table), a)
     {}
-#endif //__TBB_CPP11_RVALUE_REF_PRESENT
+#endif /*__TBB_CPP11_RVALUE_REF_PRESENT*/
+
+#if __TBB_UNORDERED_NODE_HANDLE_PRESENT
+    template<typename Hash, typename Equality>
+    void merge(concurrent_unordered_map<Key, T, Hash, Equality, Allocator>& source)
+              { this->internal_merge(source); }
+
+    template<typename Hash, typename Equality>
+    void merge(concurrent_unordered_map<Key, T, Hash, Equality, Allocator>&& source)
+              { this->internal_merge(source); }
+
+    template<typename Hash, typename Equality>
+    void merge(concurrent_unordered_multimap<Key, T, Hash, Equality, Allocator>& source)
+              { this->internal_merge(source); }
+
+    template<typename Hash, typename Equality>
+    void merge(concurrent_unordered_multimap<Key, T, Hash, Equality, Allocator>&& source)
+              { this->internal_merge(source); }
+
+#endif //__TBB_UNORDERED_NODE_HANDLE_PRESENT
 
     concurrent_unordered_map(const concurrent_unordered_map& table, const Allocator& a)
         : base_type(table, a)
@@ -191,6 +259,45 @@ class concurrent_unordered_map :
     }
 };
 
+#if __TBB_CPP17_DEDUCTION_GUIDES_PRESENT
+
+namespace internal {
+using namespace tbb::internal;
+
+template<template<typename...> typename Map, typename Key, typename Element, typename... Args>
+using cu_map_t = Map<
+    Key, Element,
+    std::conditional_t< (sizeof...(Args)>0) && !is_allocator_v< pack_element_t<0, Args...> >,
+                        pack_element_t<0, Args...>, tbb_hash<Key> >,
+    std::conditional_t< (sizeof...(Args)>1) && !is_allocator_v< pack_element_t<1, Args...> >,
+                        pack_element_t<1, Args...>, std::equal_to<Key> >,
+    std::conditional_t< (sizeof...(Args)>0) && is_allocator_v< pack_element_t<sizeof...(Args)-1, Args...> >,
+                        pack_element_t<sizeof...(Args)-1, Args...>, tbb_allocator<std::pair<const Key, Element> > >
+>;
+}
+
+// Deduction guide for the constructor from two iterators
+template<typename I>
+concurrent_unordered_map (I, I)
+-> internal::cu_map_t<concurrent_unordered_map, internal::iterator_key_t<I>, internal::iterator_mapped_t<I>>;
+
+// Deduction guide for the constructor from two iterators and hasher/equality/allocator
+template<typename I, typename... Args>
+concurrent_unordered_map(I, I, size_t, Args...)
+-> internal::cu_map_t<concurrent_unordered_map, internal::iterator_key_t<I>, internal::iterator_mapped_t<I>, Args...>;
+
+// Deduction guide for the constructor from an initializer_list
+template<typename Key, typename Element>
+concurrent_unordered_map(std::initializer_list<std::pair<const Key, Element>>)
+-> internal::cu_map_t<concurrent_unordered_map, Key, Element>;
+
+// Deduction guide for the constructor from an initializer_list and hasher/equality/allocator
+template<typename Key, typename Element, typename... Args>
+concurrent_unordered_map(std::initializer_list<std::pair<const Key, Element>>, size_t, Args...)
+-> internal::cu_map_t<concurrent_unordered_map, Key, Element, Args...>;
+
+#endif /* __TBB_CPP17_DEDUCTION_GUIDES_PRESENT */
+
 template < typename Key, typename T, typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>,
         typename Allocator = tbb::tbb_allocator<std::pair<const Key, T> > >
 class concurrent_unordered_multimap :
@@ -229,12 +336,23 @@ class concurrent_unordered_multimap :
     typedef typename base_type::const_iterator const_iterator;
     typedef typename base_type::iterator local_iterator;
     typedef typename base_type::const_iterator const_local_iterator;
+#if __TBB_UNORDERED_NODE_HANDLE_PRESENT
+    typedef typename base_type::node_type node_type;
+#endif //__TBB_UNORDERED_NODE_HANDLE_PRESENT
 
     // Construction/destruction/copying
     explicit concurrent_unordered_multimap(size_type n_of_buckets = base_type::initial_bucket_number,
-        const hasher& _Hasher = hasher(), const key_equal& _Key_equality = key_equal(),
+        const hasher& a_hasher = hasher(), const key_equal& a_keyeq = key_equal(),
         const allocator_type& a = allocator_type())
-        : base_type(n_of_buckets, key_compare(_Hasher, _Key_equality), a)
+        : base_type(n_of_buckets, key_compare(a_hasher, a_keyeq), a)
+    {}
+
+    concurrent_unordered_multimap(size_type n_of_buckets, const allocator_type& a)
+        : base_type(n_of_buckets, key_compare(hasher(), key_equal()), a)
+    {}
+
+    concurrent_unordered_multimap(size_type n_of_buckets, const hasher& a_hasher, const allocator_type& a)
+        : base_type(n_of_buckets, key_compare(a_hasher, key_equal()), a)
     {}
 
     explicit concurrent_unordered_multimap(const Allocator& a) : base_type(base_type::initial_bucket_number, key_compare(), a)
@@ -242,9 +360,24 @@ class concurrent_unordered_multimap :
 
     template <typename Iterator>
     concurrent_unordered_multimap(Iterator first, Iterator last, size_type n_of_buckets = base_type::initial_bucket_number,
-        const hasher& _Hasher = hasher(), const key_equal& _Key_equality = key_equal(),
+        const hasher& a_hasher = hasher(), const key_equal& a_keyeq = key_equal(),
         const allocator_type& a = allocator_type())
-        : base_type(n_of_buckets,key_compare(_Hasher,_Key_equality), a)
+        : base_type(n_of_buckets,key_compare(a_hasher,a_keyeq), a)
+    {
+        insert(first, last);
+    }
+
+    template <typename Iterator>
+    concurrent_unordered_multimap(Iterator first, Iterator last, size_type n_of_buckets, const allocator_type& a)
+        : base_type(n_of_buckets, key_compare(hasher(), key_equal()), a)
+    {
+        insert(first, last);
+    }
+
+    template <typename Iterator>
+    concurrent_unordered_multimap(Iterator first, Iterator last, size_type n_of_buckets, const hasher& a_hasher,
+        const allocator_type& a)
+        : base_type(n_of_buckets, key_compare(a_hasher, key_equal()), a)
     {
         insert(first, last);
     }
@@ -252,16 +385,29 @@ class concurrent_unordered_multimap :
 #if __TBB_INITIALIZER_LISTS_PRESENT
     //! Constructor from initializer_list
     concurrent_unordered_multimap(std::initializer_list<value_type> il, size_type n_of_buckets = base_type::initial_bucket_number,
-        const hasher& _Hasher = hasher(), const key_equal& _Key_equality = key_equal(),
+        const hasher& a_hasher = hasher(), const key_equal& a_keyeq = key_equal(),
         const allocator_type& a = allocator_type())
-        : base_type(n_of_buckets, key_compare(_Hasher, _Key_equality), a)
+        : base_type(n_of_buckets, key_compare(a_hasher, a_keyeq), a)
+    {
+        insert(il.begin(),il.end());
+    }
+
+    concurrent_unordered_multimap(std::initializer_list<value_type> il, size_type n_of_buckets, const allocator_type& a)
+        : base_type(n_of_buckets, key_compare(hasher(), key_equal()), a)
     {
-        this->insert(il.begin(),il.end());
+        insert(il.begin(), il.end());
     }
+
+    concurrent_unordered_multimap(std::initializer_list<value_type> il, size_type n_of_buckets, const hasher& a_hasher,
+        const allocator_type& a)
+        : base_type(n_of_buckets, key_compare(a_hasher, key_equal()), a)
+    {
+        insert(il.begin(), il.end());
+    }
+
 #endif //# __TBB_INITIALIZER_LISTS_PRESENT
 
-#if __TBB_CPP11_RVALUE_REF_PRESENT
-#if !__TBB_IMPLICIT_MOVE_PRESENT
+#if __TBB_CPP11_RVALUE_REF_PRESENT && !__TBB_IMPLICIT_MOVE_PRESENT
     concurrent_unordered_multimap(const concurrent_unordered_multimap& table)
         : base_type(table)
     {}
@@ -279,16 +425,60 @@ class concurrent_unordered_multimap :
     {
         return static_cast<concurrent_unordered_multimap&>(base_type::operator=(std::move(table)));
     }
-#endif //!__TBB_IMPLICIT_MOVE_PRESENT
+#endif //__TBB_CPP11_RVALUE_REF_PRESENT && !__TBB_IMPLICIT_MOVE_PRESENT
 
+#if __TBB_CPP11_RVALUE_REF_PRESENT
     concurrent_unordered_multimap(concurrent_unordered_multimap&& table, const Allocator& a) : base_type(std::move(table), a)
     {}
-#endif //__TBB_CPP11_RVALUE_REF_PRESENT
+#endif /*__TBB_CPP11_RVALUE_REF_PRESENT*/
+
+#if __TBB_UNORDERED_NODE_HANDLE_PRESENT
+    template<typename Hash, typename Equality>
+    void merge(concurrent_unordered_map<Key, T, Hash, Equality, Allocator>& source)
+              { this->internal_merge(source); }
+
+    template<typename Hash, typename Equality>
+    void merge(concurrent_unordered_map<Key, T, Hash, Equality, Allocator>&& source)
+              { this->internal_merge(source); }
+
+    template<typename Hash, typename Equality>
+    void merge(concurrent_unordered_multimap<Key, T, Hash, Equality, Allocator>& source)
+              { this->internal_merge(source); }
+
+    template<typename Hash, typename Equality>
+    void merge(concurrent_unordered_multimap<Key, T, Hash, Equality, Allocator>&& source)
+              { this->internal_merge(source); }
+
+#endif //__TBB_UNORDERED_NODE_HANDLE_PRESENT
 
     concurrent_unordered_multimap(const concurrent_unordered_multimap& table, const Allocator& a)
         : base_type(table, a)
     {}
 };
+
+#if __TBB_CPP17_DEDUCTION_GUIDES_PRESENT
+
+// Deduction guide for the constructor from two iterators
+template<typename I>
+concurrent_unordered_multimap (I, I)
+-> internal::cu_map_t<concurrent_unordered_multimap, internal::iterator_key_t<I>, internal::iterator_mapped_t<I>>;
+
+// Deduction guide for the constructor from two iterators and hasher/equality/allocator
+template<typename I, typename... Args>
+concurrent_unordered_multimap(I, I, size_t, Args...)
+-> internal::cu_map_t<concurrent_unordered_multimap, internal::iterator_key_t<I>, internal::iterator_mapped_t<I>, Args...>;
+
+// Deduction guide for the constructor from an initializer_list
+template<typename Key, typename Element>
+concurrent_unordered_multimap(std::initializer_list<std::pair<const Key, Element>>)
+-> internal::cu_map_t<concurrent_unordered_multimap, Key, Element>;
+
+// Deduction guide for the constructor from an initializer_list and hasher/equality/allocator
+template<typename Key, typename Element, typename... Args>
+concurrent_unordered_multimap(std::initializer_list<std::pair<const Key, Element>>, size_t, Args...)
+-> internal::cu_map_t<concurrent_unordered_multimap, Key, Element, Args...>;
+
+#endif /* __TBB_CPP17_DEDUCTION_GUIDES_PRESENT */
 } // namespace interface5
 
 using interface5::concurrent_unordered_map;
@@ -296,4 +486,7 @@ using interface5::concurrent_unordered_multimap;
 
 } // namespace tbb
 
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_concurrent_unordered_map_H_include_area
+
 #endif// __TBB_concurrent_unordered_map_H
diff --git a/inst/include/tbb/concurrent_unordered_set.h b/inst/include/tbb/concurrent_unordered_set.h
index a26fee1a..edb02565 100644
--- a/inst/include/tbb/concurrent_unordered_set.h
+++ b/inst/include/tbb/concurrent_unordered_set.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 /* Container implementations in this header are based on PPL implementations
@@ -24,6 +20,9 @@
 #ifndef __TBB_concurrent_unordered_set_H
 #define __TBB_concurrent_unordered_set_H
 
+#define __TBB_concurrent_unordered_set_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #include "internal/_concurrent_unordered_impl.h"
 
 namespace tbb
@@ -39,7 +38,13 @@ class concurrent_unordered_set_traits
     typedef Key value_type;
     typedef Key key_type;
     typedef Hash_compare hash_compare;
-    typedef typename Allocator::template rebind<value_type>::other allocator_type;
+    typedef typename tbb::internal::allocator_rebind<Allocator, value_type>::type allocator_type;
+#if __TBB_UNORDERED_NODE_HANDLE_PRESENT
+    typedef tbb::internal::node_handle<key_type, key_type,
+                                  typename internal::split_ordered_list<key_type, allocator_type>::node,
+                                  allocator_type> node_type;
+#endif // __TBB_UNORDERED_NODE_HANDLE_PRESENT
+
     enum { allow_multimapping = Allow_multimapping };
 
     concurrent_unordered_set_traits() : my_hash_compare() {}
@@ -52,6 +57,9 @@ class concurrent_unordered_set_traits
     hash_compare my_hash_compare; // the comparator predicate for keys
 };
 
+template<typename Key, typename Hasher, typename Key_equality, typename Allocator>
+class concurrent_unordered_multiset;
+
 template <typename Key, typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<Key> >
 class concurrent_unordered_set : public internal::concurrent_unordered_base< concurrent_unordered_set_traits<Key, internal::hash_compare<Key, Hasher, Key_equality>, Allocator, false> >
 {
@@ -87,6 +95,9 @@ class concurrent_unordered_set : public internal::concurrent_unordered_base< con
     typedef typename base_type::const_iterator const_iterator;
     typedef typename base_type::iterator local_iterator;
     typedef typename base_type::const_iterator const_local_iterator;
+#if __TBB_UNORDERED_NODE_HANDLE_PRESENT
+    typedef typename base_type::node_type node_type;
+#endif /*__TBB_UNORDERED_NODE_HANDLE_PRESENT*/
 
     // Construction/destruction/copying
     explicit concurrent_unordered_set(size_type n_of_buckets = base_type::initial_bucket_number, const hasher& a_hasher = hasher(),
@@ -94,29 +105,63 @@ class concurrent_unordered_set : public internal::concurrent_unordered_base< con
         : base_type(n_of_buckets, key_compare(a_hasher, a_keyeq), a)
     {}
 
+    concurrent_unordered_set(size_type n_of_buckets, const allocator_type& a)
+        : base_type(n_of_buckets, key_compare(hasher(), key_equal()), a)
+    {}
+
+    concurrent_unordered_set(size_type n_of_buckets, const hasher& a_hasher, const allocator_type& a)
+        : base_type(n_of_buckets, key_compare(a_hasher, key_equal()), a)
+    {}
+
     explicit concurrent_unordered_set(const Allocator& a) : base_type(base_type::initial_bucket_number, key_compare(), a)
     {}
 
     template <typename Iterator>
-    concurrent_unordered_set(Iterator first, Iterator last, size_type n_of_buckets = base_type::initial_bucket_number, const hasher& a_hasher = hasher(),
-        const key_equal& a_keyeq = key_equal(), const allocator_type& a = allocator_type())
+    concurrent_unordered_set(Iterator first, Iterator last, size_type n_of_buckets = base_type::initial_bucket_number,
+        const hasher& a_hasher = hasher(), const key_equal& a_keyeq = key_equal(), const allocator_type& a = allocator_type())
         : base_type(n_of_buckets, key_compare(a_hasher, a_keyeq), a)
     {
         insert(first, last);
     }
 
+    template <typename Iterator>
+    concurrent_unordered_set(Iterator first, Iterator last, size_type n_of_buckets, const allocator_type& a)
+        : base_type(n_of_buckets, key_compare(hasher(), key_equal()), a)
+    {
+        insert(first, last);
+    }
+
+    template <typename Iterator>
+    concurrent_unordered_set(Iterator first, Iterator last, size_type n_of_buckets, const hasher& a_hasher, const allocator_type& a)
+        : base_type(n_of_buckets, key_compare(a_hasher, key_equal()), a)
+    {
+        insert(first, last);
+    }
+
 #if __TBB_INITIALIZER_LISTS_PRESENT
     //! Constructor from initializer_list
     concurrent_unordered_set(std::initializer_list<value_type> il, size_type n_of_buckets = base_type::initial_bucket_number, const hasher& a_hasher = hasher(),
         const key_equal& a_keyeq = key_equal(), const allocator_type& a = allocator_type())
         : base_type(n_of_buckets, key_compare(a_hasher, a_keyeq), a)
     {
-        this->insert(il.begin(),il.end());
+        insert(il.begin(),il.end());
+    }
+
+    concurrent_unordered_set(std::initializer_list<value_type> il, size_type n_of_buckets, const allocator_type& a)
+        : base_type(n_of_buckets, key_compare(hasher(), key_equal()), a)
+    {
+        insert(il.begin(), il.end());
     }
+
+    concurrent_unordered_set(std::initializer_list<value_type> il, size_type n_of_buckets, const hasher& a_hasher, const allocator_type& a)
+        : base_type(n_of_buckets, key_compare(a_hasher, key_equal()), a)
+    {
+        insert(il.begin(), il.end());
+    }
+
 #endif //# __TBB_INITIALIZER_LISTS_PRESENT
 
-#if __TBB_CPP11_RVALUE_REF_PRESENT
-#if !__TBB_IMPLICIT_MOVE_PRESENT
+#if __TBB_CPP11_RVALUE_REF_PRESENT && !__TBB_IMPLICIT_MOVE_PRESENT
     concurrent_unordered_set(const concurrent_unordered_set& table)
         : base_type(table)
     {}
@@ -134,12 +179,32 @@ class concurrent_unordered_set : public internal::concurrent_unordered_base< con
     {
         return static_cast<concurrent_unordered_set&>(base_type::operator=(std::move(table)));
     }
-#endif //!__TBB_IMPLICIT_MOVE_PRESENT
+#endif //__TBB_CPP11_RVALUE_REF_PRESENT && !__TBB_IMPLICIT_MOVE_PRESENT
 
+#if __TBB_CPP11_RVALUE_REF_PRESENT
     concurrent_unordered_set(concurrent_unordered_set&& table, const Allocator& a)
         : base_type(std::move(table), a)
     {}
-#endif //__TBB_CPP11_RVALUE_REF_PRESENT
+#endif /*__TBB_CPP11_RVALUE_REF_PRESENT*/
+
+#if __TBB_UNORDERED_NODE_HANDLE_PRESENT
+    template<typename Hash, typename Equality>
+    void merge(concurrent_unordered_set<Key, Hash, Equality, Allocator>& source)
+              { this->internal_merge(source); }
+
+    template<typename Hash, typename Equality>
+    void merge(concurrent_unordered_set<Key, Hash, Equality, Allocator>&& source)
+              { this->internal_merge(source); }
+
+    template<typename Hash, typename Equality>
+    void merge(concurrent_unordered_multiset<Key, Hash, Equality, Allocator>& source)
+              { this->internal_merge(source); }
+
+    template<typename Hash, typename Equality>
+    void merge(concurrent_unordered_multiset<Key, Hash, Equality, Allocator>&& source)
+              { this->internal_merge(source); }
+
+#endif //__TBB_UNORDERED_NODE_HANDLE_PRESENT
 
     concurrent_unordered_set(const concurrent_unordered_set& table, const Allocator& a)
         : base_type(table, a)
@@ -147,6 +212,45 @@ class concurrent_unordered_set : public internal::concurrent_unordered_base< con
 
 };
 
+#if __TBB_CPP17_DEDUCTION_GUIDES_PRESENT
+
+namespace internal {
+using namespace tbb::internal;
+
+template <template<typename...> typename Set, typename T, typename... Args>
+using cu_set_t = Set <
+    T,
+    std::conditional_t< (sizeof...(Args)>0) && !is_allocator_v< pack_element_t<0, Args...> >,
+                        pack_element_t<0, Args...>, tbb_hash<T> >,
+    std::conditional_t< (sizeof...(Args)>1) && !is_allocator_v< pack_element_t<1, Args...> >,
+                        pack_element_t<1, Args...>, std::equal_to<T> >,
+    std::conditional_t< (sizeof...(Args)>0) && is_allocator_v< pack_element_t<sizeof...(Args)-1, Args...> >,
+                        pack_element_t<sizeof...(Args)-1, Args...>, tbb_allocator<T> >
+>;
+}
+
+// Deduction guide for the constructor from two iterators
+template<typename I>
+concurrent_unordered_set(I, I)
+-> internal::cu_set_t<concurrent_unordered_set, internal::iterator_value_t<I>>;
+
+// Deduction guide for the constructor from two iterators and hasher/equality/allocator
+template<typename I, typename... Args>
+concurrent_unordered_set(I, I, size_t, Args...)
+-> internal::cu_set_t<concurrent_unordered_set, internal::iterator_value_t<I>, Args...>;
+
+// Deduction guide for the constructor from an initializer_list
+template<typename T>
+concurrent_unordered_set(std::initializer_list<T>)
+-> internal::cu_set_t<concurrent_unordered_set, T>;
+
+// Deduction guide for the constructor from an initializer_list and hasher/equality/allocator
+template<typename T, typename... Args>
+concurrent_unordered_set(std::initializer_list<T>, size_t, Args...)
+-> internal::cu_set_t<concurrent_unordered_set, T, Args...>;
+
+#endif /*__TBB_CPP17_DEDUCTION_GUIDES_PRESENT */
+
 template <typename Key, typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>,
          typename Allocator = tbb::tbb_allocator<Key> >
 class concurrent_unordered_multiset :
@@ -185,12 +289,24 @@ class concurrent_unordered_multiset :
     typedef typename base_type::const_iterator const_iterator;
     typedef typename base_type::iterator local_iterator;
     typedef typename base_type::const_iterator const_local_iterator;
+#if __TBB_UNORDERED_NODE_HANDLE_PRESENT
+    typedef typename base_type::node_type node_type;
+#endif // __TBB_UNORDERED_NODE_HANDLE_PRESENT
 
     // Construction/destruction/copying
     explicit concurrent_unordered_multiset(size_type n_of_buckets = base_type::initial_bucket_number,
-        const hasher& _Hasher = hasher(), const key_equal& _Key_equality = key_equal(),
+        const hasher& a_hasher = hasher(), const key_equal& a_keyeq = key_equal(),
         const allocator_type& a = allocator_type())
-        : base_type(n_of_buckets, key_compare(_Hasher, _Key_equality), a)
+        : base_type(n_of_buckets, key_compare(a_hasher, a_keyeq), a)
+    {}
+
+    concurrent_unordered_multiset(size_type n_of_buckets, const allocator_type& a)
+        : base_type(n_of_buckets, key_compare(hasher(), key_equal()), a)
+    {}
+
+    concurrent_unordered_multiset(size_type n_of_buckets, const hasher& a_hasher,
+        const allocator_type& a)
+        : base_type(n_of_buckets, key_compare(a_hasher, key_equal()), a)
     {}
 
     explicit concurrent_unordered_multiset(const Allocator& a) : base_type(base_type::initial_bucket_number, key_compare(), a)
@@ -198,25 +314,54 @@ class concurrent_unordered_multiset :
 
     template <typename Iterator>
     concurrent_unordered_multiset(Iterator first, Iterator last, size_type n_of_buckets = base_type::initial_bucket_number,
-        const hasher& _Hasher = hasher(), const key_equal& _Key_equality = key_equal(),
+        const hasher& a_hasher = hasher(), const key_equal& a_keyeq = key_equal(),
         const allocator_type& a = allocator_type())
-        : base_type(n_of_buckets, key_compare(_Hasher, _Key_equality), a)
+        : base_type(n_of_buckets, key_compare(a_hasher, a_keyeq), a)
+    {
+        insert(first, last);
+    }
+
+    template <typename Iterator>
+    concurrent_unordered_multiset(Iterator first, Iterator last, size_type n_of_buckets, const allocator_type& a)
+        : base_type(n_of_buckets, key_compare(hasher(), key_equal()), a)
+    {
+        insert(first, last);
+    }
+
+    template <typename Iterator>
+    concurrent_unordered_multiset(Iterator first, Iterator last, size_type n_of_buckets, const hasher& a_hasher,
+        const allocator_type& a)
+        : base_type(n_of_buckets, key_compare(a_hasher, key_equal()), a)
     {
         insert(first, last);
     }
 
 #if __TBB_INITIALIZER_LISTS_PRESENT
     //! Constructor from initializer_list
-    concurrent_unordered_multiset(std::initializer_list<value_type> il, size_type n_of_buckets = base_type::initial_bucket_number, const hasher& a_hasher = hasher(),
-        const key_equal& a_keyeq = key_equal(), const allocator_type& a = allocator_type())
+    concurrent_unordered_multiset(std::initializer_list<value_type> il, size_type n_of_buckets = base_type::initial_bucket_number,
+        const hasher& a_hasher = hasher(), const key_equal& a_keyeq = key_equal(), const allocator_type& a = allocator_type())
         : base_type(n_of_buckets, key_compare(a_hasher, a_keyeq), a)
     {
-        this->insert(il.begin(),il.end());
+        insert(il.begin(),il.end());
+    }
+
+    concurrent_unordered_multiset(std::initializer_list<value_type> il, size_type n_of_buckets, const allocator_type& a)
+        : base_type(n_of_buckets, key_compare(hasher(), key_equal()), a)
+    {
+        insert(il.begin(), il.end());
     }
+
+    concurrent_unordered_multiset(std::initializer_list<value_type> il, size_type n_of_buckets, const hasher& a_hasher,
+        const allocator_type& a)
+        : base_type(n_of_buckets, key_compare(a_hasher, key_equal()), a)
+    {
+        insert(il.begin(), il.end());
+    }
+
 #endif //# __TBB_INITIALIZER_LISTS_PRESENT
 
-#if __TBB_CPP11_RVALUE_REF_PRESENT
-#if !__TBB_IMPLICIT_MOVE_PRESENT
+
+#if __TBB_CPP11_RVALUE_REF_PRESENT && !__TBB_IMPLICIT_MOVE_PRESENT
     concurrent_unordered_multiset(const concurrent_unordered_multiset& table)
         : base_type(table)
     {}
@@ -234,18 +379,62 @@ class concurrent_unordered_multiset :
     {
         return static_cast<concurrent_unordered_multiset&>(base_type::operator=(std::move(table)));
     }
-#endif //!__TBB_IMPLICIT_MOVE_PRESENT
+#endif //__TBB_CPP11_RVALUE_REF_PRESENT && !__TBB_IMPLICIT_MOVE_PRESENT
 
+#if __TBB_CPP11_RVALUE_REF_PRESENT
     concurrent_unordered_multiset(concurrent_unordered_multiset&& table, const Allocator& a)
         : base_type(std::move(table), a)
     {
     }
-#endif //__TBB_CPP11_RVALUE_REF_PRESENT
+#endif /*__TBB_CPP11_RVALUE_REF_PRESENT*/
+
+#if __TBB_UNORDERED_NODE_HANDLE_PRESENT
+    template<typename Hash, typename Equality>
+    void merge(concurrent_unordered_set<Key, Hash, Equality, Allocator>& source)
+              { this->internal_merge(source); }
+
+    template<typename Hash, typename Equality>
+    void merge(concurrent_unordered_set<Key, Hash, Equality, Allocator>&& source)
+              { this->internal_merge(source); }
+
+    template<typename Hash, typename Equality>
+    void merge(concurrent_unordered_multiset<Key, Hash, Equality, Allocator>& source)
+              { this->internal_merge(source); }
+
+    template<typename Hash, typename Equality>
+    void merge(concurrent_unordered_multiset<Key, Hash, Equality, Allocator>&& source)
+              { this->internal_merge(source); }
+
+#endif //__TBB_UNORDERED_NODE_HANDLE_PRESENT
 
     concurrent_unordered_multiset(const concurrent_unordered_multiset& table, const Allocator& a)
         : base_type(table, a)
     {}
 };
+
+#if __TBB_CPP17_DEDUCTION_GUIDES_PRESENT
+
+// Deduction guide for the constructor from two iterators
+template<typename I>
+concurrent_unordered_multiset(I, I)
+-> internal::cu_set_t<concurrent_unordered_multiset, internal::iterator_value_t<I>>;
+
+// Deduction guide for the constructor from two iterators and hasher/equality/allocator
+template<typename I, typename... Args>
+concurrent_unordered_multiset(I, I, size_t, Args...)
+-> internal::cu_set_t<concurrent_unordered_multiset, internal::iterator_value_t<I>, Args...>;
+
+// Deduction guide for the constructor from an initializer_list
+template<typename T>
+concurrent_unordered_multiset(std::initializer_list<T>)
+-> internal::cu_set_t<concurrent_unordered_multiset, T>;
+
+// Deduction guide for the constructor from an initializer_list and hasher/equality/allocator
+template<typename T, typename... Args>
+concurrent_unordered_multiset(std::initializer_list<T>, size_t, Args...)
+-> internal::cu_set_t<concurrent_unordered_multiset, T, Args...>;
+
+#endif /* __TBB_CPP17_DEDUCTION_GUIDES_PRESENT */
 } // namespace interface5
 
 using interface5::concurrent_unordered_set;
@@ -253,4 +442,7 @@ using interface5::concurrent_unordered_multiset;
 
 } // namespace tbb
 
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_concurrent_unordered_set_H_include_area
+
 #endif// __TBB_concurrent_unordered_set_H
diff --git a/inst/include/tbb/concurrent_vector.h b/inst/include/tbb/concurrent_vector.h
index bd93615e..a4988aaa 100644
--- a/inst/include/tbb/concurrent_vector.h
+++ b/inst/include/tbb/concurrent_vector.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,15 +12,14 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_concurrent_vector_H
 #define __TBB_concurrent_vector_H
 
+#define __TBB_concurrent_vector_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #include "tbb_stddef.h"
 #include "tbb_exception.h"
 #include "atomic.h"
@@ -31,19 +30,10 @@
 #include <new>
 #include <cstring>   // for memset()
 #include __TBB_STD_SWAP_HEADER
-
-#if !TBB_USE_EXCEPTIONS && _MSC_VER
-    // Suppress "C++ exception handler used, but unwind semantics are not enabled" warning in STL headers
-    #pragma warning (push)
-    #pragma warning (disable: 4530)
-#endif
-
 #include <algorithm>
 #include <iterator>
 
-#if !TBB_USE_EXCEPTIONS && _MSC_VER
-    #pragma warning (pop)
-#endif
+#include "internal/_allocator_traits.h"
 
 #if _MSC_VER==1500 && !__INTEL_COMPILER
     // VS2008/VC9 seems to have an issue; limits pull in math.h
@@ -85,7 +75,7 @@ namespace internal {
     //! Exception helper function
     template<typename T>
     void handle_unconstructed_elements(T* array, size_t n_of_elements){
-        std::memset( (void*) array, 0, n_of_elements * sizeof( T ) );
+        std::memset( static_cast<void*>(array), 0, n_of_elements * sizeof( T ) );
     }
 
     //! Base class of concurrent vector implementation.
@@ -105,11 +95,11 @@ namespace internal {
             pointers_per_short_table = 3, // to fit into 8 words of entire structure
             pointers_per_long_table = sizeof(segment_index_t) * 8 // one segment per bit
         };
-    public:
+
         struct segment_not_used {};
         struct segment_allocated {};
         struct segment_allocation_failed {};
-    protected:
+
         class segment_t;
         class segment_value_t {
             void* array;
@@ -351,6 +341,14 @@ namespace internal {
             my_item(other.my_item)
         {}
 
+        vector_iterator& operator=( const vector_iterator<Container,typename Container::value_type>& other )
+        {
+            my_vector=other.my_vector;
+            my_index=other.my_index;
+            my_item=other.my_item;
+            return *this;
+        }
+
         vector_iterator operator+( ptrdiff_t offset ) const {
             return vector_iterator( *my_vector, my_index+offset );
         }
@@ -478,12 +476,9 @@ namespace internal {
     template<typename T, class A>
     class allocator_base {
     public:
-        typedef typename A::template
-            rebind<T>::other allocator_type;
+        typedef typename tbb::internal::allocator_rebind<A, T>::type allocator_type;
         allocator_type my_allocator;
-
         allocator_base(const allocator_type &a = allocator_type() ) : my_allocator(a) {}
-
     };
 
 } // namespace internal
@@ -682,7 +677,7 @@ class concurrent_vector: protected internal::allocator_base<T, A>,
 
     //! Copying constructor for vector with different allocator type
     template<class M>
-    concurrent_vector( const concurrent_vector<T, M>& vector, const allocator_type& a = allocator_type() )
+    __TBB_DEPRECATED concurrent_vector( const concurrent_vector<T, M>& vector, const allocator_type& a = allocator_type() )
         : internal::allocator_base<T, A>(a), internal::concurrent_vector_base()
     {
         vector_allocator_ptr = &internal_allocator;
@@ -753,9 +748,7 @@ class concurrent_vector: protected internal::allocator_base<T, A>,
         if(pocma_t::value || this->my_allocator == other.my_allocator) {
             concurrent_vector trash (std::move(*this));
             internal_swap(other);
-            if (pocma_t::value) {
-                this->my_allocator = std::move(other.my_allocator);
-            }
+            tbb::internal::allocator_move_assignment(this->my_allocator, other.my_allocator, pocma_t());
         } else {
             internal_assign(other, sizeof(T), &destroy_array, &move_assign_array, &move_array);
         }
@@ -766,7 +759,7 @@ class concurrent_vector: protected internal::allocator_base<T, A>,
 
     //! Assignment for vector with different allocator type
     template<class M>
-    concurrent_vector& operator=( const concurrent_vector<T, M>& vector ) {
+    __TBB_DEPRECATED concurrent_vector& operator=( const concurrent_vector<T, M>& vector ) {
         if( static_cast<void*>( this ) != static_cast<const void*>( &vector ) )
             internal_assign(vector.internal_vector_base(),
                 sizeof(T), &destroy_array, &assign_array, &copy_array);
@@ -1013,10 +1006,10 @@ class concurrent_vector: protected internal::allocator_base<T, A>,
 
     //! swap two instances
     void swap(concurrent_vector &vector) {
-        using std::swap;
-        if( this != &vector ) {
+        typedef typename tbb::internal::allocator_traits<A>::propagate_on_container_swap pocs_t;
+        if( this != &vector && (this->my_allocator == vector.my_allocator || pocs_t::value) ) {
             concurrent_vector_base_v3::internal_swap(static_cast<concurrent_vector_base_v3&>(vector));
-            swap(this->my_allocator, vector.my_allocator);
+            tbb::internal::allocator_swap(this->my_allocator, vector.my_allocator, pocs_t());
         }
     }
 
@@ -1053,7 +1046,13 @@ class concurrent_vector: protected internal::allocator_base<T, A>,
         internal_resize( n, sizeof(T), max_size(), static_cast<const void*>(p), &destroy_array, p? &initialize_array_by : &initialize_array );
     }
 
-    //! helper class
+    //! True/false function override helper
+    /* Functions declarations:
+     *     void foo(is_integer_tag<true>*);
+     *     void foo(is_integer_tag<false>*);
+     * Usage example:
+     *     foo(static_cast<is_integer_tag<std::numeric_limits<T>::is_integer>*>(0));
+     */
     template<bool B> class is_integer_tag;
 
     //! assign integer items by copying when arguments are treated as iterators. See C++ Standard 2003 23.1.1p9
@@ -1167,6 +1166,25 @@ class concurrent_vector: protected internal::allocator_base<T, A>,
     };
 };
 
+#if __TBB_CPP17_DEDUCTION_GUIDES_PRESENT
+// Deduction guide for the constructor from two iterators
+template<typename I,
+         typename T = typename std::iterator_traits<I>::value_type,
+         typename A = cache_aligned_allocator<T>
+> concurrent_vector(I, I, const A& = A())
+-> concurrent_vector<T, A>;
+
+// Deduction guide for the constructor from a vector and allocator
+template<typename T, typename A1, typename A2>
+concurrent_vector(const concurrent_vector<T, A1> &, const A2 &)
+-> concurrent_vector<T, A2>;
+
+// Deduction guide for the constructor from an initializer_list
+template<typename T, typename A = cache_aligned_allocator<T>
+> concurrent_vector(std::initializer_list<T>, const A& = A())
+-> concurrent_vector<T, A>;
+#endif /* __TBB_CPP17_DEDUCTION_GUIDES_PRESENT */
+
 #if defined(_MSC_VER) && !defined(__INTEL_COMPILER)
 #pragma warning (push)
 #pragma warning (disable: 4701) // potentially uninitialized local variable "old"
@@ -1304,8 +1322,8 @@ void concurrent_vector<T, A>::move_array_if_noexcept( void* dst, const void* src
 template<typename T, class A>
 template<typename I>
 void concurrent_vector<T, A>::copy_range( void* dst, const void* p_type_erased_iterator, size_type n ){
-    I & iterator ((*const_cast<I*>(static_cast<const I*>(p_type_erased_iterator))));
-    internal_loop_guide loop(n, dst); loop.iterate(iterator);
+    internal_loop_guide loop(n, dst);
+    loop.iterate( *(static_cast<I*>(const_cast<void*>(p_type_erased_iterator))) );
 }
 
 template<typename T, class A>
@@ -1371,4 +1389,8 @@ inline void swap(concurrent_vector<T, A> &a, concurrent_vector<T, A> &b)
     #pragma warning (pop)
 #endif // warning 4267,4127 are back
 
+
+#undef __TBB_concurrent_vector_H_include_area
+#include "internal/_warning_suppress_disable_notice.h"
+
 #endif /* __TBB_concurrent_vector_H */
diff --git a/inst/include/tbb/critical_section.h b/inst/include/tbb/critical_section.h
index 324b3e13..fb3332b2 100644
--- a/inst/include/tbb/critical_section.h
+++ b/inst/include/tbb/critical_section.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,15 +12,25 @@
     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 "internal/_deprecated_header_message_guard.h"
 
+#if !defined(__TBB_show_deprecation_message_critical_section_H) && defined(__TBB_show_deprecated_header_message)
+#define  __TBB_show_deprecation_message_critical_section_H
+#pragma message("TBB Warning: tbb/critical_section.h is deprecated. For details, please see Deprecated Features appendix in the TBB reference manual.")
+#endif
 
-
-*/
+#if defined(__TBB_show_deprecated_header_message)
+#undef __TBB_show_deprecated_header_message
+#endif
 
 #ifndef _TBB_CRITICAL_SECTION_H_
 #define _TBB_CRITICAL_SECTION_H_
 
+#define __TBB_critical_section_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #if _WIN32||_WIN64
 #include "machine/windows_api.h"
 #else
@@ -126,8 +136,12 @@ class critical_section_v4 : internal::no_copy {
     static const bool is_fair_mutex = true;
 }; // critical_section_v4
 } // namespace internal
-typedef internal::critical_section_v4 critical_section;
+__TBB_DEPRECATED_IN_VERBOSE_MODE_MSG("tbb::critical_section is deprecated, use std::mutex") typedef internal::critical_section_v4 critical_section;
 
 __TBB_DEFINE_PROFILING_SET_NAME(critical_section)
 } // namespace tbb
+
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_critical_section_H_include_area
+
 #endif  // _TBB_CRITICAL_SECTION_H_
diff --git a/inst/include/tbb/enumerable_thread_specific.h b/inst/include/tbb/enumerable_thread_specific.h
index f31f533b..248597f2 100644
--- a/inst/include/tbb/enumerable_thread_specific.h
+++ b/inst/include/tbb/enumerable_thread_specific.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,15 +12,14 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_enumerable_thread_specific_H
 #define __TBB_enumerable_thread_specific_H
 
+#define __TBB_enumerable_thread_specific_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #include "atomic.h"
 #include "concurrent_vector.h"
 #include "tbb_thread.h"
@@ -32,6 +31,10 @@
 #include "tbb_profiling.h"
 #include <string.h>  // for memcpy
 
+#if __TBB_PREVIEW_RESUMABLE_TASKS
+#include "task.h" // for task::suspend_point
+#endif
+
 #if _WIN32||_WIN64
 #include "machine/windows_api.h"
 #else
@@ -45,7 +48,13 @@
 namespace tbb {
 
 //! enum for selecting between single key and key-per-instance versions
-enum ets_key_usage_type { ets_key_per_instance, ets_no_key };
+enum ets_key_usage_type {
+    ets_key_per_instance
+    , ets_no_key
+#if __TBB_PREVIEW_RESUMABLE_TASKS
+    , ets_suspend_aware
+#endif
+};
 
 namespace interface6 {
 
@@ -58,10 +67,33 @@ namespace interface6 {
 
         using namespace tbb::internal;
 
+        template <ets_key_usage_type ETS_key_type>
+        struct ets_key_selector {
+            typedef tbb_thread::id key_type;
+            static key_type current_key() {
+                return tbb::internal::thread_get_id_v3();
+            }
+        };
+
+#if __TBB_PREVIEW_RESUMABLE_TASKS
+        template <>
+        struct ets_key_selector<ets_suspend_aware> {
+            typedef task::suspend_point key_type;
+            static key_type current_key() {
+                return internal_current_suspend_point();
+            }
+        };
+
+        inline task::suspend_point atomic_compare_and_swap(task::suspend_point& location,
+                const task::suspend_point& value, const task::suspend_point& comparand) {
+            return as_atomic(location).compare_and_swap(value, comparand);
+        }
+#endif
+
         template<ets_key_usage_type ETS_key_type>
         class ets_base: tbb::internal::no_copy {
         protected:
-            typedef tbb_thread::id key_type;
+            typedef typename ets_key_selector<ETS_key_type>::key_type key_type;
 #if __TBB_PROTECTED_NESTED_CLASS_BROKEN
         public:
 #endif
@@ -119,8 +151,9 @@ namespace interface6 {
             void table_clear();
             // The following functions are not used in concurrent context,
             // so we don't need synchronization and ITT annotations there.
+            template <ets_key_usage_type E2>
             void table_elementwise_copy( const ets_base& other,
-                                         void*(*add_element)(ets_base&, void*) ) {
+                                         void*(*add_element)(ets_base<E2>&, void*) ) {
                 __TBB_ASSERT(!my_root,NULL);
                 __TBB_ASSERT(!my_count,NULL);
                 if( !other.my_root ) return;
@@ -135,7 +168,7 @@ namespace interface6 {
                             for( size_t j = root->start(tbb::tbb_hash<key_type>()(s1.key)); ; j=(j+1)&mask ) {
                                 slot& s2 = root->at(j);
                                 if( s2.empty() ) {
-                                    s2.ptr = add_element(*this, s1.ptr);
+                                    s2.ptr = add_element(static_cast<ets_base<E2>&>(*this), s1.ptr);
                                     s2.key = s1.key;
                                     break;
                                 }
@@ -169,7 +202,7 @@ namespace interface6 {
 
         template<ets_key_usage_type ETS_key_type>
         void* ets_base<ETS_key_type>::table_lookup( bool& exists ) {
-            const key_type k = tbb::this_tbb_thread::get_id();
+            const key_type k = ets_key_selector<ETS_key_type>::current_key();
 
             __TBB_ASSERT(k != key_type(),NULL);
             void* found;
@@ -242,7 +275,7 @@ namespace interface6 {
 
         //! Specialization that exploits native TLS
         template <>
-        class ets_base<ets_key_per_instance>: protected ets_base<ets_no_key> {
+        class ets_base<ets_key_per_instance>: public ets_base<ets_no_key> {
             typedef ets_base<ets_no_key> super;
 #if _WIN32||_WIN64
 #if __TBB_WIN8UI_SUPPORT
@@ -799,7 +832,7 @@ namespace interface6 {
             return lref.value_committed();
         }
 
-        static void* create_local_by_copy( internal::ets_base<ets_no_key>& base, void* p ) {
+        static void* create_local_by_copy( internal::ets_base<ETS_key_type>& base, void* p ) {
             enumerable_thread_specific& ets = static_cast<enumerable_thread_specific&>(base);
             padded_element& lref = *ets.my_locals.grow_by(1);
             new(lref.value()) T(*static_cast<T*>(p));
@@ -807,7 +840,7 @@ namespace interface6 {
         }
 
 #if __TBB_ETS_USE_CPP11
-        static void* create_local_by_move( internal::ets_base<ets_no_key>& base, void* p ) {
+        static void* create_local_by_move( internal::ets_base<ETS_key_type>& base, void* p ) {
             enumerable_thread_specific& ets = static_cast<enumerable_thread_specific&>(base);
             padded_element& lref = *ets.my_locals.grow_by(1);
             new(lref.value()) T(std::move(*static_cast<T*>(p)));
@@ -888,7 +921,7 @@ namespace interface6 {
         ~enumerable_thread_specific() {
             if(my_construct_callback) my_construct_callback->destroy();
             // Deallocate the hash table before overridden free_array() becomes inaccessible
-            this->internal::ets_base<ets_no_key>::table_clear();
+            this->internal::ets_base<ETS_key_type>::table_clear();
         }
 
         //! returns reference to local, discarding exists
@@ -1134,4 +1167,7 @@ using interface6::flatten2d;
 
 } // namespace tbb
 
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_enumerable_thread_specific_H_include_area
+
 #endif
diff --git a/inst/include/tbb/flow_graph.h b/inst/include/tbb/flow_graph.h
index 7b03c0e2..03020f79 100644
--- a/inst/include/tbb/flow_graph.h
+++ b/inst/include/tbb/flow_graph.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,15 +12,14 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_flow_graph_H
 #define __TBB_flow_graph_H
 
+#define __TBB_flow_graph_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #include "tbb_stddef.h"
 #include "atomic.h"
 #include "spin_mutex.h"
@@ -30,11 +29,23 @@
 #include "task.h"
 #include "cache_aligned_allocator.h"
 #include "tbb_exception.h"
+#include "pipeline.h"
 #include "internal/_template_helpers.h"
 #include "internal/_aggregator_impl.h"
+#include "tbb/internal/_allocator_traits.h"
 #include "tbb_profiling.h"
 #include "task_arena.h"
-#include "flow_graph_abstractions.h"
+
+#if TBB_USE_THREADING_TOOLS && TBB_PREVIEW_FLOW_GRAPH_TRACE && ( __linux__ || __APPLE__ )
+   #if __INTEL_COMPILER
+       // Disabled warning "routine is both inline and noinline"
+       #pragma warning (push)
+       #pragma warning( disable: 2196 )
+   #endif
+   #define __TBB_NOINLINE_SYM __attribute__((noinline))
+#else
+   #define __TBB_NOINLINE_SYM
+#endif 
 
 #if __TBB_PREVIEW_ASYNC_MSG
 #include <vector>    // std::vector in internal::async_storage
@@ -54,6 +65,12 @@
 #define FLOW_SPAWN(a) tbb::task::spawn((a))
 #endif
 
+#if TBB_DEPRECATED_FLOW_NODE_ALLOCATOR
+#define __TBB_DEFAULT_NODE_ALLOCATOR(T) cache_aligned_allocator<T>
+#else
+#define __TBB_DEFAULT_NODE_ALLOCATOR(T) null_type
+#endif
+
 // use the VC10 or gcc version of tuple if it is available.
 #if __TBB_CPP11_TUPLE_PRESENT
     #include <tuple>
@@ -88,66 +105,62 @@ namespace flow {
 //! An enumeration the provides the two most common concurrency levels: unlimited and serial
 enum concurrency { unlimited = 0, serial = 1 };
 
-namespace internal {
-static tbb::task * const SUCCESSFULLY_ENQUEUED = (task *)-1;
-}
-
-namespace interface9 {
-
-using tbb::flow::internal::SUCCESSFULLY_ENQUEUED;
-
-namespace internal {
-    template<typename T, typename M> class successor_cache;
-    template<typename T, typename M> class broadcast_cache;
-    template<typename T, typename M> class round_robin_cache;
-    template<typename T, typename M> class predecessor_cache;
-    template<typename T, typename M> class reservable_predecessor_cache;
-}
+namespace interface11 {
 
-//A generic null type
+//! A generic null type
 struct null_type {};
 
 //! An empty class used for messages that mean "I'm done"
 class continue_msg {};
 
+//! Forward declaration section
 template< typename T > class sender;
 template< typename T > class receiver;
 class continue_receiver;
 
-template< typename T > class limiter_node;  // needed for resetting decrementer
+template< typename T, typename U > class limiter_node;  // needed for resetting decrementer
+
 template< typename R, typename B > class run_and_put_task;
 
-// flags to modify the behavior of the graph reset().  Can be combined.
-enum reset_flags {
-    rf_reset_protocol   = 0,
-    rf_reset_bodies     = 1<<0,  // delete the current node body, reset to a copy of the initial node body.
-    rf_clear_edges      = 1<<1   // delete edges
-};
+namespace internal {
+
+template<typename T, typename M> class successor_cache;
+template<typename T, typename M> class broadcast_cache;
+template<typename T, typename M> class round_robin_cache;
+template<typename T, typename M> class predecessor_cache;
+template<typename T, typename M> class reservable_predecessor_cache;
+
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+namespace order {
+struct following;
+struct preceding;
+}
+template<typename Order, typename... Args> struct node_set;
+#endif
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
-//* holder of edges both for caches and for those nodes which do not have predecessor caches.
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
+// Holder of edges both for caches and for those nodes which do not have predecessor caches.
 // C == receiver< ... > or sender< ... >, depending.
-namespace internal {
 template<typename C>
 class edge_container {
 
 public:
     typedef std::list<C *, tbb::tbb_allocator<C *> > edge_list_type;
 
-    void add_edge( C &s) {
-        built_edges.push_back( &s );
+    void add_edge(C &s) {
+        built_edges.push_back(&s);
     }
 
-    void delete_edge( C &s) {
-        for ( typename edge_list_type::iterator i = built_edges.begin(); i != built_edges.end(); ++i ) {
-            if ( *i == &s )  {
+    void delete_edge(C &s) {
+        for (typename edge_list_type::iterator i = built_edges.begin(); i != built_edges.end(); ++i) {
+            if (*i == &s) {
                 (void)built_edges.erase(i);
                 return;  // only remove one predecessor per request
             }
         }
     }
 
-    void copy_edges( edge_list_type &v) {
+    void copy_edges(edge_list_type &v) {
         v = built_edges;
     }
 
@@ -161,21 +174,133 @@ class edge_container {
 
     // methods remove the statement from all predecessors/successors liste in the edge
     // container.
-    template< typename S > void sender_extract( S &s ); 
-    template< typename R > void receiver_extract( R &r ); 
+    template< typename S > void sender_extract(S &s);
+    template< typename R > void receiver_extract(R &r);
 
-private: 
+private:
     edge_list_type built_edges;
 };  // class edge_container
-}  // namespace internal
-#endif  /* TBB_PREVIEW_FLOW_GRAPH_FEATURES */
+#endif  /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
+
+} // namespace internal
+
+} // namespace interfaceX
+} // namespace flow
+} // namespace tbb
+
+//! The graph class
+#include "internal/_flow_graph_impl.h"
+
+namespace tbb {
+namespace flow {
+namespace interface11 {
+
+// enqueue left task if necessary. Returns the non-enqueued task if there is one.
+static inline tbb::task *combine_tasks(graph& g, tbb::task * left, tbb::task * right) {
+    // if no RHS task, don't change left.
+    if (right == NULL) return left;
+    // right != NULL
+    if (left == NULL) return right;
+    if (left == SUCCESSFULLY_ENQUEUED) return right;
+    // left contains a task
+    if (right != SUCCESSFULLY_ENQUEUED) {
+        // both are valid tasks
+        internal::spawn_in_graph_arena(g, *left);
+        return right;
+    }
+    return left;
+}
 
 #if __TBB_PREVIEW_ASYNC_MSG
 
-#include "internal/_flow_graph_async_msg_impl.h"
+template < typename T > class __TBB_DEPRECATED async_msg;
 
 namespace internal {
 
+template < typename T > class async_storage;
+
+template< typename T, typename = void >
+struct async_helpers {
+    typedef async_msg<T> async_type;
+    typedef T filtered_type;
+
+    static const bool is_async_type = false;
+
+    static const void* to_void_ptr(const T& t) {
+        return static_cast<const void*>(&t);
+    }
+
+    static void* to_void_ptr(T& t) {
+        return static_cast<void*>(&t);
+    }
+
+    static const T& from_void_ptr(const void* p) {
+        return *static_cast<const T*>(p);
+    }
+
+    static T& from_void_ptr(void* p) {
+        return *static_cast<T*>(p);
+    }
+
+    static task* try_put_task_wrapper_impl(receiver<T>* const this_recv, const void *p, bool is_async) {
+        if (is_async) {
+            // This (T) is NOT async and incoming 'A<X> t' IS async
+            // Get data from async_msg
+            const async_msg<filtered_type>& msg = async_helpers< async_msg<filtered_type> >::from_void_ptr(p);
+            task* const new_task = msg.my_storage->subscribe(*this_recv, this_recv->graph_reference());
+            // finalize() must be called after subscribe() because set() can be called in finalize()
+            // and 'this_recv' client must be subscribed by this moment
+            msg.finalize();
+            return new_task;
+        }
+        else {
+            // Incoming 't' is NOT async
+            return this_recv->try_put_task(from_void_ptr(p));
+        }
+    }
+};
+
+template< typename T >
+struct async_helpers< T, typename std::enable_if< std::is_base_of<async_msg<typename T::async_msg_data_type>, T>::value >::type > {
+    typedef T async_type;
+    typedef typename T::async_msg_data_type filtered_type;
+
+    static const bool is_async_type = true;
+
+    // Receiver-classes use const interfaces
+    static const void* to_void_ptr(const T& t) {
+        return static_cast<const void*>(&static_cast<const async_msg<filtered_type>&>(t));
+    }
+
+    static void* to_void_ptr(T& t) {
+        return static_cast<void*>(&static_cast<async_msg<filtered_type>&>(t));
+    }
+
+    // Sender-classes use non-const interfaces
+    static const T& from_void_ptr(const void* p) {
+        return *static_cast<const T*>(static_cast<const async_msg<filtered_type>*>(p));
+    }
+
+    static T& from_void_ptr(void* p) {
+        return *static_cast<T*>(static_cast<async_msg<filtered_type>*>(p));
+    }
+
+    // Used in receiver<T> class
+    static task* try_put_task_wrapper_impl(receiver<T>* const this_recv, const void *p, bool is_async) {
+        if (is_async) {
+            // Both are async
+            return this_recv->try_put_task(from_void_ptr(p));
+        }
+        else {
+            // This (T) is async and incoming 'X t' is NOT async
+            // Create async_msg for X
+            const filtered_type& t = async_helpers<filtered_type>::from_void_ptr(p);
+            const T msg(t);
+            return this_recv->try_put_task(msg);
+        }
+    }
+};
+
 class untyped_receiver;
 
 class untyped_sender {
@@ -203,7 +328,7 @@ class untyped_sender {
     //! Consumes the reserved item
     virtual bool try_consume( ) { return false; }
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
     //! interface to record edges for traversal & deletion
     typedef internal::edge_container<successor_type> built_successors_type;
     typedef built_successors_type::edge_list_type successor_list_type;
@@ -212,7 +337,7 @@ class untyped_sender {
     virtual void    internal_delete_built_successor( successor_type & ) = 0;
     virtual void    copy_successors( successor_list_type &)             = 0;
     virtual size_t  successor_count()                                   = 0;
-#endif
+#endif /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
 protected:
     //! Request an item from the sender
     template< typename X >
@@ -232,7 +357,6 @@ class untyped_sender {
 
 class untyped_receiver  {
     template< typename, typename > friend class run_and_put_task;
-    template< typename > friend class limiter_node;
 
     template< typename, typename > friend class internal::broadcast_cache;
     template< typename, typename > friend class internal::round_robin_cache;
@@ -253,7 +377,7 @@ class untyped_receiver  {
     bool try_put(const X& t) {
         task *res = try_put_task(t);
         if (!res) return false;
-        if (res != SUCCESSFULLY_ENQUEUED) FLOW_SPAWN(*res);
+        if (res != SUCCESSFULLY_ENQUEUED) internal::spawn_in_graph_arena(graph_reference(), *res);
         return true;
     }
 
@@ -267,7 +391,7 @@ class untyped_receiver  {
     //! Remove a predecessor from the node
     virtual bool remove_predecessor( predecessor_type & ) { return false; }
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
     typedef internal::edge_container<predecessor_type> built_predecessors_type;
     typedef built_predecessors_type::edge_list_type predecessor_list_type;
     virtual built_predecessors_type &built_predecessors()                  = 0;
@@ -275,7 +399,7 @@ class untyped_receiver  {
     virtual void   internal_delete_built_predecessor( predecessor_type & ) = 0;
     virtual void   copy_predecessors( predecessor_list_type & )            = 0;
     virtual size_t predecessor_count()                                     = 0;
-#endif
+#endif /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
 protected:
     template<typename X>
     task *try_put_task(const X& t) {
@@ -284,6 +408,8 @@ class untyped_receiver  {
 
     virtual task* try_put_task_wrapper( const void* p, bool is_async ) = 0;
 
+    virtual graph& graph_reference() const = 0;
+
     // NOTE: Following part of PROTECTED and PRIVATE sections is copy-paste from original receiver<T> class
 
     //! put receiver back in initial state
@@ -299,9 +425,9 @@ template< typename T >
 class sender : public internal::untyped_sender {
 public:
     //! The output type of this sender
-    typedef T output_type;
+    __TBB_DEPRECATED typedef T output_type;
 
-    typedef typename internal::async_helpers<T>::filtered_type filtered_type;
+    __TBB_DEPRECATED typedef typename internal::async_helpers<T>::filtered_type filtered_type;
 
     //! Request an item from the sender
     virtual bool try_get( T & ) { return false; }
@@ -338,9 +464,9 @@ class receiver : public internal::untyped_receiver {
     template< typename, typename > friend struct internal::async_helpers;
 public:
     //! The input type of this receiver
-    typedef T input_type;
+    __TBB_DEPRECATED typedef T input_type;
 
-    typedef typename internal::async_helpers<T>::filtered_type filtered_type;
+    __TBB_DEPRECATED typedef typename internal::async_helpers<T>::filtered_type filtered_type;
 
     //! Put an item to the receiver
     bool try_put( const typename internal::async_helpers<T>::filtered_type& t ) {
@@ -368,20 +494,20 @@ template< typename T >
 class sender {
 public:
     //! The output type of this sender
-    typedef T output_type;
+    __TBB_DEPRECATED typedef T output_type;
 
     //! The successor type for this node
-    typedef receiver<T> successor_type;
+    __TBB_DEPRECATED typedef receiver<T> successor_type;
 
     virtual ~sender() {}
 
     // NOTE: Following part of PUBLIC section is partly copy-pasted in sender<T> under #if __TBB_PREVIEW_ASYNC_MSG
 
     //! Add a new successor to this node
-    virtual bool register_successor( successor_type &r ) = 0;
+    __TBB_DEPRECATED virtual bool register_successor( successor_type &r ) = 0;
 
     //! Removes a successor from this node
-    virtual bool remove_successor( successor_type &r ) = 0;
+    __TBB_DEPRECATED virtual bool remove_successor( successor_type &r ) = 0;
 
     //! Request an item from the sender
     virtual bool try_get( T & ) { return false; }
@@ -395,16 +521,16 @@ class sender {
     //! Consumes the reserved item
     virtual bool try_consume( ) { return false; }
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
     //! interface to record edges for traversal & deletion
-    typedef typename  internal::edge_container<successor_type> built_successors_type;
-    typedef typename  built_successors_type::edge_list_type successor_list_type;
-    virtual built_successors_type &built_successors()                   = 0;
-    virtual void    internal_add_built_successor( successor_type & )    = 0;
-    virtual void    internal_delete_built_successor( successor_type & ) = 0;
-    virtual void    copy_successors( successor_list_type &)             = 0;
-    virtual size_t  successor_count()                                   = 0;
-#endif
+    __TBB_DEPRECATED typedef typename  internal::edge_container<successor_type> built_successors_type;
+    __TBB_DEPRECATED typedef typename  built_successors_type::edge_list_type successor_list_type;
+    __TBB_DEPRECATED virtual built_successors_type &built_successors()                   = 0;
+    __TBB_DEPRECATED virtual void    internal_add_built_successor( successor_type & )    = 0;
+    __TBB_DEPRECATED virtual void    internal_delete_built_successor( successor_type & ) = 0;
+    __TBB_DEPRECATED virtual void    copy_successors( successor_list_type &)             = 0;
+    __TBB_DEPRECATED virtual size_t  successor_count()                                   = 0;
+#endif /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
 };  // class sender<T>
 
 //! Pure virtual template class that defines a receiver of messages of type T
@@ -412,10 +538,10 @@ template< typename T >
 class receiver {
 public:
     //! The input type of this receiver
-    typedef T input_type;
+    __TBB_DEPRECATED typedef T input_type;
 
     //! The predecessor type for this node
-    typedef sender<T> predecessor_type;
+    __TBB_DEPRECATED typedef sender<T> predecessor_type;
 
     //! Destructor
     virtual ~receiver() {}
@@ -424,7 +550,7 @@ class receiver {
     bool try_put( const T& t ) {
         task *res = try_put_task(t);
         if (!res) return false;
-        if (res != SUCCESSFULLY_ENQUEUED) FLOW_SPAWN(*res);
+        if (res != SUCCESSFULLY_ENQUEUED) internal::spawn_in_graph_arena(graph_reference(), *res);
         return true;
     }
 
@@ -434,28 +560,28 @@ class receiver {
     template< typename X, typename Y > friend class internal::broadcast_cache;
     template< typename X, typename Y > friend class internal::round_robin_cache;
     virtual task *try_put_task(const T& t) = 0;
+    virtual graph& graph_reference() const = 0;
 public:
     // NOTE: Following part of PUBLIC and PROTECTED sections is copy-pasted in receiver<T> under #if __TBB_PREVIEW_ASYNC_MSG
 
     //! Add a predecessor to the node
-    virtual bool register_predecessor( predecessor_type & ) { return false; }
+    __TBB_DEPRECATED virtual bool register_predecessor( predecessor_type & ) { return false; }
 
     //! Remove a predecessor from the node
-    virtual bool remove_predecessor( predecessor_type & ) { return false; }
-
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
-    typedef typename internal::edge_container<predecessor_type> built_predecessors_type;
-    typedef typename built_predecessors_type::edge_list_type predecessor_list_type;
-    virtual built_predecessors_type &built_predecessors()                  = 0;
-    virtual void   internal_add_built_predecessor( predecessor_type & )    = 0;
-    virtual void   internal_delete_built_predecessor( predecessor_type & ) = 0;
-    virtual void   copy_predecessors( predecessor_list_type & )            = 0;
-    virtual size_t predecessor_count()                                     = 0;
-#endif
+    __TBB_DEPRECATED virtual bool remove_predecessor( predecessor_type & ) { return false; }
+
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
+    __TBB_DEPRECATED typedef typename internal::edge_container<predecessor_type> built_predecessors_type;
+    __TBB_DEPRECATED typedef typename built_predecessors_type::edge_list_type predecessor_list_type;
+    __TBB_DEPRECATED virtual built_predecessors_type &built_predecessors()                  = 0;
+    __TBB_DEPRECATED virtual void   internal_add_built_predecessor( predecessor_type & )    = 0;
+    __TBB_DEPRECATED virtual void   internal_delete_built_predecessor( predecessor_type & ) = 0;
+    __TBB_DEPRECATED virtual void   copy_predecessors( predecessor_list_type & )            = 0;
+    __TBB_DEPRECATED virtual size_t predecessor_count()                                     = 0;
+#endif /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
 
 protected:
     //! put receiver back in initial state
-    template<typename U> friend class limiter_node;
     virtual void reset_receiver(reset_flags f = rf_reset_protocol) = 0;
 
     template<typename TT, typename M> friend class internal::successor_cache;
@@ -468,47 +594,34 @@ class receiver {
 
 #endif // __TBB_PREVIEW_ASYNC_MSG
 
-// enqueue left task if necessary.  Returns the non-enqueued task if there is one.
-static inline tbb::task *combine_tasks( tbb::task * left, tbb::task * right) {
-    // if no RHS task, don't change left.
-    if(right == NULL) return left;
-    // right != NULL
-    if(left == NULL) return right;
-    if(left == SUCCESSFULLY_ENQUEUED) return right;
-    // left contains a task
-    if(right != SUCCESSFULLY_ENQUEUED) {
-        // both are valid tasks
-        FLOW_SPAWN(*left);
-        return right;
-    }
-    return left;
-}
-
 //! Base class for receivers of completion messages
 /** These receivers automatically reset, but cannot be explicitly waited on */
 class continue_receiver : public receiver< continue_msg > {
 public:
 
     //! The input type
-    typedef continue_msg input_type;
+    __TBB_DEPRECATED typedef continue_msg input_type;
 
     //! The predecessor type for this node
-    typedef receiver<input_type>::predecessor_type predecessor_type;
+    __TBB_DEPRECATED typedef receiver<input_type>::predecessor_type predecessor_type;
 
     //! Constructor
-    explicit continue_receiver( int number_of_predecessors = 0 ) {
+    __TBB_DEPRECATED explicit continue_receiver(
+        __TBB_FLOW_GRAPH_PRIORITY_ARG1(int number_of_predecessors, node_priority_t priority)) {
         my_predecessor_count = my_initial_predecessor_count = number_of_predecessors;
         my_current_count = 0;
+        __TBB_FLOW_GRAPH_PRIORITY_EXPR( my_priority = priority; )
     }
 
     //! Copy constructor
-    continue_receiver( const continue_receiver& src ) : receiver<continue_msg>() {
+    __TBB_DEPRECATED continue_receiver( const continue_receiver& src ) : receiver<continue_msg>() {
         my_predecessor_count = my_initial_predecessor_count = src.my_initial_predecessor_count;
         my_current_count = 0;
+        __TBB_FLOW_GRAPH_PRIORITY_EXPR( my_priority = src.my_priority; )
     }
 
     //! Increments the trigger threshold
-    bool register_predecessor( predecessor_type & ) __TBB_override {
+    __TBB_DEPRECATED bool register_predecessor( predecessor_type & ) __TBB_override {
         spin_mutex::scoped_lock l(my_mutex);
         ++my_predecessor_count;
         return true;
@@ -518,38 +631,38 @@ class continue_receiver : public receiver< continue_msg > {
     /** Does not check to see if the removal of the predecessor now makes the current count
         exceed the new threshold.  So removing a predecessor while the graph is active can cause
         unexpected results. */
-    bool remove_predecessor( predecessor_type & ) __TBB_override {
+    __TBB_DEPRECATED bool remove_predecessor( predecessor_type & ) __TBB_override {
         spin_mutex::scoped_lock l(my_mutex);
         --my_predecessor_count;
         return true;
     }
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
-    typedef internal::edge_container<predecessor_type> built_predecessors_type;
-    typedef built_predecessors_type::edge_list_type predecessor_list_type;
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
+    __TBB_DEPRECATED typedef internal::edge_container<predecessor_type> built_predecessors_type;
+    __TBB_DEPRECATED typedef built_predecessors_type::edge_list_type predecessor_list_type;
     built_predecessors_type &built_predecessors() __TBB_override { return my_built_predecessors; }
 
-    void internal_add_built_predecessor( predecessor_type &s) __TBB_override {
+    __TBB_DEPRECATED void internal_add_built_predecessor( predecessor_type &s) __TBB_override {
         spin_mutex::scoped_lock l(my_mutex);
         my_built_predecessors.add_edge( s );
     }
 
-    void internal_delete_built_predecessor( predecessor_type &s) __TBB_override {
+    __TBB_DEPRECATED void internal_delete_built_predecessor( predecessor_type &s) __TBB_override {
         spin_mutex::scoped_lock l(my_mutex);
         my_built_predecessors.delete_edge(s);
     }
 
-    void copy_predecessors( predecessor_list_type &v) __TBB_override {
+    __TBB_DEPRECATED void copy_predecessors( predecessor_list_type &v) __TBB_override {
         spin_mutex::scoped_lock l(my_mutex);
         my_built_predecessors.copy_edges(v);
     }
 
-    size_t predecessor_count() __TBB_override {
+    __TBB_DEPRECATED size_t predecessor_count() __TBB_override {
         spin_mutex::scoped_lock l(my_mutex);
         return my_built_predecessors.edge_count();
     }
 
-#endif  /* TBB_PREVIEW_FLOW_GRAPH_FEATURES */
+#endif  /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
 
 protected:
     template< typename R, typename B > friend class run_and_put_task;
@@ -568,7 +681,7 @@ class continue_receiver : public receiver< continue_msg > {
         return res? res : SUCCESSFULLY_ENQUEUED;
     }
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
     // continue_receiver must contain its own built_predecessors because it does
     // not have a node_cache.
     built_predecessors_type my_built_predecessors;
@@ -577,14 +690,15 @@ class continue_receiver : public receiver< continue_msg > {
     int my_predecessor_count;
     int my_current_count;
     int my_initial_predecessor_count;
+    __TBB_FLOW_GRAPH_PRIORITY_EXPR( node_priority_t my_priority; )
     // the friend declaration in the base class did not eliminate the "protected class"
     // error in gcc 4.1.2
-    template<typename U> friend class limiter_node;
+    template<typename U, typename V> friend class tbb::flow::interface11::limiter_node;
 
     void reset_receiver( reset_flags f ) __TBB_override {
         my_current_count = 0;
         if (f & rf_clear_edges) {
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
             my_built_predecessors.clear();
 #endif
             my_predecessor_count = my_initial_predecessor_count;
@@ -599,7 +713,8 @@ class continue_receiver : public receiver< continue_msg > {
     bool is_continue_receiver() __TBB_override { return true; }
 
 }; // class continue_receiver
-}  // interface9
+
+}  // interfaceX
 
 #if __TBB_PREVIEW_MESSAGE_BASED_KEY_MATCHING
     template <typename K, typename T>
@@ -608,9 +723,9 @@ class continue_receiver : public receiver< continue_msg > {
     }
 #endif /* __TBB_PREVIEW_MESSAGE_BASED_KEY_MATCHING */
 
-    using interface9::sender;
-    using interface9::receiver;
-    using interface9::continue_receiver;
+    using interface11::sender;
+    using interface11::receiver;
+    using interface11::continue_receiver;
 }  // flow
 }  // tbb
 
@@ -619,317 +734,15 @@ class continue_receiver : public receiver< continue_msg > {
 
 namespace tbb {
 namespace flow {
-namespace interface9 {
+namespace interface11 {
 
-#include "internal/_flow_graph_impl.h"
+#include "internal/_flow_graph_body_impl.h"
+#include "internal/_flow_graph_cache_impl.h"
 #include "internal/_flow_graph_types_impl.h"
-using namespace internal::graph_policy_namespace;
-
-class graph;
-class graph_node;
-
-template <typename GraphContainerType, typename GraphNodeType>
-class graph_iterator {
-    friend class graph;
-    friend class graph_node;
-public:
-    typedef size_t size_type;
-    typedef GraphNodeType value_type;
-    typedef GraphNodeType* pointer;
-    typedef GraphNodeType& reference;
-    typedef const GraphNodeType& const_reference;
-    typedef std::forward_iterator_tag iterator_category;
-
-    //! Default constructor
-    graph_iterator() : my_graph(NULL), current_node(NULL) {}
-
-    //! Copy constructor
-    graph_iterator(const graph_iterator& other) :
-        my_graph(other.my_graph), current_node(other.current_node)
-    {}
-
-    //! Assignment
-    graph_iterator& operator=(const graph_iterator& other) {
-        if (this != &other) {
-            my_graph = other.my_graph;
-            current_node = other.current_node;
-        }
-        return *this;
-    }
-
-    //! Dereference
-    reference operator*() const;
-
-    //! Dereference
-    pointer operator->() const;
-
-    //! Equality
-    bool operator==(const graph_iterator& other) const {
-        return ((my_graph == other.my_graph) && (current_node == other.current_node));
-    }
-
-    //! Inequality
-    bool operator!=(const graph_iterator& other) const { return !(operator==(other)); }
-
-    //! Pre-increment
-    graph_iterator& operator++() {
-        internal_forward();
-        return *this;
-    }
-
-    //! Post-increment
-    graph_iterator operator++(int) {
-        graph_iterator result = *this;
-        operator++();
-        return result;
-    }
-
-private:
-    // the graph over which we are iterating
-    GraphContainerType *my_graph;
-    // pointer into my_graph's my_nodes list
-    pointer current_node;
-
-    //! Private initializing constructor for begin() and end() iterators
-    graph_iterator(GraphContainerType *g, bool begin);
-    void internal_forward();
-};  // class graph_iterator
-
-//! The graph class
-/** This class serves as a handle to the graph */
-class graph : tbb::internal::no_copy, public graph_proxy {
-    friend class graph_node;
-
-    template< typename Body >
-    class run_task : public task {
-    public:
-        run_task( Body& body ) : my_body(body) {}
-        task *execute() __TBB_override {
-            my_body();
-            return NULL;
-        }
-    private:
-        Body my_body;
-    };
-
-    template< typename Receiver, typename Body >
-    class run_and_put_task : public task {
-    public:
-        run_and_put_task( Receiver &r, Body& body ) : my_receiver(r), my_body(body) {}
-        task *execute() __TBB_override {
-            task *res = my_receiver.try_put_task( my_body() );
-            if (res == SUCCESSFULLY_ENQUEUED) res = NULL;
-            return res;
-        }
-    private:
-        Receiver &my_receiver;
-        Body my_body;
-    };
-    typedef std::list<task *> task_list_type;
-
-    class wait_functor {
-        task* graph_root_task;
-    public:
-        wait_functor( task* t ) : graph_root_task(t) {}
-        void operator()() const { graph_root_task->wait_for_all(); }
-    };
-
-    void prepare_task_arena( bool reinit = false ) {
-        if (reinit) {
-            __TBB_ASSERT( my_task_arena, "task arena is NULL");
-            my_task_arena->terminate();
-            my_task_arena->initialize(tbb::task_arena::attach());
-        } else {
-            __TBB_ASSERT(my_task_arena == NULL, "task arena is not NULL");
-            my_task_arena = new tbb::task_arena(tbb::task_arena::attach());
-        }
-        if (!my_task_arena->is_active()) // failed to attach
-            my_task_arena->initialize(); // create a new, default-initialized arena
-        __TBB_ASSERT(my_task_arena->is_active(), "task arena is not active");
-    }
-
-public:
-    //! Constructs a graph with isolated task_group_context
-    graph() : my_nodes(NULL), my_nodes_last(NULL), my_task_arena(NULL) {
-        prepare_task_arena();
-        own_context = true;
-        cancelled = false;
-        caught_exception = false;
-        my_context = new task_group_context();
-        my_root_task = ( new ( task::allocate_root(*my_context) ) empty_task );
-        my_root_task->set_ref_count(1);
-        tbb::internal::fgt_graph( this );
-        my_is_active = true;
-    }
-
-    //! Constructs a graph with use_this_context as context
-    explicit graph(task_group_context& use_this_context) :
-      my_context(&use_this_context), my_nodes(NULL), my_nodes_last(NULL), my_task_arena(NULL) {
-        prepare_task_arena();
-        own_context = false;
-        my_root_task = ( new ( task::allocate_root(*my_context) ) empty_task );
-        my_root_task->set_ref_count(1);
-        tbb::internal::fgt_graph( this );
-        my_is_active = true;
-    }
-
-    //! Destroys the graph.
-    /** Calls wait_for_all, then destroys the root task and context. */
-    ~graph() {
-        wait_for_all();
-        my_root_task->set_ref_count(0);
-        task::destroy( *my_root_task );
-        if (own_context) delete my_context;
-        delete my_task_arena;
-    }
-
-#if TBB_PREVIEW_FLOW_GRAPH_TRACE
-    void set_name( const char *name ) {
-        tbb::internal::fgt_graph_desc( this, name );
-    }
-#endif
-
-    //! Used to register that an external entity may still interact with the graph.
-    /** The graph will not return from wait_for_all until a matching number of decrement_wait_count calls
-        is made. */
-    void increment_wait_count() {
-        if (my_root_task)
-            my_root_task->increment_ref_count();
-    }
-
-    //! Deregisters an external entity that may have interacted with the graph.
-    /** The graph will not return from wait_for_all until all the number of decrement_wait_count calls
-        matches the number of increment_wait_count calls. */
-    void decrement_wait_count() {
-        if (my_root_task)
-            my_root_task->decrement_ref_count();
-    }
-
-    void reserve_wait() __TBB_override {
-        increment_wait_count();
-    }
-
-    void release_wait() __TBB_override {
-        decrement_wait_count();
-    }
-
-    //! Spawns a task that runs a body and puts its output to a specific receiver
-    /** The task is spawned as a child of the graph. This is useful for running tasks
-        that need to block a wait_for_all() on the graph.  For example a one-off source. */
-    template< typename Receiver, typename Body >
-        void run( Receiver &r, Body body ) {
-            if(is_active()) {
-                FLOW_SPAWN( (* new ( task::allocate_additional_child_of( *root_task() ) )
-                   run_and_put_task< Receiver, Body >( r, body )) );
-            }
-    }
-
-    //! Spawns a task that runs a function object
-    /** The task is spawned as a child of the graph. This is useful for running tasks
-        that need to block a wait_for_all() on the graph. For example a one-off source. */
-    template< typename Body >
-    void run( Body body ) {
-        if(is_active()) {
-            FLOW_SPAWN( * new ( task::allocate_additional_child_of( *root_task() ) ) run_task< Body >( body ) );
-        }
-    }
-
-    //! Wait until graph is idle and decrement_wait_count calls equals increment_wait_count calls.
-    /** The waiting thread will go off and steal work while it is block in the wait_for_all. */
-    void wait_for_all() {
-        cancelled = false;
-        caught_exception = false;
-        if (my_root_task) {
-#if TBB_USE_EXCEPTIONS
-            try {
-#endif
-                my_task_arena->execute(wait_functor(my_root_task));
-                cancelled = my_context->is_group_execution_cancelled();
-#if TBB_USE_EXCEPTIONS
-            }
-            catch(...) {
-                my_root_task->set_ref_count(1);
-                my_context->reset();
-                caught_exception = true;
-                cancelled = true;
-                throw;
-            }
+#if __TBB_PREVIEW_ASYNC_MSG
+#include "internal/_flow_graph_async_msg_impl.h"
 #endif
-            // TODO: the "if" condition below is just a work-around to support the concurrent wait
-            // mode. The cancellation and exception mechanisms are still broken in this mode.
-            // Consider using task group not to re-implement the same functionality.
-            if ( !(my_context->traits() & task_group_context::concurrent_wait) ) {
-                my_context->reset();  // consistent with behavior in catch()
-                my_root_task->set_ref_count(1);
-            }
-        }
-    }
-
-    //! Returns the root task of the graph
-    task * root_task() {
-        return my_root_task;
-    }
-
-    void set_active(bool a = true) {
-       my_is_active = a;
-    }
-
-    bool is_active() {
-       return my_is_active;
-    }
-
-    void add_task_to_reset_list(task *tp) {
-        my_reset_task_list.push_back(tp);
-    }
-
-    // ITERATORS
-    template<typename C, typename N>
-    friend class graph_iterator;
-
-    // Graph iterator typedefs
-    typedef graph_iterator<graph,graph_node> iterator;
-    typedef graph_iterator<const graph,const graph_node> const_iterator;
-
-    // Graph iterator constructors
-    //! start iterator
-    iterator begin() { return iterator(this, true); }
-    //! end iterator
-    iterator end() { return iterator(this, false); }
-     //! start const iterator
-    const_iterator begin() const { return const_iterator(this, true); }
-    //! end const iterator
-    const_iterator end() const { return const_iterator(this, false); }
-    //! start const iterator
-    const_iterator cbegin() const { return const_iterator(this, true); }
-    //! end const iterator
-    const_iterator cend() const { return const_iterator(this, false); }
-
-    //! return status of graph execution
-    bool is_cancelled() { return cancelled; }
-    bool exception_thrown() { return caught_exception; }
-
-    // thread-unsafe state reset.
-    void reset(reset_flags f = rf_reset_protocol);
-
-private:
-    task *my_root_task;
-    task_group_context *my_context;
-    bool own_context;
-    bool cancelled;
-    bool caught_exception;
-    bool my_is_active;
-    task_list_type my_reset_task_list;
-
-    graph_node *my_nodes, *my_nodes_last;
-
-    spin_mutex nodelist_mutex;
-    void register_node(graph_node *n);
-    void remove_node(graph_node *n);
-
-    template < typename Input, typename Output, typename Policy, typename Allocator >
-    friend class async_node;
-    task_arena* my_task_arena;
-};  // class graph
+using namespace internal::graph_policy_namespace;
 
 template <typename C, typename N>
 graph_iterator<C,N>::graph_iterator(C *g, bool begin) : my_graph(g), current_node(NULL)
@@ -954,36 +767,57 @@ void graph_iterator<C,N>::internal_forward() {
     if (current_node) current_node = current_node->next;
 }
 
-//! The base of all graph nodes.
-class graph_node : tbb::internal::no_copy {
-    friend class graph;
-    template<typename C, typename N>
-    friend class graph_iterator;
-protected:
-    graph& my_graph;
-    graph_node *next, *prev;
-public:
-    explicit graph_node(graph& g) : my_graph(g) {
-        my_graph.register_node(this);
-    }
-    virtual ~graph_node() {
-        my_graph.remove_node(this);
-    }
+} // namespace interfaceX
 
-#if TBB_PREVIEW_FLOW_GRAPH_TRACE
-    virtual void set_name( const char *name ) = 0;
-#endif
+namespace interface10 {
+//! Constructs a graph with isolated task_group_context
+inline graph::graph() : my_nodes(NULL), my_nodes_last(NULL), my_task_arena(NULL) {
+    prepare_task_arena();
+    own_context = true;
+    cancelled = false;
+    caught_exception = false;
+    my_context = new task_group_context(tbb::internal::FLOW_TASKS);
+    my_root_task = (new (task::allocate_root(*my_context)) empty_task);
+    my_root_task->set_ref_count(1);
+    tbb::internal::fgt_graph(this);
+    my_is_active = true;
+}
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
-    virtual void extract( ) = 0;
-#endif
+inline graph::graph(task_group_context& use_this_context) :
+    my_context(&use_this_context), my_nodes(NULL), my_nodes_last(NULL), my_task_arena(NULL) {
+    prepare_task_arena();
+    own_context = false;
+    cancelled = false;
+    caught_exception = false;
+    my_root_task = (new (task::allocate_root(*my_context)) empty_task);
+    my_root_task->set_ref_count(1);
+    tbb::internal::fgt_graph(this);
+    my_is_active = true;
+}
 
-protected:
-    // performs the reset on an individual node.
-    virtual void reset_node(reset_flags f=rf_reset_protocol) = 0;
-};  // class graph_node
+inline graph::~graph() {
+    wait_for_all();
+    my_root_task->set_ref_count(0);
+    tbb::task::destroy(*my_root_task);
+    if (own_context) delete my_context;
+    delete my_task_arena;
+}
+
+inline void graph::reserve_wait() {
+    if (my_root_task) {
+        my_root_task->increment_ref_count();
+        tbb::internal::fgt_reserve_wait(this);
+    }
+}
 
-inline void graph::register_node(graph_node *n) {
+inline void graph::release_wait() {
+    if (my_root_task) {
+        tbb::internal::fgt_release_wait(this);
+        my_root_task->decrement_ref_count();
+    }
+}
+
+inline void graph::register_node(tbb::flow::interface11::graph_node *n) {
     n->next = NULL;
     {
         spin_mutex::scoped_lock lock(nodelist_mutex);
@@ -994,7 +828,7 @@ inline void graph::register_node(graph_node *n) {
     }
 }
 
-inline void graph::remove_node(graph_node *n) {
+inline void graph::remove_node(tbb::flow::interface11::graph_node *n) {
     {
         spin_mutex::scoped_lock lock(nodelist_mutex);
         __TBB_ASSERT(my_nodes && my_nodes_last, "graph::remove_node: Error: no registered nodes");
@@ -1006,33 +840,68 @@ inline void graph::remove_node(graph_node *n) {
     n->prev = n->next = NULL;
 }
 
-inline void graph::reset( reset_flags f ) {
+inline void graph::reset( tbb::flow::interface11::reset_flags f ) {
     // reset context
-    set_active(false);
+    tbb::flow::interface11::internal::deactivate_graph(*this);
+
     if(my_context) my_context->reset();
     cancelled = false;
     caught_exception = false;
     // reset all the nodes comprising the graph
     for(iterator ii = begin(); ii != end(); ++ii) {
-        graph_node *my_p = &(*ii);
+        tbb::flow::interface11::graph_node *my_p = &(*ii);
         my_p->reset_node(f);
     }
     // Reattach the arena. Might be useful to run the graph in a particular task_arena
     // while not limiting graph lifetime to a single task_arena::execute() call.
     prepare_task_arena( /*reinit=*/true );
-    set_active(true);
+    tbb::flow::interface11::internal::activate_graph(*this);
     // now spawn the tasks necessary to start the graph
     for(task_list_type::iterator rti = my_reset_task_list.begin(); rti != my_reset_task_list.end(); ++rti) {
-        FLOW_SPAWN(*(*rti));
+        tbb::flow::interface11::internal::spawn_in_graph_arena(*this, *(*rti));
     }
     my_reset_task_list.clear();
 }
 
+inline graph::iterator graph::begin() { return iterator(this, true); }
+
+inline graph::iterator graph::end() { return iterator(this, false); }
+
+inline graph::const_iterator graph::begin() const { return const_iterator(this, true); }
+
+inline graph::const_iterator graph::end() const { return const_iterator(this, false); }
+
+inline graph::const_iterator graph::cbegin() const { return const_iterator(this, true); }
+
+inline graph::const_iterator graph::cend() const { return const_iterator(this, false); }
+
+#if TBB_PREVIEW_FLOW_GRAPH_TRACE
+inline void graph::set_name(const char *name) {
+    tbb::internal::fgt_graph_desc(this, name);
+}
+#endif
+
+} // namespace interface10
+
+namespace interface11 {
+
+inline graph_node::graph_node(graph& g) : my_graph(g) {
+    my_graph.register_node(this);
+}
+
+inline graph_node::~graph_node() {
+    my_graph.remove_node(this);
+}
+
 #include "internal/_flow_graph_node_impl.h"
 
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+using internal::node_set;
+#endif
+
 //! An executable node that acts as a source, i.e. it has no predecessors
 template < typename Output >
-class source_node : public graph_node, public sender< Output > {
+class input_node : public graph_node, public sender< Output > {
 public:
     //! The type of the output message, which is complete
     typedef Output output_type;
@@ -1043,33 +912,326 @@ class source_node : public graph_node, public sender< Output > {
     //Source node has no input type
     typedef null_type input_type;
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
     typedef typename sender<output_type>::built_successors_type built_successors_type;
     typedef typename sender<output_type>::successor_list_type successor_list_type;
 #endif
 
     //! Constructor for a node with a successor
     template< typename Body >
-    source_node( graph &g, Body body, bool is_active = true )
-        : graph_node(g), my_active(is_active), init_my_active(is_active),
-        my_body( new internal::source_body_leaf< output_type, Body>(body) ),
+     __TBB_NOINLINE_SYM input_node( graph &g, Body body )
+        : graph_node(g), my_active(false),
+        my_body( new internal::input_body_leaf< output_type, Body>(body) ),
+        my_init_body( new internal::input_body_leaf< output_type, Body>(body) ),
+        my_reserved(false), my_has_cached_item(false)
+    {
+        my_successors.set_owner(this);
+        tbb::internal::fgt_node_with_body( CODEPTR(), tbb::internal::FLOW_SOURCE_NODE, &this->my_graph,
+                                           static_cast<sender<output_type> *>(this), this->my_body );
+    }
+
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+    template <typename Body, typename... Successors>
+    input_node( const node_set<internal::order::preceding, Successors...>& successors, Body body )
+        : input_node(successors.graph_reference(), body) {
+        make_edges(*this, successors);
+    }
+#endif
+
+    //! Copy constructor
+    __TBB_NOINLINE_SYM input_node( const input_node& src ) :
+        graph_node(src.my_graph), sender<Output>(),
+        my_active(false),
+        my_body( src.my_init_body->clone() ), my_init_body(src.my_init_body->clone() ),
+        my_reserved(false), my_has_cached_item(false)
+    {
+        my_successors.set_owner(this);
+        tbb::internal::fgt_node_with_body(CODEPTR(), tbb::internal::FLOW_SOURCE_NODE, &this->my_graph,
+                                           static_cast<sender<output_type> *>(this), this->my_body );
+    }
+
+    //! The destructor
+    ~input_node() { delete my_body; delete my_init_body; }
+
+#if TBB_PREVIEW_FLOW_GRAPH_TRACE
+    void set_name( const char *name ) __TBB_override {
+        tbb::internal::fgt_node_desc( this, name );
+    }
+#endif
+
+    //! Add a new successor to this node
+    bool register_successor( successor_type &r ) __TBB_override {
+        spin_mutex::scoped_lock lock(my_mutex);
+        my_successors.register_successor(r);
+        if ( my_active )
+            spawn_put();
+        return true;
+    }
+
+    //! Removes a successor from this node
+    bool remove_successor( successor_type &r ) __TBB_override {
+        spin_mutex::scoped_lock lock(my_mutex);
+        my_successors.remove_successor(r);
+        return true;
+    }
+
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
+
+    built_successors_type &built_successors() __TBB_override { return my_successors.built_successors(); }
+
+    void internal_add_built_successor( successor_type &r) __TBB_override {
+        spin_mutex::scoped_lock lock(my_mutex);
+        my_successors.internal_add_built_successor(r);
+    }
+
+    void internal_delete_built_successor( successor_type &r) __TBB_override {
+        spin_mutex::scoped_lock lock(my_mutex);
+        my_successors.internal_delete_built_successor(r);
+    }
+
+    size_t successor_count() __TBB_override {
+        spin_mutex::scoped_lock lock(my_mutex);
+        return my_successors.successor_count();
+    }
+
+    void copy_successors(successor_list_type &v) __TBB_override {
+        spin_mutex::scoped_lock l(my_mutex);
+        my_successors.copy_successors(v);
+    }
+#endif  /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
+
+    //! Request an item from the node
+    bool try_get( output_type &v ) __TBB_override {
+        spin_mutex::scoped_lock lock(my_mutex);
+        if ( my_reserved )
+            return false;
+
+        if ( my_has_cached_item ) {
+            v = my_cached_item;
+            my_has_cached_item = false;
+            return true;
+        }
+        // we've been asked to provide an item, but we have none.  enqueue a task to
+        // provide one.
+        if ( my_active )
+            spawn_put();
+        return false;
+    }
+
+    //! Reserves an item.
+    bool try_reserve( output_type &v ) __TBB_override {
+        spin_mutex::scoped_lock lock(my_mutex);
+        if ( my_reserved ) {
+            return false;
+        }
+
+        if ( my_has_cached_item ) {
+            v = my_cached_item;
+            my_reserved = true;
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    //! Release a reserved item.
+    /** true = item has been released and so remains in sender, dest must request or reserve future items */
+    bool try_release( ) __TBB_override {
+        spin_mutex::scoped_lock lock(my_mutex);
+        __TBB_ASSERT( my_reserved && my_has_cached_item, "releasing non-existent reservation" );
+        my_reserved = false;
+        if(!my_successors.empty())
+            spawn_put();
+        return true;
+    }
+
+    //! Consumes a reserved item
+    bool try_consume( ) __TBB_override {
+        spin_mutex::scoped_lock lock(my_mutex);
+        __TBB_ASSERT( my_reserved && my_has_cached_item, "consuming non-existent reservation" );
+        my_reserved = false;
+        my_has_cached_item = false;
+        if ( !my_successors.empty() ) {
+            spawn_put();
+        }
+        return true;
+    }
+
+    //! Activates a node that was created in the inactive state
+    void activate() {
+        spin_mutex::scoped_lock lock(my_mutex);
+        my_active = true;
+        if (!my_successors.empty())
+            spawn_put();
+    }
+
+    template<typename Body>
+    Body copy_function_object() {
+        internal::input_body<output_type> &body_ref = *this->my_body;
+        return dynamic_cast< internal::input_body_leaf<output_type, Body> & >(body_ref).get_body();
+    }
+
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
+    void extract( ) __TBB_override {
+        my_successors.built_successors().sender_extract(*this);   // removes "my_owner" == this from each successor
+        my_active = false;
+        my_reserved = false;
+        if(my_has_cached_item) my_has_cached_item = false;
+    }
+#endif
+
+protected:
+
+    //! resets the input_node to its initial state
+    void reset_node( reset_flags f) __TBB_override {
+        my_active = false;
+        my_reserved = false;
+        my_has_cached_item = false;
+
+        if(f & rf_clear_edges) my_successors.clear();
+        if(f & rf_reset_bodies) {
+            internal::input_body<output_type> *tmp = my_init_body->clone();
+            delete my_body;
+            my_body = tmp;
+        }
+    }
+
+private:
+    spin_mutex my_mutex;
+    bool my_active;
+    internal::input_body<output_type> *my_body;
+    internal::input_body<output_type> *my_init_body;
+    internal::broadcast_cache< output_type > my_successors;
+    bool my_reserved;
+    bool my_has_cached_item;
+    output_type my_cached_item;
+
+    // used by apply_body_bypass, can invoke body of node.
+    bool try_reserve_apply_body(output_type &v) {
+        spin_mutex::scoped_lock lock(my_mutex);
+        if ( my_reserved ) {
+            return false;
+        }
+        if ( !my_has_cached_item ) {
+            tbb::internal::fgt_begin_body( my_body );
+
+#if TBB_DEPRECATED_INPUT_NODE_BODY
+            bool r = (*my_body)(my_cached_item);
+            if (r) {
+                my_has_cached_item = true;
+            }
+#else
+            flow_control control;
+            my_cached_item = (*my_body)(control);
+            my_has_cached_item = !control.is_pipeline_stopped;
+#endif
+            tbb::internal::fgt_end_body( my_body );
+        }
+        if ( my_has_cached_item ) {
+            v = my_cached_item;
+            my_reserved = true;
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    task* create_put_task() {
+        return ( new ( task::allocate_additional_child_of( *(this->my_graph.root_task()) ) )
+                        internal:: source_task_bypass < input_node< output_type > >( *this ) );
+    }
+
+    //! Spawns a task that applies the body
+    void spawn_put( ) {
+        if(internal::is_graph_active(this->my_graph)) {
+            internal::spawn_in_graph_arena(this->my_graph, *create_put_task());
+        }
+    }
+
+    friend class internal::source_task_bypass< input_node< output_type > >;
+    //! Applies the body.  Returning SUCCESSFULLY_ENQUEUED okay; forward_task_bypass will handle it.
+    task * apply_body_bypass( ) {
+        output_type v;
+        if ( !try_reserve_apply_body(v) )
+            return NULL;
+
+        task *last_task = my_successors.try_put_task(v);
+        if ( last_task )
+            try_consume();
+        else
+            try_release();
+        return last_task;
+    }
+};  // class input_node
+
+#if TBB_USE_SOURCE_NODE_AS_ALIAS
+template < typename Output >
+class source_node : public input_node <Output> {
+public:
+    //! Constructor for a node with a successor
+    template< typename Body >
+     __TBB_NOINLINE_SYM source_node( graph &g, Body body )
+         : input_node<Output>(g, body)
+    {
+    }
+
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+    template <typename Body, typename... Successors>
+    source_node( const node_set<internal::order::preceding, Successors...>& successors, Body body )
+        : input_node<Output>(successors, body) {
+     }
+#endif
+};
+#else // TBB_USE_SOURCE_NODE_AS_ALIAS
+//! An executable node that acts as a source, i.e. it has no predecessors
+template < typename Output > class
+__TBB_DEPRECATED_MSG("TBB Warning: tbb::flow::source_node is deprecated, use tbb::flow::input_node." )
+source_node : public graph_node, public sender< Output > {
+public:
+    //! The type of the output message, which is complete
+    typedef Output output_type;
+
+    //! The type of successors of this node
+    typedef typename sender<output_type>::successor_type successor_type;
+
+    //Source node has no input type
+    typedef null_type input_type;
+
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
+    typedef typename sender<output_type>::built_successors_type built_successors_type;
+    typedef typename sender<output_type>::successor_list_type successor_list_type;
+#endif
+
+    //! Constructor for a node with a successor
+    template< typename Body >
+     __TBB_NOINLINE_SYM source_node( graph &g, Body body, bool is_active = true )
+        : graph_node(g), my_active(is_active), init_my_active(is_active),
+        my_body( new internal::source_body_leaf< output_type, Body>(body) ),
         my_init_body( new internal::source_body_leaf< output_type, Body>(body) ),
         my_reserved(false), my_has_cached_item(false)
     {
         my_successors.set_owner(this);
-        tbb::internal::fgt_node_with_body( tbb::internal::FLOW_SOURCE_NODE, &this->my_graph,
+	tbb::internal::fgt_node_with_body( CODEPTR(), tbb::internal::FLOW_SOURCE_NODE, &this->my_graph,
                                            static_cast<sender<output_type> *>(this), this->my_body );
     }
 
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+    template <typename Body, typename... Successors>
+    source_node( const node_set<internal::order::preceding, Successors...>& successors, Body body, bool is_active = true )
+        : source_node(successors.graph_reference(), body, is_active) {
+        make_edges(*this, successors);
+    }
+#endif
+
     //! Copy constructor
-    source_node( const source_node& src ) :
+    __TBB_NOINLINE_SYM source_node( const source_node& src ) :
         graph_node(src.my_graph), sender<Output>(),
         my_active(src.init_my_active),
         init_my_active(src.init_my_active), my_body( src.my_init_body->clone() ), my_init_body(src.my_init_body->clone() ),
         my_reserved(false), my_has_cached_item(false)
     {
         my_successors.set_owner(this);
-        tbb::internal::fgt_node_with_body( tbb::internal::FLOW_SOURCE_NODE, &this->my_graph,
+        tbb::internal::fgt_node_with_body(CODEPTR(), tbb::internal::FLOW_SOURCE_NODE, &this->my_graph,
                                            static_cast<sender<output_type> *>(this), this->my_body );
     }
 
@@ -1098,7 +1260,7 @@ class source_node : public graph_node, public sender< Output > {
         return true;
     }
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
 
     built_successors_type &built_successors() __TBB_override { return my_successors.built_successors(); }
 
@@ -1121,7 +1283,7 @@ class source_node : public graph_node, public sender< Output > {
         spin_mutex::scoped_lock l(my_mutex);
         my_successors.copy_successors(v);
     }
-#endif  /* TBB_PREVIEW_FLOW_GRAPH_FEATURES */
+#endif  /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
 
     //! Request an item from the node
     bool try_get( output_type &v ) __TBB_override {
@@ -1183,7 +1345,7 @@ class source_node : public graph_node, public sender< Output > {
     void activate() {
         spin_mutex::scoped_lock lock(my_mutex);
         my_active = true;
-        if ( !my_successors.empty() )
+        if (!my_successors.empty())
             spawn_put();
     }
 
@@ -1193,7 +1355,7 @@ class source_node : public graph_node, public sender< Output > {
         return dynamic_cast< internal::source_body_leaf<output_type, Body> & >(body_ref).get_body();
     }
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
     void extract( ) __TBB_override {
         my_successors.built_successors().sender_extract(*this);   // removes "my_owner" == this from each successor
         my_active = init_my_active;
@@ -1218,7 +1380,7 @@ class source_node : public graph_node, public sender< Output > {
             my_body = tmp;
         }
         if(my_active)
-            this->my_graph.add_task_to_reset_list(create_put_task());
+            internal::add_task_to_graph_reset_list(this->my_graph, create_put_task());
     }
 
 private:
@@ -1266,8 +1428,8 @@ class source_node : public graph_node, public sender< Output > {
 
     //! Spawns a task that applies the body
     void spawn_put( ) {
-        if(this->my_graph.is_active()) {
-            FLOW_SPAWN( *create_put_task());
+        if(internal::is_graph_active(this->my_graph)) {
+            internal::spawn_in_graph_arena(this->my_graph, *create_put_task());
         }
     }
 
@@ -1286,52 +1448,90 @@ class source_node : public graph_node, public sender< Output > {
         return last_task;
     }
 };  // class source_node
+#endif // TBB_USE_SOURCE_NODE_AS_ALIAS
 
-template<typename T>
-struct allocate_buffer {
-    static const bool value = false;
-};
+//! Implements a function node that supports Input -> Output
+template<typename Input, typename Output = continue_msg, typename Policy = queueing,
+         typename Allocator=__TBB_DEFAULT_NODE_ALLOCATOR(Input)>
+class function_node
+    : public graph_node
+#if TBB_DEPRECATED_FLOW_NODE_ALLOCATOR
+    , public internal::function_input< Input, Output, Policy, Allocator >
+#else
+    , public internal::function_input< Input, Output, Policy, cache_aligned_allocator<Input> >
+#endif
+    , public internal::function_output<Output> {
 
-template<>
-struct allocate_buffer<queueing> {
-    static const bool value = true;
-};
+#if TBB_DEPRECATED_FLOW_NODE_ALLOCATOR
+    typedef Allocator internals_allocator;
+#else
+    typedef cache_aligned_allocator<Input> internals_allocator;
+
+    __TBB_STATIC_ASSERT(
+        (tbb::internal::is_same_type<Allocator, null_type>::value),
+        "Allocator template parameter for flow graph nodes is deprecated and will be removed. "
+        "Specify TBB_DEPRECATED_FLOW_NODE_ALLOCATOR to temporary enable the deprecated interface."
+    );
+#endif
 
-//! Implements a function node that supports Input -> Output
-template < typename Input, typename Output = continue_msg, typename Policy = queueing, typename Allocator=cache_aligned_allocator<Input> >
-class function_node : public graph_node, public internal::function_input<Input,Output,Allocator>, public internal::function_output<Output> {
 public:
     typedef Input input_type;
     typedef Output output_type;
-    typedef internal::function_input<input_type,output_type,Allocator> fInput_type;
-    typedef internal::function_input_queue<input_type, Allocator> input_queue_type;
+    typedef internal::function_input<input_type,output_type,Policy,internals_allocator> input_impl_type;
+    typedef internal::function_input_queue<input_type, internals_allocator> input_queue_type;
     typedef internal::function_output<output_type> fOutput_type;
-    typedef typename fInput_type::predecessor_type predecessor_type;
+    typedef typename input_impl_type::predecessor_type predecessor_type;
     typedef typename fOutput_type::successor_type successor_type;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
-    typedef typename fInput_type::predecessor_list_type predecessor_list_type;
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
+    typedef typename input_impl_type::predecessor_list_type predecessor_list_type;
     typedef typename fOutput_type::successor_list_type successor_list_type;
 #endif
-    using fInput_type::my_predecessors;
+    using input_impl_type::my_predecessors;
 
     //! Constructor
     // input_queue_type is allocated here, but destroyed in the function_input_base.
     // TODO: pass the graph_buffer_policy to the function_input_base so it can all
     // be done in one place.  This would be an interface-breaking change.
     template< typename Body >
-    function_node( graph &g, size_t concurrency, Body body ) :
-        graph_node(g), fInput_type(g, concurrency, body, allocate_buffer<Policy>::value ?
-               new input_queue_type( ) : NULL ) {
-        tbb::internal::fgt_node_with_body( tbb::internal::FLOW_FUNCTION_NODE, &this->my_graph,
+     __TBB_NOINLINE_SYM function_node( graph &g, size_t concurrency,
+#if __TBB_CPP11_PRESENT
+                   Body body, __TBB_FLOW_GRAPH_PRIORITY_ARG1( Policy = Policy(), node_priority_t priority = tbb::flow::internal::no_priority ))
+#else
+                   __TBB_FLOW_GRAPH_PRIORITY_ARG1( Body body, node_priority_t priority = tbb::flow::internal::no_priority ))
+#endif
+        : graph_node(g), input_impl_type(g, concurrency, __TBB_FLOW_GRAPH_PRIORITY_ARG1(body, priority)),
+          fOutput_type(g) {
+        tbb::internal::fgt_node_with_body( CODEPTR(), tbb::internal::FLOW_FUNCTION_NODE, &this->my_graph,
                 static_cast<receiver<input_type> *>(this), static_cast<sender<output_type> *>(this), this->my_body );
     }
 
+#if __TBB_PREVIEW_FLOW_GRAPH_PRIORITIES && __TBB_CPP11_PRESENT
+    template <typename Body>
+    function_node( graph& g, size_t concurrency, Body body, node_priority_t priority )
+        : function_node(g, concurrency, body, Policy(), priority) {}
+#endif // __TBB_PREVIEW_FLOW_GRAPH_PRIORITIES && __TBB_CPP11_PRESENT
+
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+    template <typename Body, typename... Args>
+    function_node( const node_set<Args...>& nodes, size_t concurrency, Body body,
+                   __TBB_FLOW_GRAPH_PRIORITY_ARG1( Policy p = Policy(), node_priority_t priority = tbb::flow::internal::no_priority ))
+        : function_node(nodes.graph_reference(), concurrency, body, __TBB_FLOW_GRAPH_PRIORITY_ARG1(p, priority)) {
+        make_edges_in_order(nodes, *this);
+    }
+
+#if __TBB_PREVIEW_FLOW_GRAPH_PRIORITIES
+    template <typename Body, typename... Args>
+    function_node( const node_set<Args...>& nodes, size_t concurrency, Body body, node_priority_t priority )
+        : function_node(nodes, concurrency, body, Policy(), priority) {}
+#endif // __TBB_PREVIEW_FLOW_GRAPH_PRIORITIES
+#endif // __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+
     //! Copy constructor
-    function_node( const function_node& src ) :
+    __TBB_NOINLINE_SYM function_node( const function_node& src ) :
         graph_node(src.my_graph),
-        fInput_type(src, allocate_buffer<Policy>::value ? new input_queue_type : NULL),
-        fOutput_type() {
-        tbb::internal::fgt_node_with_body( tbb::internal::FLOW_FUNCTION_NODE, &this->my_graph,
+        input_impl_type(src),
+        fOutput_type(src.my_graph) {
+        tbb::internal::fgt_node_with_body( CODEPTR(), tbb::internal::FLOW_FUNCTION_NODE, &this->my_graph,
                 static_cast<receiver<input_type> *>(this), static_cast<sender<output_type> *>(this), this->my_body );
     }
 
@@ -1341,7 +1541,7 @@ class function_node : public graph_node, public internal::function_input<Input,O
     }
 #endif
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
     void extract( ) __TBB_override {
         my_predecessors.built_predecessors().receiver_extract(*this);
         successors().built_successors().sender_extract(*this);
@@ -1352,12 +1552,12 @@ class function_node : public graph_node, public internal::function_input<Input,O
     template< typename R, typename B > friend class run_and_put_task;
     template<typename X, typename Y> friend class internal::broadcast_cache;
     template<typename X, typename Y> friend class internal::round_robin_cache;
-    using fInput_type::try_put_task;
+    using input_impl_type::try_put_task;
 
     internal::broadcast_cache<output_type> &successors () __TBB_override { return fOutput_type::my_successors; }
 
     void reset_node(reset_flags f) __TBB_override {
-        fInput_type::reset_function_input(f);
+        input_impl_type::reset_function_input(f);
         // TODO: use clear() instead.
         if(f & rf_clear_edges) {
             successors().clear();
@@ -1371,7 +1571,8 @@ class function_node : public graph_node, public internal::function_input<Input,O
 
 //! implements a function node that supports Input -> (set of outputs)
 // Output is a tuple of output types.
-template < typename Input, typename Output, typename Policy = queueing, typename Allocator=cache_aligned_allocator<Input> >
+template<typename Input, typename Output, typename Policy = queueing,
+         typename Allocator=__TBB_DEFAULT_NODE_ALLOCATOR(Input)>
 class multifunction_node :
     public graph_node,
     public internal::multifunction_input
@@ -1382,31 +1583,77 @@ class multifunction_node :
             internal::multifunction_output,  // wrap this around each element
             Output // the tuple providing the types
         >::type,
+        Policy,
+#if TBB_DEPRECATED_FLOW_NODE_ALLOCATOR
         Allocator
+#else
+        cache_aligned_allocator<Input>
+#endif
     > {
+#if TBB_DEPRECATED_FLOW_NODE_ALLOCATOR
+    typedef Allocator internals_allocator;
+#else
+    typedef cache_aligned_allocator<Input> internals_allocator;
+
+    __TBB_STATIC_ASSERT(
+        (tbb::internal::is_same_type<Allocator, null_type>::value),
+        "Allocator template parameter for flow graph nodes is deprecated and will be removed. "
+        "Specify TBB_DEPRECATED_FLOW_NODE_ALLOCATOR to temporary enable the deprecated interface."
+    );
+#endif
+
 protected:
     static const int N = tbb::flow::tuple_size<Output>::value;
 public:
     typedef Input input_type;
     typedef null_type output_type;
     typedef typename internal::wrap_tuple_elements<N,internal::multifunction_output, Output>::type output_ports_type;
-    typedef internal::multifunction_input<input_type, output_ports_type, Allocator> fInput_type;
-    typedef internal::function_input_queue<input_type, Allocator> input_queue_type;
+    typedef internal::multifunction_input<
+        input_type, output_ports_type, Policy, internals_allocator> input_impl_type;
+    typedef internal::function_input_queue<input_type, internals_allocator> input_queue_type;
 private:
-    typedef typename internal::multifunction_input<input_type, output_ports_type, Allocator> base_type;
-    using fInput_type::my_predecessors;
+    using input_impl_type::my_predecessors;
 public:
     template<typename Body>
-    multifunction_node( graph &g, size_t concurrency, Body body ) :
-        graph_node(g), base_type(g,concurrency, body,  allocate_buffer<Policy>::value ? new input_queue_type : NULL) {
-        tbb::internal::fgt_multioutput_node_with_body<N>( tbb::internal::FLOW_MULTIFUNCTION_NODE,
-                &this->my_graph, static_cast<receiver<input_type> *>(this),
-                this->output_ports(), this->my_body );
-    }
-
-    multifunction_node( const multifunction_node &other) :
-        graph_node(other.my_graph), base_type(other,  allocate_buffer<Policy>::value ? new input_queue_type : NULL) {
-        tbb::internal::fgt_multioutput_node_with_body<N>( tbb::internal::FLOW_MULTIFUNCTION_NODE,
+    __TBB_NOINLINE_SYM multifunction_node(
+        graph &g, size_t concurrency,
+#if __TBB_CPP11_PRESENT
+        Body body, __TBB_FLOW_GRAPH_PRIORITY_ARG1( Policy = Policy(), node_priority_t priority = tbb::flow::internal::no_priority )
+#else
+        __TBB_FLOW_GRAPH_PRIORITY_ARG1(Body body, node_priority_t priority = tbb::flow::internal::no_priority)
+#endif
+    ) : graph_node(g), input_impl_type(g, concurrency, __TBB_FLOW_GRAPH_PRIORITY_ARG1(body, priority)) {
+        tbb::internal::fgt_multioutput_node_with_body<N>(
+            CODEPTR(), tbb::internal::FLOW_MULTIFUNCTION_NODE,
+            &this->my_graph, static_cast<receiver<input_type> *>(this),
+            this->output_ports(), this->my_body
+        );
+    }
+
+#if __TBB_PREVIEW_FLOW_GRAPH_PRIORITIES && __TBB_CPP11_PRESENT
+    template <typename Body>
+    __TBB_NOINLINE_SYM multifunction_node(graph& g, size_t concurrency, Body body, node_priority_t priority)
+        : multifunction_node(g, concurrency, body, Policy(), priority) {}
+#endif // TBB_PREVIEW_FLOW_GRAPH_PRIORITIES && __TBB_CPP11_PRESENT
+
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+    template <typename Body, typename... Args>
+    __TBB_NOINLINE_SYM multifunction_node(const node_set<Args...>& nodes, size_t concurrency, Body body,
+                       __TBB_FLOW_GRAPH_PRIORITY_ARG1(Policy p = Policy(), node_priority_t priority = tbb::flow::internal::no_priority))
+        : multifunction_node(nodes.graph_reference(), concurrency, body, __TBB_FLOW_GRAPH_PRIORITY_ARG1(p, priority)) {
+        make_edges_in_order(nodes, *this);
+    }
+
+#if __TBB_PREVIEW_FLOW_GRAPH_PRIORITIES
+    template <typename Body, typename... Args>
+    __TBB_NOINLINE_SYM multifunction_node(const node_set<Args...>& nodes, size_t concurrency, Body body, node_priority_t priority)
+        : multifunction_node(nodes, concurrency, body, Policy(), priority) {}
+#endif // __TBB_PREVIEW_FLOW_GRAPH_PRIORITIES
+#endif // __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+
+    __TBB_NOINLINE_SYM multifunction_node( const multifunction_node &other) :
+        graph_node(other.my_graph), input_impl_type(other) {
+        tbb::internal::fgt_multioutput_node_with_body<N>( CODEPTR(), tbb::internal::FLOW_MULTIFUNCTION_NODE,
                 &this->my_graph, static_cast<receiver<input_type> *>(this),
                 this->output_ports(), this->my_body );
     }
@@ -1417,27 +1664,35 @@ class multifunction_node :
     }
 #endif
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
     void extract( ) __TBB_override {
         my_predecessors.built_predecessors().receiver_extract(*this);
-        base_type::extract();
+        input_impl_type::extract();
     }
 #endif
     // all the guts are in multifunction_input...
 protected:
-    void reset_node(reset_flags f) __TBB_override { base_type::reset(f); }
+    void reset_node(reset_flags f) __TBB_override { input_impl_type::reset(f); }
 };  // multifunction_node
 
 //! split_node: accepts a tuple as input, forwards each element of the tuple to its
 //  successors.  The node has unlimited concurrency, so it does not reject inputs.
-template<typename TupleType, typename Allocator=cache_aligned_allocator<TupleType> >
+template<typename TupleType, typename Allocator=__TBB_DEFAULT_NODE_ALLOCATOR(TupleType)>
 class split_node : public graph_node, public receiver<TupleType> {
     static const int N = tbb::flow::tuple_size<TupleType>::value;
     typedef receiver<TupleType> base_type;
 public:
     typedef TupleType input_type;
+#if TBB_DEPRECATED_FLOW_NODE_ALLOCATOR
     typedef Allocator allocator_type;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#else
+    __TBB_STATIC_ASSERT(
+        (tbb::internal::is_same_type<Allocator, null_type>::value),
+        "Allocator template parameter for flow graph nodes is deprecated and will be removed. "
+        "Specify TBB_DEPRECATED_FLOW_NODE_ALLOCATOR to temporary enable the deprecated interface."
+    );
+#endif
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
     typedef typename base_type::predecessor_type predecessor_type;
     typedef typename base_type::predecessor_list_type predecessor_list_type;
     typedef internal::predecessor_cache<input_type, null_mutex > predecessor_cache_type;
@@ -1450,14 +1705,26 @@ class split_node : public graph_node, public receiver<TupleType> {
             TupleType // the tuple providing the types
         >::type  output_ports_type;
 
-    explicit split_node(graph &g) : graph_node(g)
+    __TBB_NOINLINE_SYM explicit split_node(graph &g)
+        : graph_node(g),
+          my_output_ports(internal::init_output_ports<output_ports_type>::call(g, my_output_ports))
     {
-        tbb::internal::fgt_multioutput_node<N>(tbb::internal::FLOW_SPLIT_NODE, &this->my_graph,
+        tbb::internal::fgt_multioutput_node<N>(CODEPTR(), tbb::internal::FLOW_SPLIT_NODE, &this->my_graph,
             static_cast<receiver<input_type> *>(this), this->output_ports());
     }
-    split_node( const split_node & other) : graph_node(other.my_graph), base_type(other)
+
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+    template <typename... Args>
+    __TBB_NOINLINE_SYM split_node(const node_set<Args...>& nodes) : split_node(nodes.graph_reference()) {
+        make_edges_in_order(nodes, *this);
+    }
+#endif
+
+    __TBB_NOINLINE_SYM split_node(const split_node& other)
+        : graph_node(other.my_graph), base_type(other),
+          my_output_ports(internal::init_output_ports<output_ports_type>::call(other.my_graph, my_output_ports))
     {
-        tbb::internal::fgt_multioutput_node<N>(tbb::internal::FLOW_SPLIT_NODE, &this->my_graph,
+        tbb::internal::fgt_multioutput_node<N>(CODEPTR(), tbb::internal::FLOW_SPLIT_NODE, &this->my_graph,
             static_cast<receiver<input_type> *>(this), this->output_ports());
     }
 
@@ -1471,11 +1738,9 @@ class split_node : public graph_node, public receiver<TupleType> {
 
 protected:
     task *try_put_task(const TupleType& t) __TBB_override {
-        // Sending split messages in parallel is not justified, as overheads would prevail
-        internal::emit_element<N>::emit_this(t, output_ports());
-
-        //we do not have successors here.So we just tell the task is successful.
-        return SUCCESSFULLY_ENQUEUED;
+        // Sending split messages in parallel is not justified, as overheads would prevail.
+        // Also, we do not have successors here. So we just tell the task returned here is successful.
+        return internal::emit_element<N>::emit_this(this->my_graph, t, output_ports());
     }
     void reset_node(reset_flags f) __TBB_override {
         if (f & rf_clear_edges)
@@ -1484,8 +1749,10 @@ class split_node : public graph_node, public receiver<TupleType> {
         __TBB_ASSERT(!(f & rf_clear_edges) || internal::clear_element<N>::this_empty(my_output_ports), "split_node reset failed");
     }
     void reset_receiver(reset_flags /*f*/) __TBB_override {}
-
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+    graph& graph_reference() const __TBB_override {
+        return my_graph;
+    }
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
 private: //! split_node doesn't use this "predecessors" functionality; so, we have "dummies" here;
     void extract() __TBB_override {}
 
@@ -1497,270 +1764,113 @@ class split_node : public graph_node, public receiver<TupleType> {
 
     size_t predecessor_count() __TBB_override { return 0; }
 
-    void copy_predecessors(predecessor_list_type&) __TBB_override {}
-
-    built_predecessors_type &built_predecessors() __TBB_override { return my_predessors; }
-
-    //! dummy member
-    built_predecessors_type my_predessors;
-#endif  /* TBB_PREVIEW_FLOW_GRAPH_FEATURES */
-
-private:
-    output_ports_type my_output_ports;
-};
-
-//! Implements an executable node that supports continue_msg -> Output
-template <typename Output>
-class continue_node : public graph_node, public internal::continue_input<Output>, public internal::function_output<Output> {
-public:
-    typedef continue_msg input_type;
-    typedef Output output_type;
-    typedef internal::continue_input<Output> fInput_type;
-    typedef internal::function_output<output_type> fOutput_type;
-    typedef typename fInput_type::predecessor_type predecessor_type;
-    typedef typename fOutput_type::successor_type successor_type;
-
-    //! Constructor for executable node with continue_msg -> Output
-    template <typename Body >
-    continue_node( graph &g, Body body ) :
-        graph_node(g), internal::continue_input<output_type>( g, body ) {
-        tbb::internal::fgt_node_with_body( tbb::internal::FLOW_CONTINUE_NODE, &this->my_graph,
-                                           static_cast<receiver<input_type> *>(this),
-                                           static_cast<sender<output_type> *>(this), this->my_body );
-    }
-
-
-    //! Constructor for executable node with continue_msg -> Output
-    template <typename Body >
-    continue_node( graph &g, int number_of_predecessors, Body body ) :
-        graph_node(g), internal::continue_input<output_type>( g, number_of_predecessors, body ) {
-        tbb::internal::fgt_node_with_body( tbb::internal::FLOW_CONTINUE_NODE, &this->my_graph,
-                                           static_cast<receiver<input_type> *>(this),
-                                           static_cast<sender<output_type> *>(this), this->my_body );
-    }
-
-    //! Copy constructor
-    continue_node( const continue_node& src ) :
-        graph_node(src.my_graph), internal::continue_input<output_type>(src),
-        internal::function_output<Output>() {
-        tbb::internal::fgt_node_with_body( tbb::internal::FLOW_CONTINUE_NODE, &this->my_graph,
-                                           static_cast<receiver<input_type> *>(this),
-                                           static_cast<sender<output_type> *>(this), this->my_body );
-    }
-
-#if TBB_PREVIEW_FLOW_GRAPH_TRACE
-    void set_name( const char *name ) __TBB_override {
-        tbb::internal::fgt_node_desc( this, name );
-    }
-#endif
-
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
-    void extract() __TBB_override {
-        fInput_type::my_built_predecessors.receiver_extract(*this);
-        successors().built_successors().sender_extract(*this);
-    }
-#endif
-
-protected:
-    template< typename R, typename B > friend class run_and_put_task;
-    template<typename X, typename Y> friend class internal::broadcast_cache;
-    template<typename X, typename Y> friend class internal::round_robin_cache;
-    using fInput_type::try_put_task;
-    internal::broadcast_cache<output_type> &successors () __TBB_override { return fOutput_type::my_successors; }
-
-    void reset_node(reset_flags f) __TBB_override {
-        fInput_type::reset_receiver(f);
-        if(f & rf_clear_edges)successors().clear();
-        __TBB_ASSERT(!(f & rf_clear_edges) || successors().empty(), "continue_node not reset");
-    }
-};  // continue_node
-
-template< typename T >
-class overwrite_node : public graph_node, public receiver<T>, public sender<T> {
-public:
-    typedef T input_type;
-    typedef T output_type;
-    typedef typename receiver<input_type>::predecessor_type predecessor_type;
-    typedef typename sender<output_type>::successor_type successor_type;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
-    typedef typename receiver<input_type>::built_predecessors_type built_predecessors_type;
-    typedef typename sender<output_type>::built_successors_type built_successors_type;
-    typedef typename receiver<input_type>::predecessor_list_type predecessor_list_type;
-    typedef typename sender<output_type>::successor_list_type successor_list_type;
-#endif
-
-    explicit overwrite_node(graph &g) : graph_node(g), my_buffer_is_valid(false) {
-        my_successors.set_owner( this );
-        tbb::internal::fgt_node( tbb::internal::FLOW_OVERWRITE_NODE, &this->my_graph,
-                                 static_cast<receiver<input_type> *>(this), static_cast<sender<output_type> *>(this) );
-    }
-
-    // Copy constructor; doesn't take anything from src; default won't work
-    overwrite_node( const overwrite_node& src ) :
-        graph_node(src.my_graph), receiver<T>(), sender<T>(), my_buffer_is_valid(false)
-    {
-        my_successors.set_owner( this );
-        tbb::internal::fgt_node( tbb::internal::FLOW_OVERWRITE_NODE, &this->my_graph,
-                                 static_cast<receiver<input_type> *>(this), static_cast<sender<output_type> *>(this) );
-    }
-
-    ~overwrite_node() {}
-
-#if TBB_PREVIEW_FLOW_GRAPH_TRACE
-    void set_name( const char *name ) __TBB_override {
-        tbb::internal::fgt_node_desc( this, name );
-    }
-#endif
-
-    bool register_successor( successor_type &s ) __TBB_override {
-        spin_mutex::scoped_lock l( my_mutex );
-        if (my_buffer_is_valid && this->my_graph.is_active()) {
-            // We have a valid value that must be forwarded immediately.
-            if ( s.try_put( my_buffer ) || !s.register_predecessor( *this  ) ) {
-                // We add the successor: it accepted our put or it rejected it but won't let us become a predecessor
-                my_successors.register_successor( s );
-            } else {
-                // We don't add the successor: it rejected our put and we became its predecessor instead
-                return false;
-            }
-        } else {
-            // No valid value yet, just add as successor
-            my_successors.register_successor( s );
-        }
-        return true;
-    }
-
-    bool remove_successor( successor_type &s ) __TBB_override {
-        spin_mutex::scoped_lock l( my_mutex );
-        my_successors.remove_successor(s);
-        return true;
-    }
-
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
-    built_predecessors_type &built_predecessors() __TBB_override { return my_built_predecessors; }
-    built_successors_type   &built_successors()   __TBB_override { return my_successors.built_successors(); }
-
-    void internal_add_built_successor( successor_type &s) __TBB_override {
-        spin_mutex::scoped_lock l( my_mutex );
-        my_successors.internal_add_built_successor(s);
-    }
-
-    void internal_delete_built_successor( successor_type &s) __TBB_override {
-        spin_mutex::scoped_lock l( my_mutex );
-        my_successors.internal_delete_built_successor(s);
-    }
-
-    size_t successor_count() __TBB_override {
-        spin_mutex::scoped_lock l( my_mutex );
-        return my_successors.successor_count();
-    }
-
-    void copy_successors(successor_list_type &v) __TBB_override {
-        spin_mutex::scoped_lock l( my_mutex );
-        my_successors.copy_successors(v);
-    }
-
-    void internal_add_built_predecessor( predecessor_type &p) __TBB_override {
-        spin_mutex::scoped_lock l( my_mutex );
-        my_built_predecessors.add_edge(p);
-    }
-
-    void internal_delete_built_predecessor( predecessor_type &p) __TBB_override {
-        spin_mutex::scoped_lock l( my_mutex );
-        my_built_predecessors.delete_edge(p);
-    }
-
-    size_t predecessor_count() __TBB_override {
-        spin_mutex::scoped_lock l( my_mutex );
-        return my_built_predecessors.edge_count();
-    }
-
-    void copy_predecessors(predecessor_list_type &v) __TBB_override {
-        spin_mutex::scoped_lock l( my_mutex );
-        my_built_predecessors.copy_edges(v);
-    }
+    void copy_predecessors(predecessor_list_type&) __TBB_override {}
 
-    void extract() __TBB_override {
-        my_buffer_is_valid = false;
-        built_successors().sender_extract(*this);
-        built_predecessors().receiver_extract(*this);
-    }
+    built_predecessors_type &built_predecessors() __TBB_override { return my_predessors; }
 
-#endif  /* TBB_PREVIEW_FLOW_GRAPH_FEATURES */
+    //! dummy member
+    built_predecessors_type my_predessors;
+#endif  /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
 
-    bool try_get( input_type &v ) __TBB_override {
-        spin_mutex::scoped_lock l( my_mutex );
-        if ( my_buffer_is_valid ) {
-            v = my_buffer;
-            return true;
-        }
-        return false;
-    }
+private:
+    output_ports_type my_output_ports;
+};
 
-    bool is_valid() {
-       spin_mutex::scoped_lock l( my_mutex );
-       return my_buffer_is_valid;
-    }
+//! Implements an executable node that supports continue_msg -> Output
+template <typename Output, typename Policy = internal::Policy<void> >
+class continue_node : public graph_node, public internal::continue_input<Output, Policy>,
+                      public internal::function_output<Output> {
+public:
+    typedef continue_msg input_type;
+    typedef Output output_type;
+    typedef internal::continue_input<Output, Policy> input_impl_type;
+    typedef internal::function_output<output_type> fOutput_type;
+    typedef typename input_impl_type::predecessor_type predecessor_type;
+    typedef typename fOutput_type::successor_type successor_type;
 
-    void clear() {
-       spin_mutex::scoped_lock l( my_mutex );
-       my_buffer_is_valid = false;
-    }
+    //! Constructor for executable node with continue_msg -> Output
+    template <typename Body >
+    __TBB_NOINLINE_SYM continue_node(
+        graph &g,
+#if __TBB_CPP11_PRESENT
+        Body body, __TBB_FLOW_GRAPH_PRIORITY_ARG1( Policy = Policy(), node_priority_t priority = tbb::flow::internal::no_priority )
+#else
+        __TBB_FLOW_GRAPH_PRIORITY_ARG1( Body body, node_priority_t priority = tbb::flow::internal::no_priority )
+#endif
+    ) : graph_node(g), input_impl_type( g, __TBB_FLOW_GRAPH_PRIORITY_ARG1(body, priority) ),
+        fOutput_type(g) {
+        tbb::internal::fgt_node_with_body( CODEPTR(), tbb::internal::FLOW_CONTINUE_NODE, &this->my_graph,
 
-protected:
-    template< typename R, typename B > friend class run_and_put_task;
-    template<typename X, typename Y> friend class internal::broadcast_cache;
-    template<typename X, typename Y> friend class internal::round_robin_cache;
-    task * try_put_task( const input_type &v ) __TBB_override {
-        spin_mutex::scoped_lock l( my_mutex );
-        return try_put_task_impl(v);
+                                           static_cast<receiver<input_type> *>(this),
+                                           static_cast<sender<output_type> *>(this), this->my_body );
     }
 
-    task * try_put_task_impl(const input_type &v) {
-        my_buffer = v;
-        my_buffer_is_valid = true;
-        task * rtask = my_successors.try_put_task(v);
-        if (!rtask) rtask = SUCCESSFULLY_ENQUEUED;
-        return rtask;
+#if __TBB_PREVIEW_FLOW_GRAPH_PRIORITIES && __TBB_CPP11_PRESENT
+    template <typename Body>
+    continue_node( graph& g, Body body, node_priority_t priority )
+        : continue_node(g, body, Policy(), priority) {}
+#endif
+
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+    template <typename Body, typename... Args>
+    continue_node( const node_set<Args...>& nodes, Body body,
+                   __TBB_FLOW_GRAPH_PRIORITY_ARG1( Policy p = Policy(), node_priority_t priority = tbb::flow::internal::no_priority))
+        : continue_node(nodes.graph_reference(), body, __TBB_FLOW_GRAPH_PRIORITY_ARG1(p, priority) ) {
+        make_edges_in_order(nodes, *this);
     }
+#if __TBB_PREVIEW_FLOW_GRAPH_PRIORITIES
+    template <typename Body, typename... Args>
+    continue_node( const node_set<Args...>& nodes, Body body, node_priority_t priority)
+        : continue_node(nodes, body, Policy(), priority) {}
+#endif // __TBB_PREVIEW_FLOW_GRAPH_PRIORITIES
+#endif // __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
 
-    spin_mutex my_mutex;
-    internal::broadcast_cache< input_type, null_rw_mutex > my_successors;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
-    internal::edge_container<predecessor_type> my_built_predecessors;
+    //! Constructor for executable node with continue_msg -> Output
+    template <typename Body >
+    __TBB_NOINLINE_SYM continue_node(
+        graph &g, int number_of_predecessors,
+#if __TBB_CPP11_PRESENT
+        Body body, __TBB_FLOW_GRAPH_PRIORITY_ARG1( Policy = Policy(), node_priority_t priority = tbb::flow::internal::no_priority )
+#else
+        __TBB_FLOW_GRAPH_PRIORITY_ARG1( Body body, node_priority_t priority = tbb::flow::internal::no_priority )
 #endif
-    input_type my_buffer;
-    bool my_buffer_is_valid;
-    void reset_receiver(reset_flags /*f*/) __TBB_override {}
-
-    void reset_node( reset_flags f) __TBB_override {
-        my_buffer_is_valid = false;
-       if (f&rf_clear_edges) {
-           my_successors.clear();
-       }
+    ) : graph_node(g)
+      , input_impl_type(g, number_of_predecessors, __TBB_FLOW_GRAPH_PRIORITY_ARG1(body, priority)),
+        fOutput_type(g) {
+        tbb::internal::fgt_node_with_body( CODEPTR(), tbb::internal::FLOW_CONTINUE_NODE, &this->my_graph,
+                                           static_cast<receiver<input_type> *>(this),
+                                           static_cast<sender<output_type> *>(this), this->my_body );
     }
-};  // overwrite_node
 
-template< typename T >
-class write_once_node : public overwrite_node<T> {
-public:
-    typedef T input_type;
-    typedef T output_type;
-    typedef typename receiver<input_type>::predecessor_type predecessor_type;
-    typedef typename sender<output_type>::successor_type successor_type;
+#if __TBB_PREVIEW_FLOW_GRAPH_PRIORITIES && __TBB_CPP11_PRESENT
+    template <typename Body>
+    continue_node( graph& g, int number_of_predecessors, Body body, node_priority_t priority)
+        : continue_node(g, number_of_predecessors, body, Policy(), priority) {}
+#endif
 
-    //! Constructor
-    explicit write_once_node(graph& g) : overwrite_node<T>(g) {
-        tbb::internal::fgt_node( tbb::internal::FLOW_WRITE_ONCE_NODE, &(this->my_graph),
-                                 static_cast<receiver<input_type> *>(this),
-                                 static_cast<sender<output_type> *>(this) );
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+    template <typename Body, typename... Args>
+    continue_node( const node_set<Args...>& nodes, int number_of_predecessors,
+                   Body body, __TBB_FLOW_GRAPH_PRIORITY_ARG1( Policy p = Policy(), node_priority_t priority = tbb::flow::internal::no_priority ))
+        : continue_node(nodes.graph_reference(), number_of_predecessors, body, __TBB_FLOW_GRAPH_PRIORITY_ARG1(p, priority)) {
+        make_edges_in_order(nodes, *this);
     }
 
-    //! Copy constructor: call base class copy constructor
-    write_once_node( const write_once_node& src ) : overwrite_node<T>(src) {
-        tbb::internal::fgt_node( tbb::internal::FLOW_WRITE_ONCE_NODE, &(this->my_graph),
-                                 static_cast<receiver<input_type> *>(this),
-                                 static_cast<sender<output_type> *>(this) );
+#if __TBB_PREVIEW_FLOW_GRAPH_PRIORITIES
+    template <typename Body, typename... Args>
+    continue_node( const node_set<Args...>& nodes, int number_of_predecessors,
+                   Body body, node_priority_t priority )
+        : continue_node(nodes, number_of_predecessors, body, Policy(), priority) {}
+#endif
+#endif
+
+    //! Copy constructor
+    __TBB_NOINLINE_SYM continue_node( const continue_node& src ) :
+        graph_node(src.my_graph), input_impl_type(src),
+        internal::function_output<Output>(src.my_graph) {
+        tbb::internal::fgt_node_with_body( CODEPTR(), tbb::internal::FLOW_CONTINUE_NODE, &this->my_graph,
+                                           static_cast<receiver<input_type> *>(this),
+                                           static_cast<sender<output_type> *>(this), this->my_body );
     }
 
 #if TBB_PREVIEW_FLOW_GRAPH_TRACE
@@ -1769,15 +1879,26 @@ class write_once_node : public overwrite_node<T> {
     }
 #endif
 
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
+    void extract() __TBB_override {
+        input_impl_type::my_built_predecessors.receiver_extract(*this);
+        successors().built_successors().sender_extract(*this);
+    }
+#endif
+
 protected:
     template< typename R, typename B > friend class run_and_put_task;
     template<typename X, typename Y> friend class internal::broadcast_cache;
     template<typename X, typename Y> friend class internal::round_robin_cache;
-    task *try_put_task( const T &v ) __TBB_override {
-        spin_mutex::scoped_lock l( this->my_mutex );
-        return this->my_buffer_is_valid ? NULL : this->try_put_task_impl(v);
+    using input_impl_type::try_put_task;
+    internal::broadcast_cache<output_type> &successors () __TBB_override { return fOutput_type::my_successors; }
+
+    void reset_node(reset_flags f) __TBB_override {
+        input_impl_type::reset_receiver(f);
+        if(f & rf_clear_edges)successors().clear();
+        __TBB_ASSERT(!(f & rf_clear_edges) || successors().empty(), "continue_node not reset");
     }
-};
+};  // continue_node
 
 //! Forwards messages of type T to all successors
 template <typename T>
@@ -1787,30 +1908,37 @@ class broadcast_node : public graph_node, public receiver<T>, public sender<T> {
     typedef T output_type;
     typedef typename receiver<input_type>::predecessor_type predecessor_type;
     typedef typename sender<output_type>::successor_type successor_type;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
     typedef typename receiver<input_type>::predecessor_list_type predecessor_list_type;
     typedef typename sender<output_type>::successor_list_type successor_list_type;
 #endif
 private:
     internal::broadcast_cache<input_type> my_successors;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
     internal::edge_container<predecessor_type> my_built_predecessors;
     spin_mutex pred_mutex;  // serialize accesses on edge_container
 #endif
 public:
 
-    explicit broadcast_node(graph& g) : graph_node(g) {
+    __TBB_NOINLINE_SYM explicit broadcast_node(graph& g) : graph_node(g) {
         my_successors.set_owner( this );
-        tbb::internal::fgt_node( tbb::internal::FLOW_BROADCAST_NODE, &this->my_graph,
+        tbb::internal::fgt_node( CODEPTR(), tbb::internal::FLOW_BROADCAST_NODE, &this->my_graph,
                                  static_cast<receiver<input_type> *>(this), static_cast<sender<output_type> *>(this) );
     }
 
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+    template <typename... Args>
+    broadcast_node(const node_set<Args...>& nodes) : broadcast_node(nodes.graph_reference()) {
+        make_edges_in_order(nodes, *this);
+    }
+#endif
+
     // Copy constructor
-    broadcast_node( const broadcast_node& src ) :
+    __TBB_NOINLINE_SYM broadcast_node( const broadcast_node& src ) :
         graph_node(src.my_graph), receiver<T>(), sender<T>()
     {
         my_successors.set_owner( this );
-        tbb::internal::fgt_node( tbb::internal::FLOW_BROADCAST_NODE, &this->my_graph,
+        tbb::internal::fgt_node( CODEPTR(), tbb::internal::FLOW_BROADCAST_NODE, &this->my_graph,
                                  static_cast<receiver<input_type> *>(this), static_cast<sender<output_type> *>(this) );
     }
 
@@ -1832,7 +1960,7 @@ class broadcast_node : public graph_node, public receiver<T>, public sender<T> {
         return true;
     }
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
     typedef typename sender<T>::built_successors_type built_successors_type;
 
     built_successors_type &built_successors() __TBB_override { return my_successors.built_successors(); }
@@ -1855,7 +1983,7 @@ class broadcast_node : public graph_node, public receiver<T>, public sender<T> {
 
     typedef typename receiver<T>::built_predecessors_type built_predecessors_type;
 
-    built_predecessors_type &built_predecessors() __TBB_override { return my_built_predecessors; } 
+    built_predecessors_type &built_predecessors() __TBB_override { return my_built_predecessors; }
 
     void internal_add_built_predecessor( predecessor_type &p) __TBB_override {
         spin_mutex::scoped_lock l(pred_mutex);
@@ -1881,7 +2009,7 @@ class broadcast_node : public graph_node, public receiver<T>, public sender<T> {
         my_built_predecessors.receiver_extract(*this);
         my_successors.built_successors().sender_extract(*this);
     }
-#endif  /* TBB_PREVIEW_FLOW_GRAPH_FEATURES */
+#endif  /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
 
 protected:
     template< typename R, typename B > friend class run_and_put_task;
@@ -1894,12 +2022,16 @@ class broadcast_node : public graph_node, public receiver<T>, public sender<T> {
         return new_task;
     }
 
+    graph& graph_reference() const __TBB_override {
+        return my_graph;
+    }
+
     void reset_receiver(reset_flags /*f*/) __TBB_override {}
 
     void reset_node(reset_flags f) __TBB_override {
         if (f&rf_clear_edges) {
            my_successors.clear();
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
            my_built_predecessors.clear();
 #endif
         }
@@ -1908,30 +2040,50 @@ class broadcast_node : public graph_node, public receiver<T>, public sender<T> {
 };  // broadcast_node
 
 //! Forwards messages in arbitrary order
-template <typename T, typename A=cache_aligned_allocator<T> >
-class buffer_node : public graph_node, public internal::reservable_item_buffer<T, A>, public receiver<T>, public sender<T> {
+template <typename T, typename Allocator=__TBB_DEFAULT_NODE_ALLOCATOR(T) >
+class buffer_node
+    : public graph_node
+#if TBB_DEPRECATED_FLOW_NODE_ALLOCATOR
+    , public internal::reservable_item_buffer< T, Allocator >
+#else
+    , public internal::reservable_item_buffer< T, cache_aligned_allocator<T> >
+#endif
+    , public receiver<T>, public sender<T> {
+#if TBB_DEPRECATED_FLOW_NODE_ALLOCATOR
+    typedef Allocator internals_allocator;
+#else
+    typedef cache_aligned_allocator<T> internals_allocator;
+#endif
 public:
     typedef T input_type;
     typedef T output_type;
     typedef typename receiver<input_type>::predecessor_type predecessor_type;
     typedef typename sender<output_type>::successor_type successor_type;
-    typedef buffer_node<T, A> class_type;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+    typedef buffer_node<T, Allocator> class_type;
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
     typedef typename receiver<input_type>::predecessor_list_type predecessor_list_type;
     typedef typename sender<output_type>::successor_list_type successor_list_type;
 #endif
+#if !TBB_DEPRECATED_FLOW_NODE_ALLOCATOR
+    __TBB_STATIC_ASSERT(
+        (tbb::internal::is_same_type<Allocator, null_type>::value),
+        "Allocator template parameter for flow graph nodes is deprecated and will be removed. "
+        "Specify TBB_DEPRECATED_FLOW_NODE_ALLOCATOR to temporary enable the deprecated interface."
+    );
+#endif
+
 protected:
     typedef size_t size_type;
     internal::round_robin_cache< T, null_rw_mutex > my_successors;
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
     internal::edge_container<predecessor_type> my_built_predecessors;
 #endif
 
-    friend class internal::forward_task_bypass< buffer_node< T, A > >;
+    friend class internal::forward_task_bypass< class_type >;
 
     enum op_type {reg_succ, rem_succ, req_item, res_item, rel_res, con_res, put_item, try_fwd_task
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
         , add_blt_succ, del_blt_succ,
         add_blt_pred, del_blt_pred,
         blt_succ_cnt, blt_pred_cnt,
@@ -1943,7 +2095,7 @@ class buffer_node : public graph_node, public internal::reservable_item_buffer<T
     class buffer_operation : public internal::aggregated_operation< buffer_operation > {
     public:
         char type;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
         task * ltask;
         union {
             input_type *elem;
@@ -1960,7 +2112,7 @@ class buffer_node : public graph_node, public internal::reservable_item_buffer<T
 #endif
         buffer_operation(const T& e, op_type t) : type(char(t))
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
                                                   , ltask(NULL), elem(const_cast<T*>(&e))
 #else
                                                   , elem(const_cast<T*>(&e)) , ltask(NULL)
@@ -1996,7 +2148,7 @@ class buffer_node : public graph_node, public internal::reservable_item_buffer<T
             case con_res:  internal_consume(tmp); try_forwarding = true; break;
             case put_item: try_forwarding = internal_push(tmp); break;
             case try_fwd_task: internal_forward_task(tmp); break;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
             // edge recording
             case add_blt_succ: internal_add_built_succ(tmp); break;
             case del_blt_succ: internal_del_built_succ(tmp); break;
@@ -2013,15 +2165,16 @@ class buffer_node : public graph_node, public internal::reservable_item_buffer<T
         derived->order();
 
         if (try_forwarding && !forwarder_busy) {
-            if(this->my_graph.is_active()) {
+            if(internal::is_graph_active(this->my_graph)) {
                 forwarder_busy = true;
                 task *new_task = new(task::allocate_additional_child_of(*(this->my_graph.root_task()))) internal::
-                        forward_task_bypass
-                        < buffer_node<input_type, A> >(*this);
+                    forward_task_bypass<class_type>(*this);
                 // tmp should point to the last item handled by the aggregator.  This is the operation
                 // the handling thread enqueued.  So modifying that record will be okay.
+                // workaround for icc bug
                 tbb::task *z = tmp->ltask;
-                tmp->ltask = combine_tasks(z, new_task);  // in case the op generated a task
+                graph &g = this->my_graph;
+                tmp->ltask = combine_tasks(g, z, new_task);  // in case the op generated a task
             }
         }
     }  // handle_operations
@@ -2033,7 +2186,7 @@ class buffer_node : public graph_node, public internal::reservable_item_buffer<T
     inline bool enqueue_forwarding_task(buffer_operation &op_data) {
         task *ft = grab_forwarding_task(op_data);
         if(ft) {
-            FLOW_SPAWN(*ft);
+            internal::spawn_in_graph_arena(graph_reference(), *ft);
             return true;
         }
         return false;
@@ -2047,8 +2200,11 @@ class buffer_node : public graph_node, public internal::reservable_item_buffer<T
             op_data.status = internal::WAIT;
             op_data.ltask = NULL;
             my_aggregator.execute(&op_data);
+
+            // workaround for icc bug
             tbb::task *xtask = op_data.ltask;
-            last_task = combine_tasks(last_task, xtask);
+            graph& g = this->my_graph;
+            last_task = combine_tasks(g, last_task, xtask);
         } while (op_data.status ==internal::SUCCEEDED);
         return last_task;
     }
@@ -2065,7 +2221,7 @@ class buffer_node : public graph_node, public internal::reservable_item_buffer<T
         __TBB_store_with_release(op->status, internal::SUCCEEDED);
     }
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
     typedef typename sender<T>::built_successors_type built_successors_type;
 
     built_successors_type &built_successors() __TBB_override { return my_successors.built_successors(); }
@@ -2082,7 +2238,7 @@ class buffer_node : public graph_node, public internal::reservable_item_buffer<T
 
     typedef typename receiver<T>::built_predecessors_type built_predecessors_type;
 
-    built_predecessors_type &built_predecessors() __TBB_override { return my_built_predecessors; } 
+    built_predecessors_type &built_predecessors() __TBB_override { return my_built_predecessors; }
 
     virtual void internal_add_built_pred(buffer_operation *op) {
         my_built_predecessors.add_edge(*(op->p));
@@ -2114,7 +2270,7 @@ class buffer_node : public graph_node, public internal::reservable_item_buffer<T
         __TBB_store_with_release(op->status, internal::SUCCEEDED);
     }
 
-#endif  /* TBB_PREVIEW_FLOW_GRAPH_FEATURES */
+#endif  /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
 
 private:
     void order() {}
@@ -2126,7 +2282,9 @@ class buffer_node : public graph_node, public internal::reservable_item_buffer<T
     void try_put_and_add_task(task*& last_task) {
         task *new_task = my_successors.try_put_task(this->back());
         if (new_task) {
-            last_task = combine_tasks(last_task, new_task);
+            // workaround for icc bug
+            graph& g = this->my_graph;
+            last_task = combine_tasks(g, last_task, new_task);
             this->destroy_back();
         }
     }
@@ -2198,21 +2356,31 @@ class buffer_node : public graph_node, public internal::reservable_item_buffer<T
 
 public:
     //! Constructor
-    explicit buffer_node( graph &g ) : graph_node(g), internal::reservable_item_buffer<T>(),
-        forwarder_busy(false) {
+    __TBB_NOINLINE_SYM explicit buffer_node( graph &g )
+        : graph_node(g), internal::reservable_item_buffer<T, internals_allocator>(), receiver<T>(),
+          sender<T>(), forwarder_busy(false)
+    {
         my_successors.set_owner(this);
         my_aggregator.initialize_handler(handler_type(this));
-        tbb::internal::fgt_node( tbb::internal::FLOW_BUFFER_NODE, &this->my_graph,
+        tbb::internal::fgt_node( CODEPTR(), tbb::internal::FLOW_BUFFER_NODE, &this->my_graph,
                                  static_cast<receiver<input_type> *>(this), static_cast<sender<output_type> *>(this) );
     }
 
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+    template <typename... Args>
+    buffer_node(const node_set<Args...>& nodes) : buffer_node(nodes.graph_reference()) {
+        make_edges_in_order(nodes, *this);
+    }
+#endif
+
     //! Copy constructor
-    buffer_node( const buffer_node& src ) : graph_node(src.my_graph),
-        internal::reservable_item_buffer<T>(), receiver<T>(), sender<T>() {
-        forwarder_busy = false;
+    __TBB_NOINLINE_SYM buffer_node( const buffer_node& src )
+        : graph_node(src.my_graph), internal::reservable_item_buffer<T, internals_allocator>(),
+          receiver<T>(), sender<T>(), forwarder_busy(false)
+    {
         my_successors.set_owner(this);
         my_aggregator.initialize_handler(handler_type(this));
-        tbb::internal::fgt_node( tbb::internal::FLOW_BUFFER_NODE, &this->my_graph,
+        tbb::internal::fgt_node( CODEPTR(), tbb::internal::FLOW_BUFFER_NODE, &this->my_graph,
                                  static_cast<receiver<input_type> *>(this), static_cast<sender<output_type> *>(this) );
     }
 
@@ -2236,7 +2404,7 @@ class buffer_node : public graph_node, public internal::reservable_item_buffer<T
         return true;
     }
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
     void internal_add_built_successor( successor_type &r) __TBB_override {
         buffer_operation op_data(add_blt_succ);
         op_data.r = &r;
@@ -2285,7 +2453,7 @@ class buffer_node : public graph_node, public internal::reservable_item_buffer<T
         my_aggregator.execute(&op_data);
     }
 
-#endif
+#endif /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
 
     //! Removes a successor.
     /** Removes successor r from the list of successors.
@@ -2359,7 +2527,7 @@ class buffer_node : public graph_node, public internal::reservable_item_buffer<T
             // we haven't succeeded queueing the item, but for some reason the
             // call returned a task (if another request resulted in a successful
             // forward this could happen.)  Queue the task and reset the pointer.
-            FLOW_SPAWN(*ft); ft = NULL;
+            internal::spawn_in_graph_arena(graph_reference(), *ft); ft = NULL;
         }
         else if(!ft && op_data.status ==internal::SUCCEEDED) {
             ft = SUCCESSFULLY_ENQUEUED;
@@ -2367,9 +2535,13 @@ class buffer_node : public graph_node, public internal::reservable_item_buffer<T
         return ft;
     }
 
+    graph& graph_reference() const __TBB_override {
+        return my_graph;
+    }
+
     void reset_receiver(reset_flags /*f*/) __TBB_override { }
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
 public:
     void extract() __TBB_override {
         my_built_predecessors.receiver_extract(*this);
@@ -2379,11 +2551,11 @@ class buffer_node : public graph_node, public internal::reservable_item_buffer<T
 
 protected:
     void reset_node( reset_flags f) __TBB_override {
-        internal::reservable_item_buffer<T, A>::reset();
+        internal::reservable_item_buffer<T, internals_allocator>::reset();
         // TODO: just clear structures
         if (f&rf_clear_edges) {
             my_successors.clear();
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
             my_built_predecessors.clear();
 #endif
         }
@@ -2392,10 +2564,17 @@ class buffer_node : public graph_node, public internal::reservable_item_buffer<T
 };  // buffer_node
 
 //! Forwards messages in FIFO order
-template <typename T, typename A=cache_aligned_allocator<T> >
-class queue_node : public buffer_node<T, A> {
+template <typename T, typename Allocator=__TBB_DEFAULT_NODE_ALLOCATOR(T) >
+class queue_node : public buffer_node<T, Allocator> {
+#if !TBB_DEPRECATED_FLOW_NODE_ALLOCATOR
+    __TBB_STATIC_ASSERT(
+        (tbb::internal::is_same_type<Allocator, null_type>::value),
+        "Allocator template parameter for flow graph nodes is deprecated and will be removed. "
+        "Specify TBB_DEPRECATED_FLOW_NODE_ALLOCATOR to temporary enable the deprecated interface."
+    );
+#endif
 protected:
-    typedef buffer_node<T, A> base_type;
+    typedef buffer_node<T, Allocator> base_type;
     typedef typename base_type::size_type size_type;
     typedef typename base_type::buffer_operation queue_operation;
     typedef queue_node class_type;
@@ -2410,7 +2589,9 @@ class queue_node : public buffer_node<T, A> {
     void try_put_and_add_task(task*& last_task) {
         task *new_task = this->my_successors.try_put_task(this->front());
         if (new_task) {
-            last_task = combine_tasks(last_task, new_task);
+            // workaround for icc bug
+            graph& graph_ref = this->graph_reference();
+            last_task = combine_tasks(graph_ref, last_task, new_task);
             this->destroy_front();
         }
     }
@@ -2450,15 +2631,22 @@ class queue_node : public buffer_node<T, A> {
     typedef typename sender<output_type>::successor_type successor_type;
 
     //! Constructor
-    explicit queue_node( graph &g ) : base_type(g) {
-        tbb::internal::fgt_node( tbb::internal::FLOW_QUEUE_NODE, &(this->my_graph),
+    __TBB_NOINLINE_SYM explicit queue_node( graph &g ) : base_type(g) {
+        tbb::internal::fgt_node( CODEPTR(), tbb::internal::FLOW_QUEUE_NODE, &(this->my_graph),
                                  static_cast<receiver<input_type> *>(this),
                                  static_cast<sender<output_type> *>(this) );
     }
 
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+    template <typename... Args>
+    queue_node( const node_set<Args...>& nodes) : queue_node(nodes.graph_reference()) {
+        make_edges_in_order(nodes, *this);
+    }
+#endif
+
     //! Copy constructor
-    queue_node( const queue_node& src) : base_type(src) {
-        tbb::internal::fgt_node( tbb::internal::FLOW_QUEUE_NODE, &(this->my_graph),
+    __TBB_NOINLINE_SYM queue_node( const queue_node& src) : base_type(src) {
+        tbb::internal::fgt_node( CODEPTR(), tbb::internal::FLOW_QUEUE_NODE, &(this->my_graph),
                                  static_cast<receiver<input_type> *>(this),
                                  static_cast<sender<output_type> *>(this) );
     }
@@ -2476,12 +2664,19 @@ class queue_node : public buffer_node<T, A> {
 };  // queue_node
 
 //! Forwards messages in sequence order
-template< typename T, typename A=cache_aligned_allocator<T> >
-class sequencer_node : public queue_node<T, A> {
+template< typename T, typename Allocator=__TBB_DEFAULT_NODE_ALLOCATOR(T) >
+class sequencer_node : public queue_node<T, Allocator> {
     internal::function_body< T, size_t > *my_sequencer;
     // my_sequencer should be a benign function and must be callable
     // from a parallel context.  Does this mean it needn't be reset?
 public:
+#if !TBB_DEPRECATED_FLOW_NODE_ALLOCATOR
+    __TBB_STATIC_ASSERT(
+        (tbb::internal::is_same_type<Allocator, null_type>::value),
+        "Allocator template parameter for flow graph nodes is deprecated and will be removed. "
+        "Specify TBB_DEPRECATED_FLOW_NODE_ALLOCATOR to temporary enable the deprecated interface."
+    );
+#endif
     typedef T input_type;
     typedef T output_type;
     typedef typename receiver<input_type>::predecessor_type predecessor_type;
@@ -2489,17 +2684,25 @@ class sequencer_node : public queue_node<T, A> {
 
     //! Constructor
     template< typename Sequencer >
-    sequencer_node( graph &g, const Sequencer& s ) : queue_node<T, A>(g),
+    __TBB_NOINLINE_SYM sequencer_node( graph &g, const Sequencer& s ) : queue_node<T, Allocator>(g),
         my_sequencer(new internal::function_body_leaf< T, size_t, Sequencer>(s) ) {
-        tbb::internal::fgt_node( tbb::internal::FLOW_SEQUENCER_NODE, &(this->my_graph),
+        tbb::internal::fgt_node( CODEPTR(), tbb::internal::FLOW_SEQUENCER_NODE, &(this->my_graph),
                                  static_cast<receiver<input_type> *>(this),
                                  static_cast<sender<output_type> *>(this) );
     }
 
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+    template <typename Sequencer, typename... Args>
+    sequencer_node( const node_set<Args...>& nodes, const Sequencer& s)
+        : sequencer_node(nodes.graph_reference(), s) {
+        make_edges_in_order(nodes, *this);
+    }
+#endif
+
     //! Copy constructor
-    sequencer_node( const sequencer_node& src ) : queue_node<T, A>(src),
+    __TBB_NOINLINE_SYM sequencer_node( const sequencer_node& src ) : queue_node<T, Allocator>(src),
         my_sequencer( src.my_sequencer->clone() ) {
-        tbb::internal::fgt_node( tbb::internal::FLOW_SEQUENCER_NODE, &(this->my_graph),
+        tbb::internal::fgt_node( CODEPTR(), tbb::internal::FLOW_SEQUENCER_NODE, &(this->my_graph),
                                  static_cast<receiver<input_type> *>(this),
                                  static_cast<sender<output_type> *>(this) );
     }
@@ -2514,8 +2717,8 @@ class sequencer_node : public queue_node<T, A> {
 #endif
 
 protected:
-    typedef typename buffer_node<T, A>::size_type size_type;
-    typedef typename buffer_node<T, A>::buffer_operation sequencer_operation;
+    typedef typename buffer_node<T, Allocator>::size_type size_type;
+    typedef typename buffer_node<T, Allocator>::buffer_operation sequencer_operation;
 
 private:
     bool internal_push(sequencer_operation *op) __TBB_override {
@@ -2542,26 +2745,44 @@ class sequencer_node : public queue_node<T, A> {
 };  // sequencer_node
 
 //! Forwards messages in priority order
-template< typename T, typename Compare = std::less<T>, typename A=cache_aligned_allocator<T> >
-class priority_queue_node : public buffer_node<T, A> {
+template<typename T, typename Compare = std::less<T>, typename Allocator=__TBB_DEFAULT_NODE_ALLOCATOR(T)>
+class priority_queue_node : public buffer_node<T, Allocator> {
 public:
+#if !TBB_DEPRECATED_FLOW_NODE_ALLOCATOR
+    __TBB_STATIC_ASSERT(
+        (tbb::internal::is_same_type<Allocator, null_type>::value),
+        "Allocator template parameter for flow graph nodes is deprecated and will removed in the future. "
+        "To temporary enable the deprecated interface specify TBB_ENABLE_DEPRECATED_NODE_ALLOCATOR."
+    );
+#endif
     typedef T input_type;
     typedef T output_type;
-    typedef buffer_node<T,A> base_type;
+    typedef buffer_node<T,Allocator> base_type;
     typedef priority_queue_node class_type;
     typedef typename receiver<input_type>::predecessor_type predecessor_type;
     typedef typename sender<output_type>::successor_type successor_type;
 
     //! Constructor
-    explicit priority_queue_node( graph &g ) : buffer_node<T, A>(g), mark(0) {
-        tbb::internal::fgt_node( tbb::internal::FLOW_PRIORITY_QUEUE_NODE, &(this->my_graph),
+    __TBB_NOINLINE_SYM explicit priority_queue_node( graph &g, const Compare& comp = Compare() )
+        : buffer_node<T, Allocator>(g), compare(comp), mark(0) {
+        tbb::internal::fgt_node( CODEPTR(), tbb::internal::FLOW_PRIORITY_QUEUE_NODE, &(this->my_graph),
                                  static_cast<receiver<input_type> *>(this),
                                  static_cast<sender<output_type> *>(this) );
     }
 
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+    template <typename... Args>
+    priority_queue_node(const node_set<Args...>& nodes, const Compare& comp = Compare())
+        : priority_queue_node(nodes.graph_reference(), comp) {
+        make_edges_in_order(nodes, *this);
+    }
+#endif
+
     //! Copy constructor
-    priority_queue_node( const priority_queue_node &src ) : buffer_node<T, A>(src), mark(0) {
-        tbb::internal::fgt_node( tbb::internal::FLOW_PRIORITY_QUEUE_NODE, &(this->my_graph),
+    __TBB_NOINLINE_SYM priority_queue_node( const priority_queue_node &src )
+        : buffer_node<T, Allocator>(src), mark(0)
+    {
+        tbb::internal::fgt_node( CODEPTR(), tbb::internal::FLOW_PRIORITY_QUEUE_NODE, &(this->my_graph),
                                  static_cast<receiver<input_type> *>(this),
                                  static_cast<sender<output_type> *>(this) );
     }
@@ -2579,9 +2800,9 @@ class priority_queue_node : public buffer_node<T, A> {
         base_type::reset_node(f);
     }
 
-    typedef typename buffer_node<T, A>::size_type size_type;
-    typedef typename buffer_node<T, A>::item_type item_type;
-    typedef typename buffer_node<T, A>::buffer_operation prio_operation;
+    typedef typename buffer_node<T, Allocator>::size_type size_type;
+    typedef typename buffer_node<T, Allocator>::item_type item_type;
+    typedef typename buffer_node<T, Allocator>::buffer_operation prio_operation;
 
     //! Tries to forward valid items to successors
     void internal_forward_task(prio_operation *op) __TBB_override {
@@ -2652,7 +2873,9 @@ class priority_queue_node : public buffer_node<T, A> {
     void try_put_and_add_task(task*& last_task) {
         task * new_task = this->my_successors.try_put_task(this->prio());
         if (new_task) {
-            last_task = combine_tasks(last_task, new_task);
+            // workaround for icc bug
+            graph& graph_ref = this->graph_reference();
+            last_task = combine_tasks(graph_ref, last_task, new_task);
             prio_pop();
         }
     }
@@ -2750,18 +2973,22 @@ class priority_queue_node : public buffer_node<T, A> {
     }
 };  // priority_queue_node
 
+} // interfaceX
+
+namespace interface11 {
+
 //! Forwards messages only if the threshold has not been reached
 /** This node forwards items until its threshold is reached.
     It contains no buffering.  If the downstream node rejects, the
     message is dropped. */
-template< typename T >
+template< typename T, typename DecrementType=continue_msg >
 class limiter_node : public graph_node, public receiver< T >, public sender< T > {
 public:
     typedef T input_type;
     typedef T output_type;
     typedef typename receiver<input_type>::predecessor_type predecessor_type;
     typedef typename sender<output_type>::successor_type successor_type;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
     typedef typename receiver<input_type>::built_predecessors_type built_predecessors_type;
     typedef typename sender<output_type>::built_successors_type built_successors_type;
     typedef typename receiver<input_type>::predecessor_list_type predecessor_list_type;
@@ -2776,12 +3003,12 @@ class limiter_node : public graph_node, public receiver< T >, public sender< T >
     internal::reservable_predecessor_cache< T, spin_mutex > my_predecessors;
     spin_mutex my_mutex;
     internal::broadcast_cache< T > my_successors;
-    int init_decrement_predecessors;
+    __TBB_DEPRECATED_LIMITER_EXPR( int init_decrement_predecessors; )
 
-    friend class internal::forward_task_bypass< limiter_node<T> >;
+    friend class internal::forward_task_bypass< limiter_node<T,DecrementType> >;
 
     // Let decrementer call decrement_counter()
-    friend class internal::decrementer< limiter_node<T> >;
+    friend class internal::decrementer< limiter_node<T,DecrementType>, DecrementType >;
 
     bool check_conditions() {  // always called under lock
         return ( my_count + my_tries < my_threshold && !my_predecessors.empty() && !my_successors.empty() );
@@ -2812,10 +3039,10 @@ class limiter_node : public graph_node, public receiver< T >, public sender< T >
                     --my_tries;
                     my_predecessors.try_consume();
                     if ( check_conditions() ) {
-                        if ( this->my_graph.is_active() ) {
+                        if ( internal::is_graph_active(this->my_graph) ) {
                             task *rtask = new ( task::allocate_additional_child_of( *(this->my_graph.root_task()) ) )
-                                internal::forward_task_bypass< limiter_node<T> >( *this );
-                            FLOW_SPAWN (*rtask);
+                                internal::forward_task_bypass< limiter_node<T, DecrementType> >( *this );
+                            internal::spawn_in_graph_arena(graph_reference(), *rtask);
                         }
                     }
                 }
@@ -2830,9 +3057,9 @@ class limiter_node : public graph_node, public receiver< T >, public sender< T >
             --my_tries;
             if (reserved) my_predecessors.try_release();
             if ( check_conditions() ) {
-                if ( this->my_graph.is_active() ) {
+                if ( internal::is_graph_active(this->my_graph) ) {
                     task *rtask = new ( task::allocate_additional_child_of( *(this->my_graph.root_task()) ) )
-                        internal::forward_task_bypass< limiter_node<T> >( *this );
+                        internal::forward_task_bypass< limiter_node<T, DecrementType> >( *this );
                     __TBB_ASSERT(!rval, "Have two tasks to handle");
                     return rtask;
                 }
@@ -2846,45 +3073,67 @@ class limiter_node : public graph_node, public receiver< T >, public sender< T >
         return;
     }
 
-    task * decrement_counter() {
+    task* decrement_counter( long long delta ) {
         {
             spin_mutex::scoped_lock lock(my_mutex);
-            if(my_count) --my_count;
+            if( delta > 0 && size_t(delta) > my_count )
+                my_count = 0;
+            else if( delta < 0 && size_t(delta) > my_threshold - my_count )
+                my_count = my_threshold;
+            else
+                my_count -= size_t(delta); // absolute value of delta is sufficiently small
         }
         return forward_task();
     }
 
-public:
-    //! The internal receiver< continue_msg > that decrements the count
-    internal::decrementer< limiter_node<T> > decrement;
-
-    //! Constructor
-    limiter_node(graph &g, size_t threshold, int num_decrement_predecessors=0) :
-        graph_node(g), my_threshold(threshold), my_count(0), my_tries(0),
-        init_decrement_predecessors(num_decrement_predecessors),
-        decrement(num_decrement_predecessors)
-    {
+    void initialize() {
         my_predecessors.set_owner(this);
         my_successors.set_owner(this);
         decrement.set_owner(this);
-        tbb::internal::fgt_node( tbb::internal::FLOW_LIMITER_NODE, &this->my_graph,
-                                 static_cast<receiver<input_type> *>(this), static_cast<receiver<continue_msg> *>(&decrement),
-                                 static_cast<sender<output_type> *>(this) );
+        tbb::internal::fgt_node(
+            CODEPTR(), tbb::internal::FLOW_LIMITER_NODE, &this->my_graph,
+            static_cast<receiver<input_type> *>(this), static_cast<receiver<DecrementType> *>(&decrement),
+            static_cast<sender<output_type> *>(this)
+        );
+    }
+public:
+    //! The internal receiver< DecrementType > that decrements the count
+    internal::decrementer< limiter_node<T, DecrementType>, DecrementType > decrement;
+
+#if TBB_DEPRECATED_LIMITER_NODE_CONSTRUCTOR
+    __TBB_STATIC_ASSERT( (tbb::internal::is_same_type<DecrementType, continue_msg>::value),
+                         "Deprecated interface of the limiter node can be used only in conjunction "
+                         "with continue_msg as the type of DecrementType template parameter." );
+#endif // Check for incompatible interface
+
+    //! Constructor
+    limiter_node(graph &g,
+                 __TBB_DEPRECATED_LIMITER_ARG2(size_t threshold, int num_decrement_predecessors=0))
+        : graph_node(g), my_threshold(threshold), my_count(0),
+          __TBB_DEPRECATED_LIMITER_ARG4(
+              my_tries(0), decrement(),
+              init_decrement_predecessors(num_decrement_predecessors),
+              decrement(num_decrement_predecessors)) {
+        initialize();
+    }
+
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+    template <typename... Args>
+    limiter_node(const node_set<Args...>& nodes, size_t threshold)
+        : limiter_node(nodes.graph_reference(), threshold) {
+        make_edges_in_order(nodes, *this);
     }
+#endif
 
     //! Copy constructor
     limiter_node( const limiter_node& src ) :
         graph_node(src.my_graph), receiver<T>(), sender<T>(),
-        my_threshold(src.my_threshold), my_count(0), my_tries(0),
-        init_decrement_predecessors(src.init_decrement_predecessors),
-        decrement(src.init_decrement_predecessors)
-    {
-        my_predecessors.set_owner(this);
-        my_successors.set_owner(this);
-        decrement.set_owner(this);
-        tbb::internal::fgt_node( tbb::internal::FLOW_LIMITER_NODE, &this->my_graph,
-                                 static_cast<receiver<input_type> *>(this), static_cast<receiver<continue_msg> *>(&decrement),
-                                 static_cast<sender<output_type> *>(this) );
+        my_threshold(src.my_threshold), my_count(0),
+        __TBB_DEPRECATED_LIMITER_ARG4(
+            my_tries(0), decrement(),
+            init_decrement_predecessors(src.init_decrement_predecessors),
+            decrement(src.init_decrement_predecessors)) {
+        initialize();
     }
 
 #if TBB_PREVIEW_FLOW_GRAPH_TRACE
@@ -2900,9 +3149,10 @@ class limiter_node : public graph_node, public receiver< T >, public sender< T >
         my_successors.register_successor(r);
         //spawn a forward task if this is the only successor
         if ( was_empty && !my_predecessors.empty() && my_count + my_tries < my_threshold ) {
-            if ( this->my_graph.is_active() ) {
-                FLOW_SPAWN( (* new ( task::allocate_additional_child_of( *(this->my_graph.root_task()) ) )
-                            internal::forward_task_bypass < limiter_node<T> >( *this ) ) );
+            if ( internal::is_graph_active(this->my_graph) ) {
+                task* task = new ( task::allocate_additional_child_of( *(this->my_graph.root_task()) ) )
+                    internal::forward_task_bypass < limiter_node<T, DecrementType> >( *this );
+                internal::spawn_in_graph_arena(graph_reference(), *task);
             }
         }
         return true;
@@ -2916,7 +3166,7 @@ class limiter_node : public graph_node, public receiver< T >, public sender< T >
         return true;
     }
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
     built_successors_type &built_successors() __TBB_override { return my_successors.built_successors(); }
     built_predecessors_type &built_predecessors() __TBB_override { return my_predecessors.built_predecessors(); }
 
@@ -2954,15 +3204,16 @@ class limiter_node : public graph_node, public receiver< T >, public sender< T >
         my_predecessors.built_predecessors().receiver_extract(*this);
         decrement.built_predecessors().receiver_extract(decrement);
     }
-#endif  /* TBB_PREVIEW_FLOW_GRAPH_FEATURES */
+#endif  /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
 
     //! Adds src to the list of cached predecessors.
     bool register_predecessor( predecessor_type &src ) __TBB_override {
         spin_mutex::scoped_lock lock(my_mutex);
         my_predecessors.add( src );
-        if ( my_count + my_tries < my_threshold && !my_successors.empty() && this->my_graph.is_active() ) {
-            FLOW_SPAWN( (* new ( task::allocate_additional_child_of( *(this->my_graph.root_task()) ) )
-                        internal::forward_task_bypass < limiter_node<T> >( *this ) ) );
+        if ( my_count + my_tries < my_threshold && !my_successors.empty() && internal::is_graph_active(this->my_graph) ) {
+            task* task = new ( task::allocate_additional_child_of( *(this->my_graph.root_task()) ) )
+                internal::forward_task_bypass < limiter_node<T, DecrementType> >( *this );
+            internal::spawn_in_graph_arena(graph_reference(), *task);
         }
         return true;
     }
@@ -2993,9 +3244,9 @@ class limiter_node : public graph_node, public receiver< T >, public sender< T >
         if ( !rtask ) {  // try_put_task failed.
             spin_mutex::scoped_lock lock(my_mutex);
             --my_tries;
-            if ( check_conditions() && this->my_graph.is_active() ) {
+            if (check_conditions() && internal::is_graph_active(this->my_graph)) {
                 rtask = new ( task::allocate_additional_child_of( *(this->my_graph.root_task()) ) )
-                    internal::forward_task_bypass< limiter_node<T> >( *this );
+                    internal::forward_task_bypass< limiter_node<T, DecrementType> >( *this );
             }
         }
         else {
@@ -3006,6 +3257,8 @@ class limiter_node : public graph_node, public receiver< T >, public sender< T >
         return rtask;
     }
 
+    graph& graph_reference() const __TBB_override { return my_graph; }
+
     void reset_receiver(reset_flags /*f*/) __TBB_override {
         __TBB_ASSERT(false,NULL);  // should never be called
     }
@@ -3042,12 +3295,20 @@ class join_node<OutputTuple,reserving>: public internal::unfolded_join_node<tbb:
 public:
     typedef OutputTuple output_type;
     typedef typename unfolded_type::input_ports_type input_ports_type;
-    explicit join_node(graph &g) : unfolded_type(g) {
-        tbb::internal::fgt_multiinput_node<N>( tbb::internal::FLOW_JOIN_NODE_RESERVING, &this->my_graph,
+     __TBB_NOINLINE_SYM explicit join_node(graph &g) : unfolded_type(g) {
+        tbb::internal::fgt_multiinput_node<N>( CODEPTR(), tbb::internal::FLOW_JOIN_NODE_RESERVING, &this->my_graph,
                                             this->input_ports(), static_cast< sender< output_type > *>(this) );
     }
-    join_node(const join_node &other) : unfolded_type(other) {
-        tbb::internal::fgt_multiinput_node<N>( tbb::internal::FLOW_JOIN_NODE_RESERVING, &this->my_graph,
+
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+    template <typename... Args>
+    __TBB_NOINLINE_SYM join_node(const node_set<Args...>& nodes, reserving = reserving()) : join_node(nodes.graph_reference()) {
+        make_edges_in_order(nodes, *this);
+    }
+#endif
+
+    __TBB_NOINLINE_SYM join_node(const join_node &other) : unfolded_type(other) {
+        tbb::internal::fgt_multiinput_node<N>( CODEPTR(), tbb::internal::FLOW_JOIN_NODE_RESERVING, &this->my_graph,
                                             this->input_ports(), static_cast< sender< output_type > *>(this) );
     }
 
@@ -3067,12 +3328,20 @@ class join_node<OutputTuple,queueing>: public internal::unfolded_join_node<tbb::
 public:
     typedef OutputTuple output_type;
     typedef typename unfolded_type::input_ports_type input_ports_type;
-    explicit join_node(graph &g) : unfolded_type(g) {
-        tbb::internal::fgt_multiinput_node<N>( tbb::internal::FLOW_JOIN_NODE_QUEUEING, &this->my_graph,
+     __TBB_NOINLINE_SYM explicit join_node(graph &g) : unfolded_type(g) {
+        tbb::internal::fgt_multiinput_node<N>( CODEPTR(), tbb::internal::FLOW_JOIN_NODE_QUEUEING, &this->my_graph,
                                             this->input_ports(), static_cast< sender< output_type > *>(this) );
     }
-    join_node(const join_node &other) : unfolded_type(other) {
-        tbb::internal::fgt_multiinput_node<N>( tbb::internal::FLOW_JOIN_NODE_QUEUEING, &this->my_graph,
+
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+    template <typename... Args>
+    __TBB_NOINLINE_SYM join_node(const node_set<Args...>& nodes, queueing = queueing()) : join_node(nodes.graph_reference()) {
+        make_edges_in_order(nodes, *this);
+    }
+#endif
+
+    __TBB_NOINLINE_SYM join_node(const join_node &other) : unfolded_type(other) {
+        tbb::internal::fgt_multiinput_node<N>( CODEPTR(), tbb::internal::FLOW_JOIN_NODE_QUEUEING, &this->my_graph,
                                             this->input_ports(), static_cast< sender< output_type > *>(this) );
     }
 
@@ -3098,76 +3367,94 @@ class join_node<OutputTuple, key_matching<K, KHash> > : public internal::unfolde
 
 #if __TBB_PREVIEW_MESSAGE_BASED_KEY_MATCHING
     join_node(graph &g) : unfolded_type(g) {}
+
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+    template <typename... Args>
+    join_node(const node_set<Args...>& nodes, key_matching<K, KHash> = key_matching<K, KHash>())
+        : join_node(nodes.graph_reference()) {
+        make_edges_in_order(nodes, *this);
+    }
+#endif
+
 #endif  /* __TBB_PREVIEW_MESSAGE_BASED_KEY_MATCHING */
 
     template<typename __TBB_B0, typename __TBB_B1>
-    join_node(graph &g, __TBB_B0 b0, __TBB_B1 b1) : unfolded_type(g, b0, b1) {
-        tbb::internal::fgt_multiinput_node<N>( tbb::internal::FLOW_JOIN_NODE_TAG_MATCHING, &this->my_graph,
+     __TBB_NOINLINE_SYM join_node(graph &g, __TBB_B0 b0, __TBB_B1 b1) : unfolded_type(g, b0, b1) {
+        tbb::internal::fgt_multiinput_node<N>( CODEPTR(), tbb::internal::FLOW_JOIN_NODE_TAG_MATCHING, &this->my_graph,
                                                            this->input_ports(), static_cast< sender< output_type > *>(this) );
     }
     template<typename __TBB_B0, typename __TBB_B1, typename __TBB_B2>
-    join_node(graph &g, __TBB_B0 b0, __TBB_B1 b1, __TBB_B2 b2) : unfolded_type(g, b0, b1, b2) {
-        tbb::internal::fgt_multiinput_node<N>( tbb::internal::FLOW_JOIN_NODE_TAG_MATCHING, &this->my_graph,
+     __TBB_NOINLINE_SYM join_node(graph &g, __TBB_B0 b0, __TBB_B1 b1, __TBB_B2 b2) : unfolded_type(g, b0, b1, b2) {
+        tbb::internal::fgt_multiinput_node<N>( CODEPTR(), tbb::internal::FLOW_JOIN_NODE_TAG_MATCHING, &this->my_graph,
                                                            this->input_ports(), static_cast< sender< output_type > *>(this) );
     }
     template<typename __TBB_B0, typename __TBB_B1, typename __TBB_B2, typename __TBB_B3>
-    join_node(graph &g, __TBB_B0 b0, __TBB_B1 b1, __TBB_B2 b2, __TBB_B3 b3) : unfolded_type(g, b0, b1, b2, b3) {
-        tbb::internal::fgt_multiinput_node<N>( tbb::internal::FLOW_JOIN_NODE_TAG_MATCHING, &this->my_graph,
+     __TBB_NOINLINE_SYM join_node(graph &g, __TBB_B0 b0, __TBB_B1 b1, __TBB_B2 b2, __TBB_B3 b3) : unfolded_type(g, b0, b1, b2, b3) {
+        tbb::internal::fgt_multiinput_node<N>( CODEPTR(), tbb::internal::FLOW_JOIN_NODE_TAG_MATCHING, &this->my_graph,
                                                            this->input_ports(), static_cast< sender< output_type > *>(this) );
     }
     template<typename __TBB_B0, typename __TBB_B1, typename __TBB_B2, typename __TBB_B3, typename __TBB_B4>
-    join_node(graph &g, __TBB_B0 b0, __TBB_B1 b1, __TBB_B2 b2, __TBB_B3 b3, __TBB_B4 b4) :
+     __TBB_NOINLINE_SYM join_node(graph &g, __TBB_B0 b0, __TBB_B1 b1, __TBB_B2 b2, __TBB_B3 b3, __TBB_B4 b4) :
             unfolded_type(g, b0, b1, b2, b3, b4) {
-        tbb::internal::fgt_multiinput_node<N>( tbb::internal::FLOW_JOIN_NODE_TAG_MATCHING, &this->my_graph,
+        tbb::internal::fgt_multiinput_node<N>( CODEPTR(), tbb::internal::FLOW_JOIN_NODE_TAG_MATCHING, &this->my_graph,
                                                            this->input_ports(), static_cast< sender< output_type > *>(this) );
     }
 #if __TBB_VARIADIC_MAX >= 6
     template<typename __TBB_B0, typename __TBB_B1, typename __TBB_B2, typename __TBB_B3, typename __TBB_B4,
         typename __TBB_B5>
-    join_node(graph &g, __TBB_B0 b0, __TBB_B1 b1, __TBB_B2 b2, __TBB_B3 b3, __TBB_B4 b4, __TBB_B5 b5) :
+     __TBB_NOINLINE_SYM join_node(graph &g, __TBB_B0 b0, __TBB_B1 b1, __TBB_B2 b2, __TBB_B3 b3, __TBB_B4 b4, __TBB_B5 b5) :
             unfolded_type(g, b0, b1, b2, b3, b4, b5) {
-        tbb::internal::fgt_multiinput_node<N>( tbb::internal::FLOW_JOIN_NODE_TAG_MATCHING, &this->my_graph,
+        tbb::internal::fgt_multiinput_node<N>( CODEPTR(), tbb::internal::FLOW_JOIN_NODE_TAG_MATCHING, &this->my_graph,
                                                            this->input_ports(), static_cast< sender< output_type > *>(this) );
     }
 #endif
 #if __TBB_VARIADIC_MAX >= 7
     template<typename __TBB_B0, typename __TBB_B1, typename __TBB_B2, typename __TBB_B3, typename __TBB_B4,
         typename __TBB_B5, typename __TBB_B6>
-    join_node(graph &g, __TBB_B0 b0, __TBB_B1 b1, __TBB_B2 b2, __TBB_B3 b3, __TBB_B4 b4, __TBB_B5 b5, __TBB_B6 b6) :
+     __TBB_NOINLINE_SYM join_node(graph &g, __TBB_B0 b0, __TBB_B1 b1, __TBB_B2 b2, __TBB_B3 b3, __TBB_B4 b4, __TBB_B5 b5, __TBB_B6 b6) :
             unfolded_type(g, b0, b1, b2, b3, b4, b5, b6) {
-        tbb::internal::fgt_multiinput_node<N>( tbb::internal::FLOW_JOIN_NODE_TAG_MATCHING, &this->my_graph,
+        tbb::internal::fgt_multiinput_node<N>( CODEPTR(), tbb::internal::FLOW_JOIN_NODE_TAG_MATCHING, &this->my_graph,
                                                            this->input_ports(), static_cast< sender< output_type > *>(this) );
     }
 #endif
 #if __TBB_VARIADIC_MAX >= 8
     template<typename __TBB_B0, typename __TBB_B1, typename __TBB_B2, typename __TBB_B3, typename __TBB_B4,
         typename __TBB_B5, typename __TBB_B6, typename __TBB_B7>
-    join_node(graph &g, __TBB_B0 b0, __TBB_B1 b1, __TBB_B2 b2, __TBB_B3 b3, __TBB_B4 b4, __TBB_B5 b5, __TBB_B6 b6,
+     __TBB_NOINLINE_SYM join_node(graph &g, __TBB_B0 b0, __TBB_B1 b1, __TBB_B2 b2, __TBB_B3 b3, __TBB_B4 b4, __TBB_B5 b5, __TBB_B6 b6,
             __TBB_B7 b7) : unfolded_type(g, b0, b1, b2, b3, b4, b5, b6, b7) {
-        tbb::internal::fgt_multiinput_node<N>( tbb::internal::FLOW_JOIN_NODE_TAG_MATCHING, &this->my_graph,
+        tbb::internal::fgt_multiinput_node<N>( CODEPTR(), tbb::internal::FLOW_JOIN_NODE_TAG_MATCHING, &this->my_graph,
                                                            this->input_ports(), static_cast< sender< output_type > *>(this) );
     }
 #endif
 #if __TBB_VARIADIC_MAX >= 9
     template<typename __TBB_B0, typename __TBB_B1, typename __TBB_B2, typename __TBB_B3, typename __TBB_B4,
         typename __TBB_B5, typename __TBB_B6, typename __TBB_B7, typename __TBB_B8>
-    join_node(graph &g, __TBB_B0 b0, __TBB_B1 b1, __TBB_B2 b2, __TBB_B3 b3, __TBB_B4 b4, __TBB_B5 b5, __TBB_B6 b6,
+     __TBB_NOINLINE_SYM join_node(graph &g, __TBB_B0 b0, __TBB_B1 b1, __TBB_B2 b2, __TBB_B3 b3, __TBB_B4 b4, __TBB_B5 b5, __TBB_B6 b6,
             __TBB_B7 b7, __TBB_B8 b8) : unfolded_type(g, b0, b1, b2, b3, b4, b5, b6, b7, b8) {
-        tbb::internal::fgt_multiinput_node<N>( tbb::internal::FLOW_JOIN_NODE_TAG_MATCHING, &this->my_graph,
+        tbb::internal::fgt_multiinput_node<N>( CODEPTR(), tbb::internal::FLOW_JOIN_NODE_TAG_MATCHING, &this->my_graph,
                                                            this->input_ports(), static_cast< sender< output_type > *>(this) );
     }
 #endif
 #if __TBB_VARIADIC_MAX >= 10
     template<typename __TBB_B0, typename __TBB_B1, typename __TBB_B2, typename __TBB_B3, typename __TBB_B4,
         typename __TBB_B5, typename __TBB_B6, typename __TBB_B7, typename __TBB_B8, typename __TBB_B9>
-    join_node(graph &g, __TBB_B0 b0, __TBB_B1 b1, __TBB_B2 b2, __TBB_B3 b3, __TBB_B4 b4, __TBB_B5 b5, __TBB_B6 b6,
+     __TBB_NOINLINE_SYM join_node(graph &g, __TBB_B0 b0, __TBB_B1 b1, __TBB_B2 b2, __TBB_B3 b3, __TBB_B4 b4, __TBB_B5 b5, __TBB_B6 b6,
             __TBB_B7 b7, __TBB_B8 b8, __TBB_B9 b9) : unfolded_type(g, b0, b1, b2, b3, b4, b5, b6, b7, b8, b9) {
-        tbb::internal::fgt_multiinput_node<N>( tbb::internal::FLOW_JOIN_NODE_TAG_MATCHING, &this->my_graph,
+        tbb::internal::fgt_multiinput_node<N>( CODEPTR(), tbb::internal::FLOW_JOIN_NODE_TAG_MATCHING, &this->my_graph,
                                                            this->input_ports(), static_cast< sender< output_type > *>(this) );
     }
 #endif
-    join_node(const join_node &other) : unfolded_type(other) {
-        tbb::internal::fgt_multiinput_node<N>( tbb::internal::FLOW_JOIN_NODE_TAG_MATCHING, &this->my_graph,
+
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+    template <typename... Args, typename... Bodies>
+    __TBB_NOINLINE_SYM join_node(const node_set<Args...>& nodes, Bodies... bodies)
+        : join_node(nodes.graph_reference(), bodies...) {
+        make_edges_in_order(nodes, *this);
+    }
+#endif
+
+    __TBB_NOINLINE_SYM join_node(const join_node &other) : unfolded_type(other) {
+        tbb::internal::fgt_multiinput_node<N>( CODEPTR(), tbb::internal::FLOW_JOIN_NODE_TAG_MATCHING, &this->my_graph,
                                                            this->input_ports(), static_cast< sender< output_type > *>(this) );
     }
 
@@ -3196,18 +3483,26 @@ class indexer_node<T0> : public internal::unfolded_indexer_node<tuple<T0> > {
     typedef tuple<T0> InputTuple;
     typedef typename internal::tagged_msg<size_t, T0> output_type;
     typedef typename internal::unfolded_indexer_node<InputTuple> unfolded_type;
-    indexer_node(graph& g) : unfolded_type(g) {
-        tbb::internal::fgt_multiinput_node<N>( tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
+    __TBB_NOINLINE_SYM indexer_node(graph& g) : unfolded_type(g) {
+        tbb::internal::fgt_multiinput_node<N>( CODEPTR(), tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
                                            this->input_ports(), static_cast< sender< output_type > *>(this) );
     }
+
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+    template <typename... Args>
+    indexer_node(const node_set<Args...>& nodes) : indexer_node(nodes.graph_reference()) {
+        make_edges_in_order(nodes, *this);
+    }
+#endif
+
     // Copy constructor
-    indexer_node( const indexer_node& other ) : unfolded_type(other) {
-        tbb::internal::fgt_multiinput_node<N>( tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
+    __TBB_NOINLINE_SYM indexer_node( const indexer_node& other ) : unfolded_type(other) {
+        tbb::internal::fgt_multiinput_node<N>( CODEPTR(), tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
                                            this->input_ports(), static_cast< sender< output_type > *>(this) );
     }
 
 #if TBB_PREVIEW_FLOW_GRAPH_TRACE
-     void set_name( const char *name ) {
+     void set_name( const char *name ) __TBB_override {
         tbb::internal::fgt_node_desc( this, name );
     }
 #endif
@@ -3221,18 +3516,26 @@ class indexer_node<T0, T1> : public internal::unfolded_indexer_node<tuple<T0, T1
     typedef tuple<T0, T1> InputTuple;
     typedef typename internal::tagged_msg<size_t, T0, T1> output_type;
     typedef typename internal::unfolded_indexer_node<InputTuple> unfolded_type;
-    indexer_node(graph& g) : unfolded_type(g) {
-        tbb::internal::fgt_multiinput_node<N>( tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
+    __TBB_NOINLINE_SYM indexer_node(graph& g) : unfolded_type(g) {
+        tbb::internal::fgt_multiinput_node<N>( CODEPTR(), tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
                                            this->input_ports(), static_cast< sender< output_type > *>(this) );
     }
+
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+    template <typename... Args>
+    indexer_node(const node_set<Args...>& nodes) : indexer_node(nodes.graph_reference()) {
+        make_edges_in_order(nodes, *this);
+    }
+#endif
+
     // Copy constructor
-    indexer_node( const indexer_node& other ) : unfolded_type(other) {
-        tbb::internal::fgt_multiinput_node<N>( tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
+    __TBB_NOINLINE_SYM indexer_node( const indexer_node& other ) : unfolded_type(other) {
+        tbb::internal::fgt_multiinput_node<N>( CODEPTR(), tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
                                            this->input_ports(), static_cast< sender< output_type > *>(this) );
     }
 
 #if TBB_PREVIEW_FLOW_GRAPH_TRACE
-     void set_name( const char *name ) {
+     void set_name( const char *name ) __TBB_override {
         tbb::internal::fgt_node_desc( this, name );
     }
 #endif
@@ -3246,18 +3549,26 @@ class indexer_node<T0, T1, T2> : public internal::unfolded_indexer_node<tuple<T0
     typedef tuple<T0, T1, T2> InputTuple;
     typedef typename internal::tagged_msg<size_t, T0, T1, T2> output_type;
     typedef typename internal::unfolded_indexer_node<InputTuple> unfolded_type;
-    indexer_node(graph& g) : unfolded_type(g) {
-        tbb::internal::fgt_multiinput_node<N>( tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
+    __TBB_NOINLINE_SYM indexer_node(graph& g) : unfolded_type(g) {
+        tbb::internal::fgt_multiinput_node<N>( CODEPTR(), tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
                                            this->input_ports(), static_cast< sender< output_type > *>(this) );
     }
+
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+    template <typename... Args>
+    indexer_node(const node_set<Args...>& nodes) : indexer_node(nodes.graph_reference()) {
+        make_edges_in_order(nodes, *this);
+    }
+#endif
+
     // Copy constructor
-    indexer_node( const indexer_node& other ) : unfolded_type(other) {
-        tbb::internal::fgt_multiinput_node<N>( tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
+    __TBB_NOINLINE_SYM indexer_node( const indexer_node& other ) : unfolded_type(other) {
+        tbb::internal::fgt_multiinput_node<N>( CODEPTR(), tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
                                            this->input_ports(), static_cast< sender< output_type > *>(this) );
     }
 
 #if TBB_PREVIEW_FLOW_GRAPH_TRACE
-        void set_name( const char *name ) {
+    void set_name( const char *name ) __TBB_override {
         tbb::internal::fgt_node_desc( this, name );
     }
 #endif
@@ -3271,13 +3582,21 @@ class indexer_node<T0, T1, T2, T3> : public internal::unfolded_indexer_node<tupl
     typedef tuple<T0, T1, T2, T3> InputTuple;
     typedef typename internal::tagged_msg<size_t, T0, T1, T2, T3> output_type;
     typedef typename internal::unfolded_indexer_node<InputTuple> unfolded_type;
-    indexer_node(graph& g) : unfolded_type(g) {
-        tbb::internal::fgt_multiinput_node<N>( tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
+    __TBB_NOINLINE_SYM indexer_node(graph& g) : unfolded_type(g) {
+        tbb::internal::fgt_multiinput_node<N>( CODEPTR(), tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
                                            this->input_ports(), static_cast< sender< output_type > *>(this) );
     }
+
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+    template <typename... Args>
+    indexer_node(const node_set<Args...>& nodes) : indexer_node(nodes.graph_reference()) {
+        make_edges_in_order(nodes, *this);
+    }
+#endif
+
     // Copy constructor
-    indexer_node( const indexer_node& other ) : unfolded_type(other) {
-        tbb::internal::fgt_multiinput_node<N>( tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
+    __TBB_NOINLINE_SYM indexer_node( const indexer_node& other ) : unfolded_type(other) {
+        tbb::internal::fgt_multiinput_node<N>( CODEPTR(), tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
                                            this->input_ports(), static_cast< sender< output_type > *>(this) );
     }
 
@@ -3296,13 +3615,21 @@ class indexer_node<T0, T1, T2, T3, T4> : public internal::unfolded_indexer_node<
     typedef tuple<T0, T1, T2, T3, T4> InputTuple;
     typedef typename internal::tagged_msg<size_t, T0, T1, T2, T3, T4> output_type;
     typedef typename internal::unfolded_indexer_node<InputTuple> unfolded_type;
-    indexer_node(graph& g) : unfolded_type(g) {
-        tbb::internal::fgt_multiinput_node<N>( tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
+    __TBB_NOINLINE_SYM indexer_node(graph& g) : unfolded_type(g) {
+        tbb::internal::fgt_multiinput_node<N>( CODEPTR(), tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
                                            this->input_ports(), static_cast< sender< output_type > *>(this) );
     }
+
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+    template <typename... Args>
+    indexer_node(const node_set<Args...>& nodes) : indexer_node(nodes.graph_reference()) {
+        make_edges_in_order(nodes, *this);
+    }
+#endif
+
     // Copy constructor
-    indexer_node( const indexer_node& other ) : unfolded_type(other) {
-        tbb::internal::fgt_multiinput_node<N>( tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
+    __TBB_NOINLINE_SYM indexer_node( const indexer_node& other ) : unfolded_type(other) {
+        tbb::internal::fgt_multiinput_node<N>( CODEPTR(), tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
                                            this->input_ports(), static_cast< sender< output_type > *>(this) );
     }
 
@@ -3322,13 +3649,21 @@ class indexer_node<T0, T1, T2, T3, T4, T5> : public internal::unfolded_indexer_n
     typedef tuple<T0, T1, T2, T3, T4, T5> InputTuple;
     typedef typename internal::tagged_msg<size_t, T0, T1, T2, T3, T4, T5> output_type;
     typedef typename internal::unfolded_indexer_node<InputTuple> unfolded_type;
-    indexer_node(graph& g) : unfolded_type(g) {
-        tbb::internal::fgt_multiinput_node<N>( tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
+    __TBB_NOINLINE_SYM indexer_node(graph& g) : unfolded_type(g) {
+        tbb::internal::fgt_multiinput_node<N>( CODEPTR(), tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
                                            this->input_ports(), static_cast< sender< output_type > *>(this) );
     }
+
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+    template <typename... Args>
+    indexer_node(const node_set<Args...>& nodes) : indexer_node(nodes.graph_reference()) {
+        make_edges_in_order(nodes, *this);
+    }
+#endif
+
     // Copy constructor
-    indexer_node( const indexer_node& other ) : unfolded_type(other) {
-        tbb::internal::fgt_multiinput_node<N>( tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
+    __TBB_NOINLINE_SYM indexer_node( const indexer_node& other ) : unfolded_type(other) {
+        tbb::internal::fgt_multiinput_node<N>( CODEPTR(), tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
                                            this->input_ports(), static_cast< sender< output_type > *>(this) );
     }
 
@@ -3350,13 +3685,21 @@ class indexer_node<T0, T1, T2, T3, T4, T5, T6> : public internal::unfolded_index
     typedef tuple<T0, T1, T2, T3, T4, T5, T6> InputTuple;
     typedef typename internal::tagged_msg<size_t, T0, T1, T2, T3, T4, T5, T6> output_type;
     typedef typename internal::unfolded_indexer_node<InputTuple> unfolded_type;
-    indexer_node(graph& g) : unfolded_type(g) {
-        tbb::internal::fgt_multiinput_node<N>( tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
+    __TBB_NOINLINE_SYM indexer_node(graph& g) : unfolded_type(g) {
+        tbb::internal::fgt_multiinput_node<N>( CODEPTR(), tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
                                            this->input_ports(), static_cast< sender< output_type > *>(this) );
     }
+
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+    template <typename... Args>
+    indexer_node(const node_set<Args...>& nodes) : indexer_node(nodes.graph_reference()) {
+        make_edges_in_order(nodes, *this);
+    }
+#endif
+
     // Copy constructor
-    indexer_node( const indexer_node& other ) : unfolded_type(other) {
-        tbb::internal::fgt_multiinput_node<N>( tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
+    __TBB_NOINLINE_SYM indexer_node( const indexer_node& other ) : unfolded_type(other) {
+        tbb::internal::fgt_multiinput_node<N>( CODEPTR(), tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
                                            this->input_ports(), static_cast< sender< output_type > *>(this) );
     }
 
@@ -3379,12 +3722,20 @@ class indexer_node<T0, T1, T2, T3, T4, T5, T6, T7> : public internal::unfolded_i
     typedef typename internal::tagged_msg<size_t, T0, T1, T2, T3, T4, T5, T6, T7> output_type;
     typedef typename internal::unfolded_indexer_node<InputTuple> unfolded_type;
     indexer_node(graph& g) : unfolded_type(g) {
-        tbb::internal::fgt_multiinput_node<N>( tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
+        tbb::internal::fgt_multiinput_node<N>( CODEPTR(), tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
                                            this->input_ports(), static_cast< sender< output_type > *>(this) );
     }
+
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+    template <typename... Args>
+    indexer_node(const node_set<Args...>& nodes) : indexer_node(nodes.graph_reference()) {
+        make_edges_in_order(nodes, *this);
+    }
+#endif
+
     // Copy constructor
     indexer_node( const indexer_node& other ) : unfolded_type(other) {
-        tbb::internal::fgt_multiinput_node<N>( tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
+        tbb::internal::fgt_multiinput_node<N>( CODEPTR(), tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
                                            this->input_ports(), static_cast< sender< output_type > *>(this) );
     }
 
@@ -3406,13 +3757,21 @@ class indexer_node<T0, T1, T2, T3, T4, T5, T6, T7, T8> : public internal::unfold
     typedef tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8> InputTuple;
     typedef typename internal::tagged_msg<size_t, T0, T1, T2, T3, T4, T5, T6, T7, T8> output_type;
     typedef typename internal::unfolded_indexer_node<InputTuple> unfolded_type;
-    indexer_node(graph& g) : unfolded_type(g) {
-        tbb::internal::fgt_multiinput_node<N>( tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
+    __TBB_NOINLINE_SYM indexer_node(graph& g) : unfolded_type(g) {
+        tbb::internal::fgt_multiinput_node<N>( CODEPTR(), tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
                                            this->input_ports(), static_cast< sender< output_type > *>(this) );
     }
+
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+    template <typename... Args>
+    indexer_node(const node_set<Args...>& nodes) : indexer_node(nodes.graph_reference()) {
+        make_edges_in_order(nodes, *this);
+    }
+#endif
+
     // Copy constructor
-    indexer_node( const indexer_node& other ) : unfolded_type(other) {
-        tbb::internal::fgt_multiinput_node<N>( tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
+    __TBB_NOINLINE_SYM indexer_node( const indexer_node& other ) : unfolded_type(other) {
+        tbb::internal::fgt_multiinput_node<N>( CODEPTR(), tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
                                            this->input_ports(), static_cast< sender< output_type > *>(this) );
     }
 
@@ -3434,13 +3793,21 @@ class indexer_node/*default*/ : public internal::unfolded_indexer_node<tuple<T0,
     typedef tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> InputTuple;
     typedef typename internal::tagged_msg<size_t, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> output_type;
     typedef typename internal::unfolded_indexer_node<InputTuple> unfolded_type;
-    indexer_node(graph& g) : unfolded_type(g) {
-        tbb::internal::fgt_multiinput_node<N>( tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
+    __TBB_NOINLINE_SYM indexer_node(graph& g) : unfolded_type(g) {
+        tbb::internal::fgt_multiinput_node<N>( CODEPTR(), tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
                                            this->input_ports(), static_cast< sender< output_type > *>(this) );
     }
+
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+    template <typename... Args>
+    indexer_node(const node_set<Args...>& nodes) : indexer_node(nodes.graph_reference()) {
+        make_edges_in_order(nodes, *this);
+    }
+#endif
+
     // Copy constructor
-    indexer_node( const indexer_node& other ) : unfolded_type(other) {
-        tbb::internal::fgt_multiinput_node<N>( tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
+    __TBB_NOINLINE_SYM indexer_node( const indexer_node& other ) : unfolded_type(other) {
+        tbb::internal::fgt_multiinput_node<N>( CODEPTR(), tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
                                            this->input_ports(), static_cast< sender< output_type > *>(this) );
     }
 
@@ -3458,7 +3825,7 @@ inline void internal_make_edge( internal::untyped_sender &p, internal::untyped_r
 template< typename T >
 inline void internal_make_edge( sender<T> &p, receiver<T> &s ) {
 #endif
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
     s.internal_add_built_predecessor(p);
     p.internal_add_built_successor(s);
 #endif
@@ -3522,7 +3889,7 @@ template< typename T >
 inline void internal_remove_edge( sender<T> &p, receiver<T> &s ) {
 #endif
     p.remove_successor( s );
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
     // TODO: should we try to remove p from the predecessor list of s, in case the edge is reversed?
     p.internal_delete_built_successor(s);
     s.internal_delete_built_predecessor(p);
@@ -3577,7 +3944,7 @@ inline void remove_edge( sender<S>& output, V& input) {
 }
 #endif
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
 template<typename C >
 template< typename S >
 void internal::edge_container<C>::sender_extract( S &s ) {
@@ -3595,7 +3962,7 @@ void internal::edge_container<C>::receiver_extract( R &r ) {
         remove_edge(**i, r);
     }
 }
-#endif  /* TBB_PREVIEW_FLOW_GRAPH_FEATURES */
+#endif  /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
 
 //! Returns a copy of the body from a function or continue node
 template< typename Body, typename Node >
@@ -3616,11 +3983,8 @@ class composite_node <tbb::flow::tuple<InputTypes...>, tbb::flow::tuple<OutputTy
     typedef tbb::flow::tuple< sender<OutputTypes>&... > output_ports_type;
 
 private:
-#if TBB_PREVIEW_FLOW_GRAPH_TRACE
-    const char *my_type_name;
-#endif
-    input_ports_type *my_input_ports;
-    output_ports_type *my_output_ports;
+    std::unique_ptr<input_ports_type> my_input_ports;
+    std::unique_ptr<output_ports_type> my_output_ports;
 
     static const size_t NUM_INPUTS = sizeof...(InputTypes);
     static const size_t NUM_OUTPUTS = sizeof...(OutputTypes);
@@ -3630,37 +3994,32 @@ class composite_node <tbb::flow::tuple<InputTypes...>, tbb::flow::tuple<OutputTy
 
 public:
 #if TBB_PREVIEW_FLOW_GRAPH_TRACE
-    composite_node( graph &g, const char *type_name = "composite_node") : graph_node(g), my_type_name(type_name), my_input_ports(NULL), my_output_ports(NULL)  {
-        tbb::internal::itt_make_task_group( tbb::internal::ITT_DOMAIN_FLOW, this, tbb::internal::FLOW_NODE, &g, tbb::internal::FLOW_GRAPH, tbb::internal::FLOW_COMPOSITE_NODE );
-        tbb::internal::fgt_multiinput_multioutput_node_desc( this, my_type_name );
+    composite_node( graph &g, const char *type_name = "composite_node" ) : graph_node(g) {
+        tbb::internal::fgt_multiinput_multioutput_node( CODEPTR(), tbb::internal::FLOW_COMPOSITE_NODE, this, &this->my_graph );
+        tbb::internal::fgt_multiinput_multioutput_node_desc( this, type_name );
     }
 #else
-    composite_node( graph &g) : graph_node(g), my_input_ports(NULL), my_output_ports(NULL) {}
+    composite_node( graph &g ) : graph_node(g) {
+        tbb::internal::fgt_multiinput_multioutput_node( CODEPTR(), tbb::internal::FLOW_COMPOSITE_NODE, this, &this->my_graph );
+    }
 #endif
 
-   template<typename T1, typename T2>
-   void set_external_ports(T1&& input_ports_tuple, T2&& output_ports_tuple) {
-       __TBB_STATIC_ASSERT(NUM_INPUTS == tbb::flow::tuple_size<input_ports_type>::value, "number of arguments does not match number of input ports");
-       __TBB_STATIC_ASSERT(NUM_OUTPUTS == tbb::flow::tuple_size<output_ports_type>::value, "number of arguments does not match number of output ports");
-      my_input_ports =  new input_ports_type(std::forward<T1>(input_ports_tuple));
-      my_output_ports = new output_ports_type(std::forward<T2>(output_ports_tuple));
+    template<typename T1, typename T2>
+    void set_external_ports(T1&& input_ports_tuple, T2&& output_ports_tuple) {
+        __TBB_STATIC_ASSERT(NUM_INPUTS == tbb::flow::tuple_size<input_ports_type>::value, "number of arguments does not match number of input ports");
+        __TBB_STATIC_ASSERT(NUM_OUTPUTS == tbb::flow::tuple_size<output_ports_type>::value, "number of arguments does not match number of output ports");
+        my_input_ports = tbb::internal::make_unique<input_ports_type>(std::forward<T1>(input_ports_tuple));
+        my_output_ports = tbb::internal::make_unique<output_ports_type>(std::forward<T2>(output_ports_tuple));
 
-#if TBB_PREVIEW_FLOW_GRAPH_TRACE
-      tbb::internal::fgt_internal_input_helper<T1, NUM_INPUTS>::register_port( this, input_ports_tuple);
-      tbb::internal::fgt_internal_output_helper<T2, NUM_OUTPUTS>::register_port( this, output_ports_tuple);
-#endif
-   }
+        tbb::internal::fgt_internal_input_alias_helper<T1, NUM_INPUTS>::alias_port( this, input_ports_tuple);
+        tbb::internal::fgt_internal_output_alias_helper<T2, NUM_OUTPUTS>::alias_port( this, output_ports_tuple);
+    }
 
-#if TBB_PREVIEW_FLOW_GRAPH_TRACE
     template< typename... NodeTypes >
     void add_visible_nodes(const NodeTypes&... n) { internal::add_nodes_impl(this, true, n...); }
 
     template< typename... NodeTypes >
     void add_nodes(const NodeTypes&... n) { internal::add_nodes_impl(this, false, n...); }
-#else
-    template<typename... Nodes> void add_nodes(Nodes&...) { }
-    template<typename... Nodes> void add_visible_nodes(Nodes&...) { }
-#endif
 
 #if TBB_PREVIEW_FLOW_GRAPH_TRACE
     void set_name( const char *name ) __TBB_override {
@@ -3668,22 +4027,17 @@ class composite_node <tbb::flow::tuple<InputTypes...>, tbb::flow::tuple<OutputTy
     }
 #endif
 
-    input_ports_type input_ports() {
+    input_ports_type& input_ports() {
          __TBB_ASSERT(my_input_ports, "input ports not set, call set_external_ports to set input ports");
          return *my_input_ports;
     }
 
-    output_ports_type output_ports() {
+    output_ports_type& output_ports() {
          __TBB_ASSERT(my_output_ports, "output ports not set, call set_external_ports to set output ports");
          return *my_output_ports;
     }
 
-    virtual ~composite_node() {
-        if(my_input_ports) delete my_input_ports;
-        if(my_output_ports) delete my_output_ports;
-    }
-
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
     void extract() __TBB_override {
         __TBB_ASSERT(false, "Current composite_node implementation does not support extract");
     }
@@ -3697,10 +4051,7 @@ class composite_node <tbb::flow::tuple<InputTypes...>, tbb::flow::tuple<> > : pu
     typedef tbb::flow::tuple< receiver<InputTypes>&... > input_ports_type;
 
 private:
-#if TBB_PREVIEW_FLOW_GRAPH_TRACE
-    const char *my_type_name;
-#endif
-    input_ports_type *my_input_ports;
+    std::unique_ptr<input_ports_type> my_input_ports;
     static const size_t NUM_INPUTS = sizeof...(InputTypes);
 
 protected:
@@ -3708,35 +4059,30 @@ class composite_node <tbb::flow::tuple<InputTypes...>, tbb::flow::tuple<> > : pu
 
 public:
 #if TBB_PREVIEW_FLOW_GRAPH_TRACE
-    composite_node( graph &g, const char *type_name = "composite_node") : graph_node(g), my_type_name(type_name), my_input_ports(NULL)  {
-        tbb::internal::itt_make_task_group( tbb::internal::ITT_DOMAIN_FLOW, this, tbb::internal::FLOW_NODE, &g, tbb::internal::FLOW_GRAPH, tbb::internal::FLOW_COMPOSITE_NODE );
-        tbb::internal::fgt_multiinput_multioutput_node_desc( this, my_type_name );
+    composite_node( graph &g, const char *type_name = "composite_node") : graph_node(g) {
+        tbb::internal::fgt_composite( CODEPTR(), this, &g );
+        tbb::internal::fgt_multiinput_multioutput_node_desc( this, type_name );
     }
 #else
-    composite_node( graph &g) : graph_node(g), my_input_ports(NULL) {}
+    composite_node( graph &g ) : graph_node(g) {
+        tbb::internal::fgt_composite( CODEPTR(), this, &g );
+    }
 #endif
 
    template<typename T>
    void set_external_ports(T&& input_ports_tuple) {
        __TBB_STATIC_ASSERT(NUM_INPUTS == tbb::flow::tuple_size<input_ports_type>::value, "number of arguments does not match number of input ports");
 
-      my_input_ports =  new input_ports_type(std::forward<T>(input_ports_tuple));
+       my_input_ports = tbb::internal::make_unique<input_ports_type>(std::forward<T>(input_ports_tuple));
 
-#if TBB_PREVIEW_FLOW_GRAPH_TRACE
-      tbb::internal::fgt_internal_input_helper<T, NUM_INPUTS>::register_port( this, std::forward<T>(input_ports_tuple));
-#endif
+       tbb::internal::fgt_internal_input_alias_helper<T, NUM_INPUTS>::alias_port( this, std::forward<T>(input_ports_tuple));
    }
 
-#if TBB_PREVIEW_FLOW_GRAPH_TRACE
     template< typename... NodeTypes >
     void add_visible_nodes(const NodeTypes&... n) { internal::add_nodes_impl(this, true, n...); }
 
     template< typename... NodeTypes >
     void add_nodes( const NodeTypes&... n) { internal::add_nodes_impl(this, false, n...); }
-#else
-    template<typename... Nodes> void add_nodes(Nodes&...) {}
-    template<typename... Nodes> void add_visible_nodes(Nodes&...) {}
-#endif
 
 #if TBB_PREVIEW_FLOW_GRAPH_TRACE
     void set_name( const char *name ) __TBB_override {
@@ -3744,16 +4090,12 @@ class composite_node <tbb::flow::tuple<InputTypes...>, tbb::flow::tuple<> > : pu
     }
 #endif
 
-    input_ports_type input_ports() {
+    input_ports_type& input_ports() {
          __TBB_ASSERT(my_input_ports, "input ports not set, call set_external_ports to set input ports");
          return *my_input_ports;
     }
 
-    virtual ~composite_node() {
-        if(my_input_ports) delete my_input_ports;
-    }
-
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
     void extract() __TBB_override {
         __TBB_ASSERT(false, "Current composite_node implementation does not support extract");
     }
@@ -3768,10 +4110,7 @@ class composite_node <tbb::flow::tuple<>, tbb::flow::tuple<OutputTypes...> > : p
     typedef tbb::flow::tuple< sender<OutputTypes>&... > output_ports_type;
 
 private:
-#if TBB_PREVIEW_FLOW_GRAPH_TRACE
-    const char *my_type_name;
-#endif
-    output_ports_type *my_output_ports;
+    std::unique_ptr<output_ports_type> my_output_ports;
     static const size_t NUM_OUTPUTS = sizeof...(OutputTypes);
 
 protected:
@@ -3779,35 +4118,30 @@ class composite_node <tbb::flow::tuple<>, tbb::flow::tuple<OutputTypes...> > : p
 
 public:
 #if TBB_PREVIEW_FLOW_GRAPH_TRACE
-    composite_node( graph &g, const char *type_name = "composite_node") : graph_node(g), my_type_name(type_name), my_output_ports(NULL) {
-        tbb::internal::itt_make_task_group( tbb::internal::ITT_DOMAIN_FLOW, this, tbb::internal::FLOW_NODE, &g, tbb::internal::FLOW_GRAPH, tbb::internal::FLOW_COMPOSITE_NODE );
-        tbb::internal::fgt_multiinput_multioutput_node_desc( this, my_type_name );
+    __TBB_NOINLINE_SYM composite_node( graph &g, const char *type_name = "composite_node") : graph_node(g) {
+        tbb::internal::fgt_composite( CODEPTR(), this, &g );
+        tbb::internal::fgt_multiinput_multioutput_node_desc( this, type_name );
     }
 #else
-    composite_node( graph &g) : graph_node(g), my_output_ports(NULL) {}
+    __TBB_NOINLINE_SYM composite_node( graph &g ) : graph_node(g) {
+        tbb::internal::fgt_composite( CODEPTR(), this, &g );
+    }
 #endif
 
    template<typename T>
    void set_external_ports(T&& output_ports_tuple) {
        __TBB_STATIC_ASSERT(NUM_OUTPUTS == tbb::flow::tuple_size<output_ports_type>::value, "number of arguments does not match number of output ports");
 
-      my_output_ports = new output_ports_type(std::forward<T>(output_ports_tuple));
+       my_output_ports = tbb::internal::make_unique<output_ports_type>(std::forward<T>(output_ports_tuple));
 
-#if TBB_PREVIEW_FLOW_GRAPH_TRACE
-      tbb::internal::fgt_internal_output_helper<T, NUM_OUTPUTS>::register_port( this, std::forward<T>(output_ports_tuple));
-#endif
+       tbb::internal::fgt_internal_output_alias_helper<T, NUM_OUTPUTS>::alias_port( this, std::forward<T>(output_ports_tuple));
    }
 
-#if TBB_PREVIEW_FLOW_GRAPH_TRACE
     template<typename... NodeTypes >
     void add_visible_nodes(const NodeTypes&... n) { internal::add_nodes_impl(this, true, n...); }
 
     template<typename... NodeTypes >
     void add_nodes(const NodeTypes&... n) { internal::add_nodes_impl(this, false, n...); }
-#else
-    template<typename... Nodes> void add_nodes(Nodes&...) {}
-    template<typename... Nodes> void add_visible_nodes(Nodes&...) {}
-#endif
 
 #if TBB_PREVIEW_FLOW_GRAPH_TRACE
     void set_name( const char *name ) __TBB_override {
@@ -3815,16 +4149,12 @@ class composite_node <tbb::flow::tuple<>, tbb::flow::tuple<OutputTypes...> > : p
     }
 #endif
 
-    output_ports_type output_ports() {
+    output_ports_type& output_ports() {
          __TBB_ASSERT(my_output_ports, "output ports not set, call set_external_ports to set output ports");
          return *my_output_ports;
     }
 
-    virtual ~composite_node() {
-        if(my_output_ports) delete my_output_ports;
-    }
-
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
     void extract() __TBB_override {
         __TBB_ASSERT(false, "Current composite_node implementation does not support extract");
     }
@@ -3856,7 +4186,7 @@ class async_body: public async_body_base<Gateway> {
     typedef async_body_base<Gateway> base_type;
     typedef Gateway gateway_type;
 
-    async_body(const Body &body, gateway_type *gateway) 
+    async_body(const Body &body, gateway_type *gateway)
         : base_type(gateway), my_body(body) { }
 
     void operator()( const Input &v, Ports & ) {
@@ -3869,13 +4199,27 @@ class async_body: public async_body_base<Gateway> {
     Body my_body;
 };
 
-}
+} // namespace internal
+
+} // namespace interfaceX
+namespace interface11 {
 
 //! Implements async node
-template < typename Input, typename Output, typename Policy = queueing, typename Allocator=cache_aligned_allocator<Input> >
-class async_node : public multifunction_node< Input, tuple< Output >, Policy, Allocator >, public sender< Output > {
+template < typename Input, typename Output,
+           typename Policy = queueing_lightweight,
+           typename Allocator=__TBB_DEFAULT_NODE_ALLOCATOR(Input) >
+class async_node
+    : public multifunction_node< Input, tuple< Output >, Policy, Allocator >, public sender< Output >
+{
+#if !TBB_DEPRECATED_FLOW_NODE_ALLOCATOR
+    __TBB_STATIC_ASSERT(
+        (tbb::internal::is_same_type<Allocator, null_type>::value),
+        "Allocator template parameter for flow graph nodes is deprecated and will removed in the future. "
+        "To temporary enable the deprecated interface specify TBB_ENABLE_DEPRECATED_NODE_ALLOCATOR."
+    );
+#endif
     typedef multifunction_node< Input, tuple< Output >, Policy, Allocator > base_type;
-    typedef typename internal::multifunction_input<Input, typename base_type::output_ports_type, Allocator> mfn_input_type;
+    typedef typename internal::multifunction_input<Input, typename base_type::output_ports_type, Policy, Allocator> mfn_input_type;
 
 public:
     typedef Input input_type;
@@ -3885,11 +4229,13 @@ class async_node : public multifunction_node< Input, tuple< Output >, Policy, Al
     typedef typename sender<output_type>::successor_type successor_type;
     typedef receiver_gateway<output_type> gateway_type;
     typedef internal::async_body_base<gateway_type> async_body_base_type;
+    typedef typename base_type::output_ports_type output_ports_type;
 
 private:
     struct try_put_functor {
         typedef internal::multifunction_output<Output> output_port_type;
         output_port_type *port;
+        // TODO: pass value by copy since we do not want to block asynchronous thread.
         const Output *value;
         bool result;
         try_put_functor(output_port_type &p, const Output &v) : port(&p), value(&v), result(false) { }
@@ -3902,8 +4248,8 @@ class async_node : public multifunction_node< Input, tuple< Output >, Policy, Al
     public:
         receiver_gateway_impl(async_node* node): my_node(node) {}
         void reserve_wait() __TBB_override {
-            my_node->my_graph.reserve_wait();
             tbb::internal::fgt_async_reserve(static_cast<typename async_node::receiver_type *>(my_node), &my_node->my_graph);
+            my_node->my_graph.reserve_wait();
         }
 
         void release_wait() __TBB_override {
@@ -3926,29 +4272,69 @@ class async_node : public multifunction_node< Input, tuple< Output >, Policy, Al
     //! Implements gateway_type::try_put for an external activity to submit a message to FG
     bool try_put_impl(const Output &i) {
         internal::multifunction_output<Output> &port_0 = internal::output_port<0>(*this);
+        internal::broadcast_cache<output_type>& port_successors = port_0.successors();
         tbb::internal::fgt_async_try_put_begin(this, &port_0);
-        __TBB_ASSERT(this->my_graph.my_task_arena && this->my_graph.my_task_arena->is_active(), NULL);
-        try_put_functor tpf(port_0, i);
-        this->my_graph.my_task_arena->execute(tpf);
+        task_list tasks;
+        bool is_at_least_one_put_successful = port_successors.gather_successful_try_puts(i, tasks);
+        __TBB_ASSERT( is_at_least_one_put_successful || tasks.empty(),
+                      "Return status is inconsistent with the method operation." );
+
+        while( !tasks.empty() ) {
+            internal::enqueue_in_graph_arena(this->my_graph, tasks.pop_front());
+        }
         tbb::internal::fgt_async_try_put_end(this, &port_0);
-        return tpf.result;
+        return is_at_least_one_put_successful;
     }
 
 public:
     template<typename Body>
-    async_node( graph &g, size_t concurrency, Body body ) :
-        base_type( g, concurrency, internal::async_body<Input, typename base_type::output_ports_type, gateway_type, Body>(body, &my_gateway) ), my_gateway(self()) {
-        tbb::internal::fgt_multioutput_node<1>( tbb::internal::FLOW_ASYNC_NODE,
-                                                &this->my_graph,
-                                                static_cast<receiver<input_type> *>(this),
-                                                this->output_ports() );
-    }
-
-    async_node( const async_node &other ) : base_type(other), sender<Output>(), my_gateway(self()) {
+    __TBB_NOINLINE_SYM async_node(
+        graph &g, size_t concurrency,
+#if __TBB_CPP11_PRESENT
+        Body body, __TBB_FLOW_GRAPH_PRIORITY_ARG1(Policy = Policy(), node_priority_t priority = tbb::flow::internal::no_priority)
+#else
+        __TBB_FLOW_GRAPH_PRIORITY_ARG1(Body body, node_priority_t priority = tbb::flow::internal::no_priority)
+#endif
+    ) : base_type(
+        g, concurrency,
+        internal::async_body<Input, typename base_type::output_ports_type, gateway_type, Body>
+        (body, &my_gateway) __TBB_FLOW_GRAPH_PRIORITY_ARG0(priority) ), my_gateway(self()) {
+        tbb::internal::fgt_multioutput_node_with_body<1>(
+            CODEPTR(), tbb::internal::FLOW_ASYNC_NODE,
+            &this->my_graph, static_cast<receiver<input_type> *>(this),
+            this->output_ports(), this->my_body
+        );
+    }
+
+#if __TBB_PREVIEW_FLOW_GRAPH_PRIORITIES && __TBB_CPP11_PRESENT
+    template <typename Body, typename... Args>
+    __TBB_NOINLINE_SYM async_node(graph& g, size_t concurrency, Body body, node_priority_t priority)
+        : async_node(g, concurrency, body, Policy(), priority) {}
+#endif // __TBB_PREVIEW_FLOW_GRAPH_PRIORITIES
+
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+    template <typename Body, typename... Args>
+    __TBB_NOINLINE_SYM async_node(
+        const node_set<Args...>& nodes, size_t concurrency, Body body,
+        __TBB_FLOW_GRAPH_PRIORITY_ARG1(Policy = Policy(), node_priority_t priority = tbb::flow::internal::no_priority)
+    ) : async_node(nodes.graph_reference(), concurrency, __TBB_FLOW_GRAPH_PRIORITY_ARG1(body, priority)) {
+        make_edges_in_order(nodes, *this);
+    }
+
+#if __TBB_PREVIEW_FLOW_GRAPH_PRIORITIES
+    template <typename Body, typename... Args>
+    __TBB_NOINLINE_SYM async_node(const node_set<Args...>& nodes, size_t concurrency, Body body, node_priority_t priority)
+        : async_node(nodes, concurrency, body, Policy(), priority) {}
+#endif // __TBB_PREVIEW_FLOW_GRAPH_PRIORITIES
+#endif // __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+
+    __TBB_NOINLINE_SYM async_node( const async_node &other ) : base_type(other), sender<Output>(), my_gateway(self()) {
         static_cast<async_body_base_type*>(this->my_body->get_body_ptr())->set_gateway(&my_gateway);
         static_cast<async_body_base_type*>(this->my_init_body->get_body_ptr())->set_gateway(&my_gateway);
 
-        tbb::internal::fgt_multioutput_node<1>( tbb::internal::FLOW_ASYNC_NODE, &this->my_graph, static_cast<receiver<input_type> *>(this), this->output_ports() );
+        tbb::internal::fgt_multioutput_node_with_body<1>( CODEPTR(), tbb::internal::FLOW_ASYNC_NODE,
+                &this->my_graph, static_cast<receiver<input_type> *>(this),
+                this->output_ports(), this->my_body );
     }
 
     gateway_type& gateway() {
@@ -3957,7 +4343,7 @@ class async_node : public multifunction_node< Input, tuple< Output >, Policy, Al
 
 #if TBB_PREVIEW_FLOW_GRAPH_TRACE
     void set_name( const char *name ) __TBB_override {
-            tbb::internal::fgt_node_desc( this, name );
+        tbb::internal::fgt_multioutput_node_desc( this, name );
     }
 #endif
 
@@ -3982,7 +4368,7 @@ class async_node : public multifunction_node< Input, tuple< Output >, Policy, Al
         return ab.get_body();
     }
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
     //! interface to record edges for traversal & deletion
     typedef typename  internal::edge_container<successor_type> built_successors_type;
     typedef typename  built_successors_type::edge_list_type successor_list_type;
@@ -4005,7 +4391,7 @@ class async_node : public multifunction_node< Input, tuple< Output >, Policy, Al
     size_t  successor_count() __TBB_override {
         return internal::output_port<0>(*this).successor_count();
     }
-#endif
+#endif /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
 
 protected:
 
@@ -4018,58 +4404,340 @@ class async_node : public multifunction_node< Input, tuple< Output >, Policy, Al
 #include "internal/_flow_graph_streaming_node.h"
 #endif // __TBB_PREVIEW_STREAMING_NODE
 
-} // interface9
-
-    using interface9::reset_flags;
-    using interface9::rf_reset_protocol;
-    using interface9::rf_reset_bodies;
-    using interface9::rf_clear_edges;
-
-    using interface9::graph;
-    using interface9::graph_node;
-    using interface9::continue_msg;
-
-    using interface9::source_node;
-    using interface9::function_node;
-    using interface9::multifunction_node;
-    using interface9::split_node;
-    using interface9::internal::output_port;
-    using interface9::indexer_node;
-    using interface9::internal::tagged_msg;
-    using interface9::internal::cast_to;
-    using interface9::internal::is_a;
-    using interface9::continue_node;
-    using interface9::overwrite_node;
-    using interface9::write_once_node;
-    using interface9::broadcast_node;
-    using interface9::buffer_node;
-    using interface9::queue_node;
-    using interface9::sequencer_node;
-    using interface9::priority_queue_node;
-    using interface9::limiter_node;
-    using namespace interface9::internal::graph_policy_namespace;
-    using interface9::join_node;
-    using interface9::input_port;
-    using interface9::copy_body;
-    using interface9::make_edge;
-    using interface9::remove_edge;
-    using interface9::internal::tag_value;
+#include "internal/_flow_graph_node_set_impl.h"
+
+template< typename T >
+class overwrite_node : public graph_node, public receiver<T>, public sender<T> {
+public:
+    typedef T input_type;
+    typedef T output_type;
+    typedef typename receiver<input_type>::predecessor_type predecessor_type;
+    typedef typename sender<output_type>::successor_type successor_type;
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
+    typedef typename receiver<input_type>::built_predecessors_type built_predecessors_type;
+    typedef typename sender<output_type>::built_successors_type built_successors_type;
+    typedef typename receiver<input_type>::predecessor_list_type predecessor_list_type;
+    typedef typename sender<output_type>::successor_list_type successor_list_type;
+#endif
+
+    __TBB_NOINLINE_SYM explicit overwrite_node(graph &g) : graph_node(g), my_buffer_is_valid(false) {
+        my_successors.set_owner( this );
+        tbb::internal::fgt_node( CODEPTR(), tbb::internal::FLOW_OVERWRITE_NODE, &this->my_graph,
+                                 static_cast<receiver<input_type> *>(this), static_cast<sender<output_type> *>(this) );
+    }
+
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+    template <typename... Args>
+    overwrite_node(const node_set<Args...>& nodes) : overwrite_node(nodes.graph_reference()) {
+        make_edges_in_order(nodes, *this);
+    }
+#endif
+
+    //! Copy constructor; doesn't take anything from src; default won't work
+    __TBB_NOINLINE_SYM overwrite_node( const overwrite_node& src ) :
+        graph_node(src.my_graph), receiver<T>(), sender<T>(), my_buffer_is_valid(false)
+    {
+        my_successors.set_owner( this );
+        tbb::internal::fgt_node( CODEPTR(), tbb::internal::FLOW_OVERWRITE_NODE, &this->my_graph,
+                                 static_cast<receiver<input_type> *>(this), static_cast<sender<output_type> *>(this) );
+    }
+
+    ~overwrite_node() {}
+
+#if TBB_PREVIEW_FLOW_GRAPH_TRACE
+    void set_name( const char *name ) __TBB_override {
+        tbb::internal::fgt_node_desc( this, name );
+    }
+#endif
+
+   bool register_successor( successor_type &s ) __TBB_override {
+        spin_mutex::scoped_lock l( my_mutex );
+        if (my_buffer_is_valid && internal::is_graph_active( my_graph )) {
+            // We have a valid value that must be forwarded immediately.
+            bool ret = s.try_put( my_buffer );
+            if ( ret ) {
+                // We add the successor that accepted our put
+                my_successors.register_successor( s );
+            } else {
+                // In case of reservation a race between the moment of reservation and register_successor can appear,
+                // because failed reserve does not mean that register_successor is not ready to put a message immediately.
+                // We have some sort of infinite loop: reserving node tries to set pull state for the edge,
+                // but overwrite_node tries to return push state back. That is why we have to break this loop with task creation.
+                task *rtask = new ( task::allocate_additional_child_of( *( my_graph.root_task() ) ) )
+                    register_predecessor_task( *this, s );
+                internal::spawn_in_graph_arena( my_graph, *rtask );
+            }
+        } else {
+            // No valid value yet, just add as successor
+            my_successors.register_successor( s );
+        }
+        return true;
+    }
+
+    bool remove_successor( successor_type &s ) __TBB_override {
+        spin_mutex::scoped_lock l( my_mutex );
+        my_successors.remove_successor(s);
+        return true;
+    }
+
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
+    built_predecessors_type &built_predecessors() __TBB_override { return my_built_predecessors; }
+    built_successors_type   &built_successors()   __TBB_override { return my_successors.built_successors(); }
+
+    void internal_add_built_successor( successor_type &s) __TBB_override {
+        spin_mutex::scoped_lock l( my_mutex );
+        my_successors.internal_add_built_successor(s);
+    }
+
+    void internal_delete_built_successor( successor_type &s) __TBB_override {
+        spin_mutex::scoped_lock l( my_mutex );
+        my_successors.internal_delete_built_successor(s);
+    }
+
+    size_t successor_count() __TBB_override {
+        spin_mutex::scoped_lock l( my_mutex );
+        return my_successors.successor_count();
+    }
+
+    void copy_successors(successor_list_type &v) __TBB_override {
+        spin_mutex::scoped_lock l( my_mutex );
+        my_successors.copy_successors(v);
+    }
+
+    void internal_add_built_predecessor( predecessor_type &p) __TBB_override {
+        spin_mutex::scoped_lock l( my_mutex );
+        my_built_predecessors.add_edge(p);
+    }
+
+    void internal_delete_built_predecessor( predecessor_type &p) __TBB_override {
+        spin_mutex::scoped_lock l( my_mutex );
+        my_built_predecessors.delete_edge(p);
+    }
+
+    size_t predecessor_count() __TBB_override {
+        spin_mutex::scoped_lock l( my_mutex );
+        return my_built_predecessors.edge_count();
+    }
+
+    void copy_predecessors( predecessor_list_type &v ) __TBB_override {
+        spin_mutex::scoped_lock l( my_mutex );
+        my_built_predecessors.copy_edges(v);
+    }
+
+    void extract() __TBB_override {
+        my_buffer_is_valid = false;
+        built_successors().sender_extract(*this);
+        built_predecessors().receiver_extract(*this);
+    }
+
+#endif  /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
+
+    bool try_get( input_type &v ) __TBB_override {
+        spin_mutex::scoped_lock l( my_mutex );
+        if ( my_buffer_is_valid ) {
+            v = my_buffer;
+            return true;
+        }
+        return false;
+    }
+
+    //! Reserves an item
+    bool try_reserve( T &v ) __TBB_override {
+        return try_get(v);
+    }
+
+    //! Releases the reserved item
+    bool try_release() __TBB_override { return true; }
+
+    //! Consumes the reserved item
+    bool try_consume() __TBB_override { return true; }
+
+    bool is_valid() {
+       spin_mutex::scoped_lock l( my_mutex );
+       return my_buffer_is_valid;
+    }
+
+    void clear() {
+       spin_mutex::scoped_lock l( my_mutex );
+       my_buffer_is_valid = false;
+    }
+
+protected:
+
+    template< typename R, typename B > friend class run_and_put_task;
+    template<typename X, typename Y> friend class internal::broadcast_cache;
+    template<typename X, typename Y> friend class internal::round_robin_cache;
+    task * try_put_task( const input_type &v ) __TBB_override {
+        spin_mutex::scoped_lock l( my_mutex );
+        return try_put_task_impl(v);
+    }
+
+    task * try_put_task_impl(const input_type &v) {
+        my_buffer = v;
+        my_buffer_is_valid = true;
+        task * rtask = my_successors.try_put_task(v);
+        if (!rtask) rtask = SUCCESSFULLY_ENQUEUED;
+        return rtask;
+    }
+
+    graph& graph_reference() const __TBB_override {
+        return my_graph;
+    }
+
+    //! Breaks an infinite loop between the node reservation and register_successor call
+    struct register_predecessor_task : public graph_task {
+
+        register_predecessor_task(predecessor_type& owner, successor_type& succ) :
+            o(owner), s(succ) {};
+
+        tbb::task* execute() __TBB_override {
+            if (!s.register_predecessor(o)) {
+                o.register_successor(s);
+            }
+            return NULL;
+        }
+
+        predecessor_type& o;
+        successor_type& s;
+    };
+
+    spin_mutex my_mutex;
+    internal::broadcast_cache< input_type, null_rw_mutex > my_successors;
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
+    internal::edge_container<predecessor_type> my_built_predecessors;
+#endif
+    input_type my_buffer;
+    bool my_buffer_is_valid;
+    void reset_receiver(reset_flags /*f*/) __TBB_override {}
+
+    void reset_node( reset_flags f) __TBB_override {
+        my_buffer_is_valid = false;
+       if (f&rf_clear_edges) {
+           my_successors.clear();
+       }
+    }
+};  // overwrite_node
+
+template< typename T >
+class write_once_node : public overwrite_node<T> {
+public:
+    typedef T input_type;
+    typedef T output_type;
+    typedef overwrite_node<T> base_type;
+    typedef typename receiver<input_type>::predecessor_type predecessor_type;
+    typedef typename sender<output_type>::successor_type successor_type;
+
+    //! Constructor
+    __TBB_NOINLINE_SYM explicit write_once_node(graph& g) : base_type(g) {
+        tbb::internal::fgt_node( CODEPTR(), tbb::internal::FLOW_WRITE_ONCE_NODE, &(this->my_graph),
+                                 static_cast<receiver<input_type> *>(this),
+                                 static_cast<sender<output_type> *>(this) );
+    }
+
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+    template <typename... Args>
+    write_once_node(const node_set<Args...>& nodes) : write_once_node(nodes.graph_reference()) {
+        make_edges_in_order(nodes, *this);
+    }
+#endif
+
+    //! Copy constructor: call base class copy constructor
+    __TBB_NOINLINE_SYM write_once_node( const write_once_node& src ) : base_type(src) {
+        tbb::internal::fgt_node( CODEPTR(), tbb::internal::FLOW_WRITE_ONCE_NODE, &(this->my_graph),
+                                 static_cast<receiver<input_type> *>(this),
+                                 static_cast<sender<output_type> *>(this) );
+    }
+
+#if TBB_PREVIEW_FLOW_GRAPH_TRACE
+    void set_name( const char *name ) __TBB_override {
+        tbb::internal::fgt_node_desc( this, name );
+    }
+#endif
+
+protected:
+    template< typename R, typename B > friend class run_and_put_task;
+    template<typename X, typename Y> friend class internal::broadcast_cache;
+    template<typename X, typename Y> friend class internal::round_robin_cache;
+    task *try_put_task( const T &v ) __TBB_override {
+        spin_mutex::scoped_lock l( this->my_mutex );
+        return this->my_buffer_is_valid ? NULL : this->try_put_task_impl(v);
+    }
+};
+
+} // interfaceX
+
+    using interface11::reset_flags;
+    using interface11::rf_reset_protocol;
+    using interface11::rf_reset_bodies;
+    using interface11::rf_clear_edges;
+
+    using interface11::graph;
+    using interface11::graph_node;
+    using interface11::continue_msg;
+    using interface11::source_node;
+    using interface11::input_node;
+    using interface11::function_node;
+    using interface11::multifunction_node;
+    using interface11::split_node;
+    using interface11::internal::output_port;
+    using interface11::indexer_node;
+    using interface11::internal::tagged_msg;
+    using interface11::internal::cast_to;
+    using interface11::internal::is_a;
+    using interface11::continue_node;
+    using interface11::overwrite_node;
+    using interface11::write_once_node;
+    using interface11::broadcast_node;
+    using interface11::buffer_node;
+    using interface11::queue_node;
+    using interface11::sequencer_node;
+    using interface11::priority_queue_node;
+    using interface11::limiter_node;
+    using namespace interface11::internal::graph_policy_namespace;
+    using interface11::join_node;
+    using interface11::input_port;
+    using interface11::copy_body;
+    using interface11::make_edge;
+    using interface11::remove_edge;
+    using interface11::internal::tag_value;
 #if __TBB_FLOW_GRAPH_CPP11_FEATURES
-     using interface9::composite_node;
+    using interface11::composite_node;
 #endif
-    using interface9::async_node;
+    using interface11::async_node;
 #if __TBB_PREVIEW_ASYNC_MSG
-    using interface9::async_msg;
+    using interface11::async_msg;
 #endif
 #if __TBB_PREVIEW_STREAMING_NODE
-    using interface9::port_ref;
-    using interface9::streaming_node;
+    using interface11::port_ref;
+    using interface11::streaming_node;
 #endif // __TBB_PREVIEW_STREAMING_NODE
+#if __TBB_PREVIEW_FLOW_GRAPH_PRIORITIES
+    using internal::node_priority_t;
+    using internal::no_priority;
+#endif
+
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+    using interface11::internal::follows;
+    using interface11::internal::precedes;
+    using interface11::internal::make_node_set;
+    using interface11::internal::make_edges;
+#endif
 
 } // flow
 } // tbb
 
+// Include deduction guides for node classes
+#include "internal/_flow_graph_nodes_deduction.h"
+
 #undef __TBB_PFG_RESET_ARG
 #undef __TBB_COMMA
+#undef __TBB_DEFAULT_NODE_ALLOCATOR
+
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_flow_graph_H_include_area
+
+#if TBB_USE_THREADING_TOOLS && TBB_PREVIEW_FLOW_GRAPH_TRACE && ( __linux__ || __APPLE__ )
+   #undef __TBB_NOINLINE_SYM
+#endif
 
 #endif // __TBB_flow_graph_H
diff --git a/inst/include/tbb/flow_graph_abstractions.h b/inst/include/tbb/flow_graph_abstractions.h
index f6eb3fb3..f8ac239c 100644
--- a/inst/include/tbb/flow_graph_abstractions.h
+++ b/inst/include/tbb/flow_graph_abstractions.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_flow_graph_abstractions_H
@@ -23,7 +19,7 @@
 
 namespace tbb {
 namespace flow {
-namespace interface9 {
+namespace interface11 {
 
 //! Pure virtual template classes that define interfaces for async communication
 class graph_proxy {
@@ -47,10 +43,10 @@ class receiver_gateway : public graph_proxy {
     virtual bool try_put(const input_type&) = 0;
 };
 
-} //interface9
+} //interfaceX
 
-using interface9::graph_proxy;
-using interface9::receiver_gateway;
+using interface11::graph_proxy;
+using interface11::receiver_gateway;
 
 } //flow
 } //tbb
diff --git a/inst/include/tbb/flow_graph_opencl_node.h b/inst/include/tbb/flow_graph_opencl_node.h
index 89f4da7b..e6670db6 100644
--- a/inst/include/tbb/flow_graph_opencl_node.h
+++ b/inst/include/tbb/flow_graph_opencl_node.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,15 +12,25 @@
     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 "internal/_deprecated_header_message_guard.h"
 
+#if !defined(__TBB_show_deprecation_message_flow_graph_opencl_node_H) && defined(__TBB_show_deprecated_header_message)
+#define  __TBB_show_deprecation_message_flow_graph_opencl_node_H
+#pragma message("TBB Warning: tbb/flow_graph_opencl_node.h is deprecated. For details, please see Deprecated Features appendix in the TBB reference manual.")
+#endif
 
-
-*/
+#if defined(__TBB_show_deprecated_header_message)
+#undef __TBB_show_deprecated_header_message
+#endif
 
 #ifndef __TBB_flow_graph_opencl_node_H
 #define __TBB_flow_graph_opencl_node_H
 
+#define __TBB_flow_graph_opencl_node_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #include "tbb/tbb_config.h"
 #if __TBB_PREVIEW_OPENCL_NODE
 
@@ -43,100 +53,70 @@
 namespace tbb {
 namespace flow {
 
-namespace interface9 {
-
-class opencl_foundation;
-class opencl_device_list;
-
-template <typename Factory>
-class opencl_buffer_impl;
-
-template <typename Factory>
-class opencl_program;
-
-class default_opencl_factory;
-
-class opencl_graph : public graph {
-public:
-    //! Constructs a graph with isolated task_group_context
-    opencl_graph() : my_opencl_foundation( NULL ) {}
-    //! Constructs a graph with an user context
-    explicit opencl_graph( task_group_context& context ) : graph( context ), my_opencl_foundation( NULL ) {}
-    //! Destroys a graph
-    ~opencl_graph();
-    //! Available devices
-    const opencl_device_list& available_devices();
-    default_opencl_factory& opencl_factory();
-protected:
-    opencl_foundation *my_opencl_foundation;
-    opencl_foundation &get_opencl_foundation();
-
-    template <typename T, typename Factory>
-    friend class opencl_buffer;
-    template <cl_channel_order channel_order, cl_channel_type channel_type, typename Factory>
-    friend class opencl_image2d;
-    template<typename... Args>
-    friend class opencl_node;
-    template <typename DeviceFilter>
-    friend class opencl_factory;
-};
+namespace interface11 {
 
 template <typename DeviceFilter>
 class opencl_factory;
 
-template <typename T, typename Factory>
-class dependency_msg;
+namespace opencl_info {
+class default_opencl_factory;
+}
 
+template <typename Factory>
+class opencl_program;
 
-inline void enforce_cl_retcode( cl_int err, std::string msg ) {
-    if ( err != CL_SUCCESS ) {
+inline void enforce_cl_retcode(cl_int err, std::string msg) {
+    if (err != CL_SUCCESS) {
         std::cerr << msg << "; error code: " << err << std::endl;
         throw msg;
     }
 }
 
 template <typename T>
-T event_info( cl_event e, cl_event_info i ) {
+T event_info(cl_event e, cl_event_info i) {
     T res;
-    enforce_cl_retcode( clGetEventInfo( e, i, sizeof( res ), &res, NULL ), "Failed to get OpenCL event information" );
+    enforce_cl_retcode(clGetEventInfo(e, i, sizeof(res), &res, NULL), "Failed to get OpenCL event information");
     return res;
 }
 
 template <typename T>
-T device_info( cl_device_id d, cl_device_info i ) {
+T device_info(cl_device_id d, cl_device_info i) {
     T res;
-    enforce_cl_retcode( clGetDeviceInfo( d, i, sizeof( res ), &res, NULL ), "Failed to get OpenCL device information" );
+    enforce_cl_retcode(clGetDeviceInfo(d, i, sizeof(res), &res, NULL), "Failed to get OpenCL device information");
     return res;
 }
+
 template <>
-std::string device_info<std::string>( cl_device_id d, cl_device_info i ) {
+inline std::string device_info<std::string>(cl_device_id d, cl_device_info i) {
     size_t required;
-    enforce_cl_retcode( clGetDeviceInfo( d, i, 0, NULL, &required ), "Failed to get OpenCL device information" );
+    enforce_cl_retcode(clGetDeviceInfo(d, i, 0, NULL, &required), "Failed to get OpenCL device information");
 
-    char *buff = (char*)alloca( required );
-    enforce_cl_retcode( clGetDeviceInfo( d, i, required, buff, NULL ), "Failed to get OpenCL device information" );
+    char *buff = (char*)alloca(required);
+    enforce_cl_retcode(clGetDeviceInfo(d, i, required, buff, NULL), "Failed to get OpenCL device information");
 
     return buff;
 }
+
 template <typename T>
-T platform_info( cl_platform_id p, cl_platform_info i ) {
+T platform_info(cl_platform_id p, cl_platform_info i) {
     T res;
-    enforce_cl_retcode( clGetPlatformInfo( p, i, sizeof( res ), &res, NULL ), "Failed to get OpenCL platform information" );
+    enforce_cl_retcode(clGetPlatformInfo(p, i, sizeof(res), &res, NULL), "Failed to get OpenCL platform information");
     return res;
 }
+
 template <>
-std::string platform_info<std::string>( cl_platform_id p, cl_platform_info  i ) {
+inline std::string platform_info<std::string>(cl_platform_id p, cl_platform_info  i) {
     size_t required;
-    enforce_cl_retcode( clGetPlatformInfo( p, i, 0, NULL, &required ), "Failed to get OpenCL platform information" );
+    enforce_cl_retcode(clGetPlatformInfo(p, i, 0, NULL, &required), "Failed to get OpenCL platform information");
 
-    char *buff = (char*)alloca( required );
-    enforce_cl_retcode( clGetPlatformInfo( p, i, required, buff, NULL ), "Failed to get OpenCL platform information" );
+    char *buff = (char*)alloca(required);
+    enforce_cl_retcode(clGetPlatformInfo(p, i, required, buff, NULL), "Failed to get OpenCL platform information");
 
     return buff;
 }
 
 
-class opencl_device {
+class __TBB_DEPRECATED_IN_VERBOSE_MODE opencl_device {
 public:
     typedef size_t device_id_type;
     enum : device_id_type {
@@ -144,24 +124,26 @@ class opencl_device {
         host = device_id_type( -1 )
     };
 
-    opencl_device() : my_device_id( unknown ) {}
+    opencl_device() : my_device_id( unknown ), my_cl_device_id( NULL ), my_cl_command_queue( NULL ) {}
 
-    opencl_device( cl_device_id cl_d_id, device_id_type device_id ) : my_device_id( device_id ), my_cl_device_id( cl_d_id ) {}
+    opencl_device( cl_device_id d_id ) : my_device_id( unknown ), my_cl_device_id( d_id ), my_cl_command_queue( NULL ) {}
+
+    opencl_device( cl_device_id cl_d_id, device_id_type device_id ) : my_device_id( device_id ), my_cl_device_id( cl_d_id ), my_cl_command_queue( NULL ) {}
 
     std::string platform_profile() const {
-        return platform_info<std::string>( platform(), CL_PLATFORM_PROFILE );
+        return platform_info<std::string>( platform_id(), CL_PLATFORM_PROFILE );
     }
     std::string platform_version() const {
-        return platform_info<std::string>( platform(), CL_PLATFORM_VERSION );
+        return platform_info<std::string>( platform_id(), CL_PLATFORM_VERSION );
     }
     std::string platform_name() const {
-        return platform_info<std::string>( platform(), CL_PLATFORM_NAME );
+        return platform_info<std::string>( platform_id(), CL_PLATFORM_NAME );
     }
     std::string platform_vendor() const {
-        return platform_info<std::string>( platform(), CL_PLATFORM_VENDOR );
+        return platform_info<std::string>( platform_id(), CL_PLATFORM_VENDOR );
     }
     std::string platform_extensions() const {
-        return platform_info<std::string>( platform(), CL_PLATFORM_EXTENSIONS );
+        return platform_info<std::string>( platform_id(), CL_PLATFORM_EXTENSIONS );
     }
 
     template <typename T>
@@ -257,13 +239,12 @@ class opencl_device {
         my_cl_command_queue = cmd_queue;
     }
 
-private:
-    opencl_device( cl_device_id d_id ) : my_device_id( unknown ), my_cl_device_id( d_id ) {}
-
-    cl_platform_id platform() const {
+    cl_platform_id platform_id() const {
         return device_info<cl_platform_id>( my_cl_device_id, CL_DEVICE_PLATFORM );
     }
 
+private:
+
     device_id_type my_device_id;
     cl_device_id my_cl_device_id;
     cl_command_queue my_cl_command_queue;
@@ -276,7 +257,6 @@ class opencl_device {
     friend class opencl_memory;
     template <typename Factory>
     friend class opencl_program;
-    friend class opencl_foundation;
 
 #if TBB_USE_ASSERT
     template <typename T, typename Factory>
@@ -284,7 +264,7 @@ class opencl_device {
 #endif
 };
 
-class opencl_device_list {
+class __TBB_DEPRECATED_IN_VERBOSE_MODE opencl_device_list {
     typedef std::vector<opencl_device> container_type;
 public:
     typedef container_type::iterator iterator;
@@ -303,10 +283,66 @@ class opencl_device_list {
     const_iterator end() const { return my_container.end(); }
     const_iterator cbegin() const { return my_container.cbegin(); }
     const_iterator cend() const { return my_container.cend(); }
+
 private:
     container_type my_container;
 };
 
+namespace internal {
+
+// Retrieve all OpenCL devices from machine
+inline opencl_device_list find_available_devices() {
+    opencl_device_list opencl_devices;
+
+    cl_uint num_platforms;
+    enforce_cl_retcode(clGetPlatformIDs(0, NULL, &num_platforms), "clGetPlatformIDs failed");
+
+    std::vector<cl_platform_id> platforms(num_platforms);
+    enforce_cl_retcode(clGetPlatformIDs(num_platforms, platforms.data(), NULL), "clGetPlatformIDs failed");
+
+    cl_uint num_devices;
+    std::vector<cl_platform_id>::iterator platforms_it = platforms.begin();
+    cl_uint num_all_devices = 0;
+    while (platforms_it != platforms.end()) {
+        cl_int err = clGetDeviceIDs(*platforms_it, CL_DEVICE_TYPE_ALL, 0, NULL, &num_devices);
+        if (err == CL_DEVICE_NOT_FOUND) {
+            platforms_it = platforms.erase(platforms_it);
+        }
+        else {
+            enforce_cl_retcode(err, "clGetDeviceIDs failed");
+            num_all_devices += num_devices;
+            ++platforms_it;
+        }
+    }
+
+    std::vector<cl_device_id> devices(num_all_devices);
+    std::vector<cl_device_id>::iterator devices_it = devices.begin();
+    for (auto p = platforms.begin(); p != platforms.end(); ++p) {
+        enforce_cl_retcode(clGetDeviceIDs((*p), CL_DEVICE_TYPE_ALL, (cl_uint)std::distance(devices_it, devices.end()), &*devices_it, &num_devices), "clGetDeviceIDs failed");
+        devices_it += num_devices;
+    }
+
+    for (auto d = devices.begin(); d != devices.end(); ++d) {
+        opencl_devices.add(opencl_device((*d)));
+    }
+
+    return opencl_devices;
+}
+
+} // namespace internal
+
+// TODO: consider this namespace as public API
+namespace opencl_info {
+
+    inline const opencl_device_list& available_devices() {
+        // Static storage for all available OpenCL devices on machine
+        static const opencl_device_list my_devices = internal::find_available_devices();
+        return my_devices;
+    }
+
+} // namespace opencl_info
+
+
 class callback_base : tbb::internal::no_copy {
 public:
     virtual void call() = 0;
@@ -315,41 +351,30 @@ class callback_base : tbb::internal::no_copy {
 
 template <typename Callback, typename T>
 class callback : public callback_base {
-    graph &my_graph;
     Callback my_callback;
     T my_data;
 public:
-    callback( graph &g, Callback c, const T& t ) : my_graph( g ), my_callback( c ), my_data( t ) {
-        // Extend the graph lifetime until the callback completion.
-        my_graph.increment_wait_count();
-    }
-    ~callback() {
-        // Release the reference to the graph.
-        my_graph.decrement_wait_count();
-    }
+    callback( Callback c, const T& t ) : my_callback( c ), my_data( t ) {}
+
     void call() __TBB_override {
         my_callback( my_data );
     }
 };
 
-template <typename T, typename Factory = default_opencl_factory>
-class dependency_msg : public async_msg<T> {
+template <typename T, typename Factory = opencl_info::default_opencl_factory>
+class __TBB_DEPRECATED_IN_VERBOSE_MODE opencl_async_msg : public async_msg<T> {
 public:
     typedef T value_type;
 
-    dependency_msg() : my_callback_flag_ptr( std::make_shared< tbb::atomic<bool>>() ) {
+    opencl_async_msg() : my_callback_flag_ptr( std::make_shared< tbb::atomic<bool>>() ) {
         my_callback_flag_ptr->store<tbb::relaxed>(false);
     }
 
-    explicit dependency_msg( const T& data ) : my_data(data), my_callback_flag_ptr( std::make_shared<tbb::atomic<bool>>() ) {
+    explicit opencl_async_msg( const T& data ) : my_data(data), my_callback_flag_ptr( std::make_shared<tbb::atomic<bool>>() ) {
         my_callback_flag_ptr->store<tbb::relaxed>(false);
     }
 
-    dependency_msg( opencl_graph &g, const T& data ) : my_data(data), my_graph(&g), my_callback_flag_ptr( std::make_shared<tbb::atomic<bool>>() ) {
-        my_callback_flag_ptr->store<tbb::relaxed>(false);
-    }
-
-    dependency_msg( const T& data, cl_event event ) : my_data(data), my_event(event), my_is_event(true), my_callback_flag_ptr( std::make_shared<tbb::atomic<bool>>() ) {
+    opencl_async_msg( const T& data, cl_event event ) : my_data(data), my_event(event), my_is_event(true), my_callback_flag_ptr( std::make_shared<tbb::atomic<bool>>() ) {
         my_callback_flag_ptr->store<tbb::relaxed>(false);
         enforce_cl_retcode( clRetainEvent( my_event ), "Failed to retain an event" );
     }
@@ -372,22 +397,22 @@ class dependency_msg : public async_msg<T> {
         return my_data;
     }
 
-    dependency_msg( const dependency_msg &dmsg ) : async_msg<T>(dmsg),
-        my_data(dmsg.my_data), my_event(dmsg.my_event), my_is_event( dmsg.my_is_event ), my_graph( dmsg.my_graph ),
+    opencl_async_msg( const opencl_async_msg &dmsg ) : async_msg<T>(dmsg),
+        my_data(dmsg.my_data), my_event(dmsg.my_event), my_is_event( dmsg.my_is_event ),
         my_callback_flag_ptr(dmsg.my_callback_flag_ptr)
     {
         if ( my_is_event )
             enforce_cl_retcode( clRetainEvent( my_event ), "Failed to retain an event" );
     }
 
-    dependency_msg( dependency_msg &&dmsg ) : async_msg<T>(std::move(dmsg)),
-        my_data(std::move(dmsg.my_data)), my_event(dmsg.my_event), my_is_event(dmsg.my_is_event), my_graph(dmsg.my_graph),
+    opencl_async_msg( opencl_async_msg &&dmsg ) : async_msg<T>(std::move(dmsg)),
+        my_data(std::move(dmsg.my_data)), my_event(dmsg.my_event), my_is_event(dmsg.my_is_event),
         my_callback_flag_ptr( std::move(dmsg.my_callback_flag_ptr) )
     {
         dmsg.my_is_event = false;
     }
 
-    dependency_msg& operator=(const dependency_msg &dmsg) {
+    opencl_async_msg& operator=(const opencl_async_msg &dmsg) {
         async_msg<T>::operator =(dmsg);
 
         // Release original event
@@ -397,7 +422,6 @@ class dependency_msg : public async_msg<T> {
         my_data = dmsg.my_data;
         my_event = dmsg.my_event;
         my_is_event = dmsg.my_is_event;
-        my_graph = dmsg.my_graph;
 
         // Retain copied event
         if ( my_is_event )
@@ -407,7 +431,7 @@ class dependency_msg : public async_msg<T> {
         return *this;
     }
 
-    ~dependency_msg() {
+    ~opencl_async_msg() {
         if ( my_is_event )
             enforce_cl_retcode( clReleaseEvent( my_event ), "Failed to release an event" );
     }
@@ -425,10 +449,6 @@ class dependency_msg : public async_msg<T> {
         clRetainEvent( my_event );
     }
 
-    void set_graph( graph &g ) {
-        my_graph = &g;
-    }
-
     void clear_event() const {
         if ( my_is_event ) {
             enforce_cl_retcode( clFlush( event_info<cl_command_queue>( my_event, CL_EVENT_COMMAND_QUEUE ) ), "Failed to flush an OpenCL command queue" );
@@ -440,20 +460,19 @@ class dependency_msg : public async_msg<T> {
     template <typename Callback>
     void register_callback( Callback c ) const {
         __TBB_ASSERT( my_is_event, "The OpenCL event is not set" );
-        __TBB_ASSERT( my_graph, "The graph is not set" );
-        enforce_cl_retcode( clSetEventCallback( my_event, CL_COMPLETE, register_callback_func, new callback<Callback, T>( *my_graph, c, my_data ) ), "Failed to set an OpenCL callback" );
+        enforce_cl_retcode( clSetEventCallback( my_event, CL_COMPLETE, register_callback_func, new callback<Callback, T>( c, my_data ) ), "Failed to set an OpenCL callback" );
     }
 
     operator T&() { return data(); }
     operator const T&() const { return data(); }
 
 protected:
-    // Overridden in this derived class to inform that 
+    // Overridden in this derived class to inform that
     // async calculation chain is over
     void finalize() const __TBB_override {
         receive_if_memory_object(*this);
         if (! my_callback_flag_ptr->fetch_and_store(true)) {
-            dependency_msg a(*this);
+            opencl_async_msg a(*this);
             if (my_is_event) {
                 register_callback([a](const T& t) mutable {
                     a.set(t);
@@ -479,13 +498,12 @@ class dependency_msg : public async_msg<T> {
     T my_data;
     mutable cl_event my_event;
     mutable bool my_is_event = false;
-    graph *my_graph = NULL;
 
     std::shared_ptr< tbb::atomic<bool> > my_callback_flag_ptr;
 };
 
 template <typename K, typename T, typename Factory>
-K key_from_message( const dependency_msg<T, Factory> &dmsg ) {
+K key_from_message( const opencl_async_msg<T, Factory> &dmsg ) {
     using tbb::flow::key_from_message;
     const T &t = dmsg.data( false );
     __TBB_STATIC_ASSERT( true, "" );
@@ -500,7 +518,7 @@ class opencl_memory {
         my_curr_device_id = my_factory->devices().begin()->my_device_id;
     }
 
-    ~opencl_memory() {
+    virtual ~opencl_memory() {
         if ( my_sending_event_present ) enforce_cl_retcode( clReleaseEvent( my_sending_event ), "Failed to release an event for the OpenCL buffer" );
         enforce_cl_retcode( clReleaseMemObject( my_cl_mem ), "Failed to release an memory object" );
     }
@@ -511,7 +529,7 @@ class opencl_memory {
 
     void* get_host_ptr() {
         if ( !my_host_ptr ) {
-            dependency_msg<void*, Factory> d = receive( NULL );
+            opencl_async_msg<void*, Factory> d = receive( NULL );
             d.data();
             __TBB_ASSERT( d.data() == my_host_ptr, NULL );
         }
@@ -520,9 +538,55 @@ class opencl_memory {
 
     Factory *factory() const { return my_factory; }
 
-    dependency_msg<void*, Factory> send( opencl_device d, const cl_event *e );
-    dependency_msg<void*, Factory> receive( const cl_event *e );
-    virtual void map_memory( opencl_device, dependency_msg<void*, Factory> & ) = 0;
+    opencl_async_msg<void*, Factory> receive(const cl_event *e) {
+        opencl_async_msg<void*, Factory> d;
+        if (e) {
+            d = opencl_async_msg<void*, Factory>(my_host_ptr, *e);
+        } else {
+            d = opencl_async_msg<void*, Factory>(my_host_ptr);
+        }
+
+        // Concurrent receives are prohibited so we do not worry about synchronization.
+        if (my_curr_device_id.load<tbb::relaxed>() != opencl_device::host) {
+            map_memory(*my_factory->devices().begin(), d);
+            my_curr_device_id.store<tbb::relaxed>(opencl_device::host);
+            my_host_ptr = d.data(false);
+        }
+        // Release the sending event
+        if (my_sending_event_present) {
+            enforce_cl_retcode(clReleaseEvent(my_sending_event), "Failed to release an event");
+            my_sending_event_present = false;
+        }
+        return d;
+    }
+
+    opencl_async_msg<void*, Factory> send(opencl_device device, const cl_event *e) {
+        opencl_device::device_id_type device_id = device.my_device_id;
+        if (!my_factory->is_same_context(my_curr_device_id.load<tbb::acquire>(), device_id)) {
+            {
+                tbb::spin_mutex::scoped_lock lock(my_sending_lock);
+                if (!my_factory->is_same_context(my_curr_device_id.load<tbb::relaxed>(), device_id)) {
+                    __TBB_ASSERT(my_host_ptr, "The buffer has not been mapped");
+                    opencl_async_msg<void*, Factory> d(my_host_ptr);
+                    my_factory->enqueue_unmap_buffer(device, *this, d);
+                    my_sending_event = *d.get_event();
+                    my_sending_event_present = true;
+                    enforce_cl_retcode(clRetainEvent(my_sending_event), "Failed to retain an event");
+                    my_host_ptr = NULL;
+                    my_curr_device_id.store<tbb::release>(device_id);
+                }
+            }
+            __TBB_ASSERT(my_sending_event_present, NULL);
+        }
+
+        // !e means that buffer has come from the host
+        if (!e && my_sending_event_present) e = &my_sending_event;
+
+        __TBB_ASSERT(!my_host_ptr, "The buffer has not been unmapped");
+        return e ? opencl_async_msg<void*, Factory>(NULL, *e) : opencl_async_msg<void*, Factory>(NULL);
+    }
+
+    virtual void map_memory( opencl_device, opencl_async_msg<void*, Factory> & ) = 0;
 protected:
     cl_mem my_cl_mem;
     tbb::atomic<opencl_device::device_id_type> my_curr_device_id;
@@ -556,8 +620,8 @@ class opencl_buffer_impl : public opencl_memory<Factory> {
         return my_size;
     }
 
-    void map_memory( opencl_device device, dependency_msg<void*, Factory> &dmsg ) __TBB_override {
-        this->my_factory->enque_map_buffer( device, *this, dmsg );
+    void map_memory( opencl_device device, opencl_async_msg<void*, Factory> &dmsg ) __TBB_override {
+        this->my_factory->enqueue_map_buffer( device, *this, dmsg );
     }
 
 #if TBB_USE_ASSERT
@@ -572,11 +636,13 @@ enum access_type {
     read_only
 };
 
-template <typename T, typename Factory = default_opencl_factory>
-class opencl_subbuffer;
+template <typename T, typename Factory = opencl_info::default_opencl_factory>
+class __TBB_DEPRECATED_IN_VERBOSE_MODE
+opencl_subbuffer;
 
-template <typename T, typename Factory = default_opencl_factory>
-class opencl_buffer {
+template <typename T, typename Factory = opencl_info::default_opencl_factory>
+class __TBB_DEPRECATED_IN_VERBOSE_MODE
+opencl_buffer {
 public:
     typedef cl_mem native_object_type;
     typedef opencl_buffer memory_object_type;
@@ -604,7 +670,7 @@ class opencl_buffer {
     T& operator[] ( ptrdiff_t k ) { return begin()[k]; }
 
     opencl_buffer() {}
-    opencl_buffer( opencl_graph &g, size_t size );
+    opencl_buffer( size_t size );
     opencl_buffer( Factory &f, size_t size ) : my_impl( std::make_shared<impl_type>( size*sizeof(T), f ) ) {}
 
     cl_mem native_object() const {
@@ -615,16 +681,16 @@ class opencl_buffer {
         return *this;
     }
 
-    void send( opencl_device device, dependency_msg<opencl_buffer, Factory> &dependency ) const {
+    void send( opencl_device device, opencl_async_msg<opencl_buffer, Factory> &dependency ) const {
         __TBB_ASSERT( dependency.data( /*wait = */false ) == *this, NULL );
-        dependency_msg<void*, Factory> d = my_impl->send( device, dependency.get_event() );
+        opencl_async_msg<void*, Factory> d = my_impl->send( device, dependency.get_event() );
         const cl_event *e = d.get_event();
         if ( e ) dependency.set_event( *e );
         else dependency.clear_event();
     }
-    void receive( const dependency_msg<opencl_buffer, Factory> &dependency ) const {
+    void receive( const opencl_async_msg<opencl_buffer, Factory> &dependency ) const {
         __TBB_ASSERT( dependency.data( /*wait = */false ) == *this, NULL );
-        dependency_msg<void*, Factory> d = my_impl->receive( dependency.get_event() );
+        opencl_async_msg<void*, Factory> d = my_impl->receive( dependency.get_event() );
         const cl_event *e = d.get_event();
         if ( e ) dependency.set_event( *e );
         else dependency.clear_event();
@@ -650,7 +716,8 @@ class opencl_buffer {
 };
 
 template <typename T, typename Factory>
-class opencl_subbuffer : public opencl_buffer<T, Factory> {
+class __TBB_DEPRECATED_IN_VERBOSE_MODE
+opencl_subbuffer : public opencl_buffer<T, Factory> {
     opencl_buffer<T, Factory> my_owner;
 public:
     opencl_subbuffer() {}
@@ -690,11 +757,11 @@ typename std::enable_if<!is_native_object_type<T>::value, T>::type get_native_ob
 
 // send_if_memory_object checks if the T type has memory_object_type and call the send method for the object.
 template <typename T, typename Factory>
-typename std::enable_if<is_memory_object_type<T>::value>::type send_if_memory_object( opencl_device device, dependency_msg<T, Factory> &dmsg ) {
+typename std::enable_if<is_memory_object_type<T>::value>::type send_if_memory_object( opencl_device device, opencl_async_msg<T, Factory> &dmsg ) {
     const T &t = dmsg.data( false );
     typedef typename T::memory_object_type mem_obj_t;
     mem_obj_t mem_obj = t.memory_object();
-    dependency_msg<mem_obj_t, Factory> d( mem_obj );
+    opencl_async_msg<mem_obj_t, Factory> d( mem_obj );
     if ( dmsg.get_event() ) d.set_event( *dmsg.get_event() );
     mem_obj.send( device, d );
     if ( d.get_event() ) dmsg.set_event( *d.get_event() );
@@ -704,7 +771,7 @@ template <typename T>
 typename std::enable_if<is_memory_object_type<T>::value>::type send_if_memory_object( opencl_device device, T &t ) {
     typedef typename T::memory_object_type mem_obj_t;
     mem_obj_t mem_obj = t.memory_object();
-    dependency_msg<mem_obj_t, typename mem_obj_t::opencl_factory_type> dmsg( mem_obj );
+    opencl_async_msg<mem_obj_t, typename mem_obj_t::opencl_factory_type> dmsg( mem_obj );
     mem_obj.send( device, dmsg );
 }
 
@@ -713,11 +780,11 @@ typename std::enable_if<!is_memory_object_type<T>::value>::type send_if_memory_o
 
 // receive_if_memory_object checks if the T type has memory_object_type and call the receive method for the object.
 template <typename T, typename Factory>
-typename std::enable_if<is_memory_object_type<T>::value>::type receive_if_memory_object( const dependency_msg<T, Factory> &dmsg ) {
+typename std::enable_if<is_memory_object_type<T>::value>::type receive_if_memory_object( const opencl_async_msg<T, Factory> &dmsg ) {
     const T &t = dmsg.data( false );
     typedef typename T::memory_object_type mem_obj_t;
     mem_obj_t mem_obj = t.memory_object();
-    dependency_msg<mem_obj_t, Factory> d( mem_obj );
+    opencl_async_msg<mem_obj_t, Factory> d( mem_obj );
     if ( dmsg.get_event() ) d.set_event( *dmsg.get_event() );
     mem_obj.receive( d );
     if ( d.get_event() ) dmsg.set_event( *d.get_event() );
@@ -726,7 +793,7 @@ typename std::enable_if<is_memory_object_type<T>::value>::type receive_if_memory
 template <typename T>
 typename std::enable_if<!is_memory_object_type<T>::value>::type  receive_if_memory_object( const T& ) {}
 
-class opencl_range {
+class __TBB_DEPRECATED_IN_VERBOSE_MODE opencl_range {
 public:
     typedef size_t range_index_type;
     typedef std::array<range_index_type, 3> nd_range_type;
@@ -736,7 +803,7 @@ class opencl_range {
     opencl_range(G&& global_work = std::initializer_list<int>({ 0 }), L&& local_work = std::initializer_list<int>({ 0, 0, 0 })) {
         auto g_it = global_work.begin();
         auto l_it = local_work.begin();
-        my_global_work_size = { size_t(-1), size_t(-1), size_t(-1) };
+        my_global_work_size = { {size_t(-1), size_t(-1), size_t(-1)} };
         // my_local_work_size is still uninitialized
         for (int s = 0; s < 3 && g_it != global_work.end(); ++g_it, ++l_it, ++s) {
             __TBB_ASSERT(l_it != local_work.end(), "global_work & local_work must have same size");
@@ -754,9 +821,9 @@ class opencl_range {
 };
 
 template <typename DeviceFilter>
-class opencl_factory {
+class __TBB_DEPRECATED_IN_VERBOSE_MODE opencl_factory {
 public:
-    template<typename T> using async_msg_type = dependency_msg<T, opencl_factory<DeviceFilter>>;
+    template<typename T> using async_msg_type = opencl_async_msg<T, opencl_factory<DeviceFilter>>;
     typedef opencl_device device_type;
 
     class kernel : tbb::internal::no_assign {
@@ -805,7 +872,7 @@ class opencl_factory {
     // it affects expectations for enqueue_kernel(.....) interface method
     typedef opencl_range range_type;
 
-    opencl_factory( opencl_graph &g ) : my_graph( g ) {}
+    opencl_factory() {}
     ~opencl_factory() {
         if ( my_devices.size() ) {
             for ( auto d = my_devices.begin(); d != my_devices.end(); ++d ) {
@@ -827,7 +894,7 @@ class opencl_factory {
 
 private:
     template <typename Factory>
-    void enque_map_buffer( opencl_device device, opencl_buffer_impl<Factory> &buffer, dependency_msg<void*, Factory>& dmsg ) {
+    void enqueue_map_buffer( opencl_device device, opencl_buffer_impl<Factory> &buffer, opencl_async_msg<void*, Factory>& dmsg ) {
         cl_event const* e1 = dmsg.get_event();
         cl_event e2;
         cl_int err;
@@ -841,7 +908,7 @@ class opencl_factory {
 
 
     template <typename Factory>
-    void enque_unmap_buffer( opencl_device device, opencl_memory<Factory> &memory, dependency_msg<void*, Factory>& dmsg ) {
+    void enqueue_unmap_buffer( opencl_device device, opencl_memory<Factory> &memory, opencl_async_msg<void*, Factory>& dmsg ) {
         cl_event const* e1 = dmsg.get_event();
         cl_event e2;
         enforce_cl_retcode(
@@ -859,7 +926,7 @@ class opencl_factory {
     }
 
     template <size_t NUM_ARGS, typename T, typename F>
-    void process_one_arg( const kernel_type& kernel, std::array<cl_event, NUM_ARGS>& events, int& num_events, int& place, const dependency_msg<T, F>& msg ) {
+    void process_one_arg( const kernel_type& kernel, std::array<cl_event, NUM_ARGS>& events, int& num_events, int& place, const opencl_async_msg<T, F>& msg ) {
         __TBB_ASSERT((static_cast<typename std::array<cl_event, NUM_ARGS>::size_type>(num_events) < events.size()), NULL);
 
         const cl_event * const e = msg.get_event();
@@ -883,9 +950,8 @@ class opencl_factory {
     void update_one_arg( cl_event, T& ) {}
 
     template <typename T, typename F>
-    void update_one_arg( cl_event e, dependency_msg<T, F>& msg ) {
+    void update_one_arg( cl_event e, opencl_async_msg<T, F>& msg ) {
         msg.set_event( e );
-        msg.set_graph( my_graph );
     }
 
     template <typename T, typename ...Rest>
@@ -945,7 +1011,7 @@ class opencl_factory {
     }
 
     template <typename T, typename F>
-    bool get_event_from_one_arg( cl_event& e, const dependency_msg<T, F>& msg) {
+    bool get_event_from_one_arg( cl_event& e, const opencl_async_msg<T, F>& msg) {
         cl_event const *e_ptr = msg.get_event();
 
         if ( e_ptr != NULL ) {
@@ -1028,12 +1094,79 @@ class opencl_factory {
         return my_cl_context;
     }
 
-    void init_once();
+    void init_once() {
+        {
+            tbb::spin_mutex::scoped_lock lock(my_devices_mutex);
+            if (!my_devices.size())
+                my_devices = DeviceFilter()( opencl_info::available_devices() );
+        }
+
+        enforce_cl_retcode(my_devices.size() ? CL_SUCCESS : CL_INVALID_DEVICE, "No devices in the device list");
+        cl_platform_id platform_id = my_devices.begin()->platform_id();
+        for (opencl_device_list::iterator it = ++my_devices.begin(); it != my_devices.end(); ++it)
+            enforce_cl_retcode(it->platform_id() == platform_id ? CL_SUCCESS : CL_INVALID_PLATFORM, "All devices should be in the same platform");
+
+        std::vector<cl_device_id> cl_device_ids;
+        for (auto d = my_devices.begin(); d != my_devices.end(); ++d) {
+            cl_device_ids.push_back((*d).my_cl_device_id);
+        }
+
+        cl_context_properties context_properties[3] = { CL_CONTEXT_PLATFORM, (cl_context_properties)platform_id, (cl_context_properties)NULL };
+        cl_int err;
+        cl_context ctx = clCreateContext(context_properties,
+            (cl_uint)cl_device_ids.size(),
+            cl_device_ids.data(),
+            NULL, NULL, &err);
+        enforce_cl_retcode(err, "Failed to create context");
+        my_cl_context = ctx;
+
+        size_t device_counter = 0;
+        for (auto d = my_devices.begin(); d != my_devices.end(); d++) {
+            (*d).my_device_id = device_counter++;
+            cl_int err2;
+            cl_command_queue cq;
+#if CL_VERSION_2_0
+            if ((*d).major_version() >= 2) {
+                if ((*d).out_of_order_exec_mode_on_host_present()) {
+                    cl_queue_properties props[] = { CL_QUEUE_PROPERTIES, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE, 0 };
+                    cq = clCreateCommandQueueWithProperties(ctx, (*d).my_cl_device_id, props, &err2);
+                } else {
+                    cl_queue_properties props[] = { 0 };
+                    cq = clCreateCommandQueueWithProperties(ctx, (*d).my_cl_device_id, props, &err2);
+                }
+            } else
+#endif
+            {
+                cl_command_queue_properties props = (*d).out_of_order_exec_mode_on_host_present() ? CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE : 0;
+                // Suppress "declared deprecated" warning for the next line.
+#if __TBB_GCC_WARNING_SUPPRESSION_PRESENT
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
+#if _MSC_VER || __INTEL_COMPILER
+#pragma warning( push )
+#if __INTEL_COMPILER
+#pragma warning (disable: 1478)
+#else
+#pragma warning (disable: 4996)
+#endif
+#endif
+                cq = clCreateCommandQueue(ctx, (*d).my_cl_device_id, props, &err2);
+#if _MSC_VER || __INTEL_COMPILER
+#pragma warning( pop )
+#endif
+#if __TBB_GCC_WARNING_SUPPRESSION_PRESENT
+#pragma GCC diagnostic pop
+#endif
+            }
+            enforce_cl_retcode(err2, "Failed to create command queue");
+            (*d).my_cl_command_queue = cq;
+        }
+    }
 
     std::once_flag my_once_flag;
     opencl_device_list my_devices;
     cl_context my_cl_context;
-    opencl_graph &my_graph;
 
     tbb::spin_mutex my_devices_mutex;
 
@@ -1043,239 +1176,63 @@ class opencl_factory {
     friend class opencl_buffer_impl;
     template <typename Factory>
     friend class opencl_memory;
-};
+}; // class opencl_factory
 
-template <typename Factory>
-dependency_msg<void*, Factory> opencl_memory<Factory>::receive( const cl_event *e ) {
-    dependency_msg<void*, Factory> d = e ? dependency_msg<void*, Factory>( my_host_ptr, *e ) : dependency_msg<void*, Factory>( my_host_ptr );
-    // Concurrent receives are prohibited so we do not worry about synchronization.
-    if ( my_curr_device_id.load<tbb::relaxed>() != opencl_device::host ) {
-        map_memory( *my_factory->devices().begin(), d );
-        my_curr_device_id.store<tbb::relaxed>( opencl_device::host );
-        my_host_ptr = d.data( false );
-    }
-    // Release the sending event
-    if ( my_sending_event_present ) {
-        enforce_cl_retcode( clReleaseEvent( my_sending_event ), "Failed to release an event" );
-        my_sending_event_present = false;
-    }
-    return d;
-}
+// TODO: consider this namespace as public API
+namespace opencl_info {
+
+// Default types
 
 template <typename Factory>
-dependency_msg<void*, Factory> opencl_memory<Factory>::send( opencl_device device, const cl_event *e ) {
-    opencl_device::device_id_type device_id = device.my_device_id;
-    if ( !my_factory->is_same_context( my_curr_device_id.load<tbb::acquire>(), device_id ) ) {
-        {
-            tbb::spin_mutex::scoped_lock lock( my_sending_lock );
-            if ( !my_factory->is_same_context( my_curr_device_id.load<tbb::relaxed>(), device_id ) ) {
-                __TBB_ASSERT( my_host_ptr, "The buffer has not been mapped" );
-                dependency_msg<void*, Factory> d( my_host_ptr );
-                my_factory->enque_unmap_buffer( device, *this, d );
-                my_sending_event = *d.get_event();
-                my_sending_event_present = true;
-                enforce_cl_retcode( clRetainEvent( my_sending_event ), "Failed to retain an event" );
-                my_host_ptr = NULL;
-                my_curr_device_id.store<tbb::release>(device_id);
-            }
-        }
-        __TBB_ASSERT( my_sending_event_present, NULL );
+struct default_device_selector {
+    opencl_device operator()(Factory& f) {
+        __TBB_ASSERT(!f.devices().empty(), "No available devices");
+        return *(f.devices().begin());
     }
+};
 
-    // !e means that buffer has come from the host
-    if ( !e && my_sending_event_present ) e = &my_sending_event;
-
-    __TBB_ASSERT( !my_host_ptr, "The buffer has not been unmapped" );
-    return e ? dependency_msg<void*, Factory>( NULL, *e ) : dependency_msg<void*, Factory>( NULL );
-}
-
-struct default_opencl_factory_device_filter {
-    opencl_device_list operator()( const opencl_device_list &devices ) {
+struct default_device_filter {
+    opencl_device_list operator()(const opencl_device_list &devices) {
         opencl_device_list dl;
-        dl.add( *devices.begin() );
+        cl_platform_id platform_id = devices.begin()->platform_id();
+        for (opencl_device_list::const_iterator it = devices.cbegin(); it != devices.cend(); ++it) {
+            if (it->platform_id() == platform_id) {
+                dl.add(*it);
+            }
+        }
         return dl;
     }
 };
 
-class default_opencl_factory : public opencl_factory < default_opencl_factory_device_filter > {
+class default_opencl_factory : public opencl_factory < default_device_filter >, tbb::internal::no_copy {
 public:
-    template<typename T> using async_msg_type = dependency_msg<T, default_opencl_factory>;
-    
-    default_opencl_factory( opencl_graph &g ) : opencl_factory( g ) {}
-private:
-    default_opencl_factory( const default_opencl_factory& );
-    default_opencl_factory& operator=(const default_opencl_factory&);
-};
+    template<typename T> using async_msg_type = opencl_async_msg<T, default_opencl_factory>;
 
-class opencl_foundation : tbb::internal::no_assign {
-    struct default_device_selector_type {
-        opencl_device operator()( default_opencl_factory& f ) {
-            __TBB_ASSERT( ! f.devices().empty(), "No available devices" );
-            return *( f.devices().begin() );
-        }
-    };
-public:
-    opencl_foundation(opencl_graph &g) : my_default_opencl_factory(g), my_default_device_selector() {
-        cl_uint num_platforms;
-        enforce_cl_retcode(clGetPlatformIDs(0, NULL, &num_platforms), "clGetPlatformIDs failed");
-
-        std::vector<cl_platform_id> platforms(num_platforms);
-        enforce_cl_retcode(clGetPlatformIDs(num_platforms, platforms.data(), NULL), "clGetPlatformIDs failed");
-
-        cl_uint num_devices;
-        std::vector<cl_platform_id>::iterator platforms_it = platforms.begin();
-        cl_uint num_all_devices = 0;
-        while (platforms_it != platforms.end()) {
-            cl_int err = clGetDeviceIDs(*platforms_it, CL_DEVICE_TYPE_ALL, 0, NULL, &num_devices);
-            if (err == CL_DEVICE_NOT_FOUND) {
-                platforms_it = platforms.erase(platforms_it);
-            } else {
-                enforce_cl_retcode(err, "clGetDeviceIDs failed");
-                num_all_devices += num_devices;
-                ++platforms_it;
-            }
-        }
-
-        std::vector<cl_device_id> devices(num_all_devices);
-        std::vector<cl_device_id>::iterator devices_it = devices.begin();
-        for (auto p = platforms.begin(); p != platforms.end(); ++p) {
-            enforce_cl_retcode(clGetDeviceIDs((*p), CL_DEVICE_TYPE_ALL, (cl_uint)std::distance(devices_it, devices.end()), &*devices_it, &num_devices), "clGetDeviceIDs failed");
-            devices_it += num_devices;
-        }
-
-        for (auto d = devices.begin(); d != devices.end(); ++d) {
-            my_devices.add(opencl_device((*d)));
-        }
-    }
-
-    default_opencl_factory &get_default_opencl_factory() {
-        return my_default_opencl_factory;
-    }
-
-    const opencl_device_list &get_all_devices() {
-        return my_devices;
-    }
-
-    default_device_selector_type get_default_device_selector() { return my_default_device_selector; }
+    friend default_opencl_factory& default_factory();
 
 private:
-    default_opencl_factory my_default_opencl_factory;
-    opencl_device_list my_devices;
-
-    const default_device_selector_type my_default_device_selector;
+    default_opencl_factory() = default;
 };
 
-opencl_foundation &opencl_graph::get_opencl_foundation() {
-    opencl_foundation* INITIALIZATION = (opencl_foundation*)1;
-    if ( my_opencl_foundation <= INITIALIZATION ) {
-        if ( tbb::internal::as_atomic( my_opencl_foundation ).compare_and_swap( INITIALIZATION, NULL ) == 0 ) {
-            my_opencl_foundation = new opencl_foundation( *this );
-        }
-        else {
-            tbb::internal::spin_wait_while_eq( my_opencl_foundation, INITIALIZATION );
-        }
-    }
-
-    __TBB_ASSERT( my_opencl_foundation > INITIALIZATION, "opencl_foundation is not initialized");
-    return *my_opencl_foundation;
-}
-
-opencl_graph::~opencl_graph() {
-    if ( my_opencl_foundation )
-        delete my_opencl_foundation;
-}
-
-template <typename DeviceFilter>
-void opencl_factory<DeviceFilter>::init_once() {
-        {
-            tbb::spin_mutex::scoped_lock lock( my_devices_mutex );
-            if ( !my_devices.size() )
-                my_devices = DeviceFilter()(my_graph.get_opencl_foundation().get_all_devices());
-        }
-
-    enforce_cl_retcode( my_devices.size() ? CL_SUCCESS : CL_INVALID_DEVICE, "No devices in the device list" );
-    cl_platform_id platform_id = my_devices.begin()->platform();
-    for ( opencl_device_list::iterator it = ++my_devices.begin(); it != my_devices.end(); ++it )
-        enforce_cl_retcode( it->platform() == platform_id ? CL_SUCCESS : CL_INVALID_PLATFORM, "All devices should be in the same platform" );
-
-    std::vector<cl_device_id> cl_device_ids;
-    for (auto d = my_devices.begin(); d != my_devices.end(); ++d) {
-        cl_device_ids.push_back((*d).my_cl_device_id);
-    }
-
-    cl_context_properties context_properties[3] = { CL_CONTEXT_PLATFORM, (cl_context_properties)platform_id, (cl_context_properties)NULL };
-    cl_int err;
-    cl_context ctx = clCreateContext( context_properties,
-        (cl_uint)cl_device_ids.size(),
-        cl_device_ids.data(),
-        NULL, NULL, &err );
-    enforce_cl_retcode( err, "Failed to create context" );
-    my_cl_context = ctx;
-
-    size_t device_counter = 0;
-    for ( auto d = my_devices.begin(); d != my_devices.end(); d++ ) {
-        (*d).my_device_id = device_counter++;
-        cl_int err2;
-        cl_command_queue cq;
-#if CL_VERSION_2_0
-        if ( (*d).major_version() >= 2 ) {
-            if ( (*d).out_of_order_exec_mode_on_host_present() ) {
-                cl_queue_properties props[] = { CL_QUEUE_PROPERTIES, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE, 0 };
-                cq = clCreateCommandQueueWithProperties( ctx, (*d).my_cl_device_id, props, &err2 );
-            } else {
-                cl_queue_properties props[] = { 0 };
-                cq = clCreateCommandQueueWithProperties( ctx, (*d).my_cl_device_id, props, &err2 );
-            }
-        } else
-#endif
-        {
-            cl_command_queue_properties props = (*d).out_of_order_exec_mode_on_host_present() ? CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE : 0;
-            // Suppress "declared deprecated" warning for the next line.
-#if __TBB_GCC_WARNING_SUPPRESSION_PRESENT
-#pragma GCC diagnostic push
-// #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-#endif
-#if _MSC_VER || __INTEL_COMPILER
-#pragma warning( push )
-#if __INTEL_COMPILER
-#pragma warning (disable: 1478)
-#else
-#pragma warning (disable: 4996)
-#endif
-#endif
-            cq = clCreateCommandQueue( ctx, (*d).my_cl_device_id, props, &err2 );
-#if _MSC_VER || __INTEL_COMPILER
-#pragma warning( pop )
-#endif
-#if __TBB_GCC_WARNING_SUPPRESSION_PRESENT
-#pragma GCC diagnostic pop
-#endif
-        }
-        enforce_cl_retcode( err2, "Failed to create command queue" );
-        (*d).my_cl_command_queue = cq;
-    }
+inline default_opencl_factory& default_factory() {
+    static default_opencl_factory default_factory;
+    return default_factory;
 }
 
-const opencl_device_list &opencl_graph::available_devices() {
-    return get_opencl_foundation().get_all_devices();
-}
-
-default_opencl_factory &opencl_graph::opencl_factory() {
-    return get_opencl_foundation().get_default_opencl_factory();
-}
+} // namespace opencl_info
 
 template <typename T, typename Factory>
-opencl_buffer<T, Factory>::opencl_buffer( opencl_graph &g, size_t size ) : my_impl( std::make_shared<impl_type>( size*sizeof(T), g.get_opencl_foundation().get_default_opencl_factory() ) ) {}
+opencl_buffer<T, Factory>::opencl_buffer( size_t size ) : my_impl( std::make_shared<impl_type>( size*sizeof(T), opencl_info::default_factory() ) ) {}
+
 
-    
 enum class opencl_program_type {
     SOURCE,
     PRECOMPILED,
     SPIR
 };
 
-template <typename Factory = default_opencl_factory>
-class opencl_program : tbb::internal::no_assign {
+template <typename Factory = opencl_info::default_opencl_factory>
+class __TBB_DEPRECATED_IN_VERBOSE_MODE opencl_program : tbb::internal::no_assign {
 public:
     typedef typename Factory::kernel_type kernel_type;
 
@@ -1283,10 +1240,10 @@ class opencl_program : tbb::internal::no_assign {
     opencl_program( Factory& factory, const char* program_name ) : opencl_program( factory, std::string( program_name ) ) {}
     opencl_program( Factory& factory, const std::string& program_name ) : opencl_program( factory, opencl_program_type::SOURCE, program_name ) {}
 
-    opencl_program( opencl_graph& graph, opencl_program_type type, const std::string& program_name ) : opencl_program( graph.opencl_factory(), type, program_name ) {}
-    opencl_program( opencl_graph& graph, const char* program_name ) : opencl_program( graph.opencl_factory(), program_name ) {}
-    opencl_program( opencl_graph& graph, const std::string& program_name ) : opencl_program( graph.opencl_factory(), program_name ) {}
-    opencl_program( opencl_graph& graph, opencl_program_type type ) : opencl_program( graph.opencl_factory(), type ) {}
+    opencl_program( opencl_program_type type, const std::string& program_name ) : opencl_program( opencl_info::default_factory(), type, program_name ) {}
+    opencl_program( const char* program_name ) : opencl_program( opencl_info::default_factory(), program_name ) {}
+    opencl_program( const std::string& program_name ) : opencl_program( opencl_info::default_factory(), program_name ) {}
+    opencl_program( opencl_program_type type ) : opencl_program( opencl_info::default_factory(), type ) {}
 
     opencl_program( const opencl_program &src ) : my_factory( src.my_factory ), my_type( src.type ), my_arg_str( src.my_arg_str ), my_cl_program( src.my_cl_program ) {
         // Set my_do_once_flag to the called state.
@@ -1454,84 +1411,94 @@ class opencl_program : tbb::internal::no_assign {
     template <typename DeviceFilter>
     friend class opencl_factory;
 
-    template <typename DeviceFilter>
-    friend class opencl_factory<DeviceFilter>::kernel;
+    friend class Factory::kernel;
 };
 
 template<typename... Args>
-class opencl_node;
+class __TBB_DEPRECATED_IN_VERBOSE_MODE opencl_node;
 
 template<typename JP, typename Factory, typename... Ports>
-class opencl_node< tuple<Ports...>, JP, Factory > : public streaming_node< tuple<Ports...>, JP, Factory > {
+class __TBB_DEPRECATED_IN_VERBOSE_MODE
+opencl_node< tuple<Ports...>, JP, Factory > : public streaming_node< tuple<Ports...>, JP, Factory > {
     typedef streaming_node < tuple<Ports...>, JP, Factory > base_type;
 public:
     typedef typename base_type::kernel_type kernel_type;
 
-    opencl_node( opencl_graph &g, const kernel_type& kernel )
-        : base_type( g, kernel, g.get_opencl_foundation().get_default_device_selector(), g.get_opencl_foundation().get_default_opencl_factory() )
-    {}
+    opencl_node( graph &g, const kernel_type& kernel )
+        : base_type( g, kernel, opencl_info::default_device_selector< opencl_info::default_opencl_factory >(), opencl_info::default_factory() )
+    {
+        tbb::internal::fgt_multiinput_multioutput_node( CODEPTR(), tbb::internal::FLOW_OPENCL_NODE, this, &this->my_graph );
+    }
 
-    opencl_node( opencl_graph &g, const kernel_type& kernel, Factory &f )
-        : base_type( g, kernel, g.get_opencl_foundation().get_default_device_selector(), f )
-    {}
+    opencl_node( graph &g, const kernel_type& kernel, Factory &f )
+        : base_type( g, kernel, opencl_info::default_device_selector <Factory >(), f )
+    {
+        tbb::internal::fgt_multiinput_multioutput_node( CODEPTR(), tbb::internal::FLOW_OPENCL_NODE, this, &this->my_graph );
+    }
 
     template <typename DeviceSelector>
-    opencl_node( opencl_graph &g, const kernel_type& kernel, DeviceSelector d, Factory &f)
+    opencl_node( graph &g, const kernel_type& kernel, DeviceSelector d, Factory &f)
         : base_type( g, kernel, d, f)
-    {}
+    {
+        tbb::internal::fgt_multiinput_multioutput_node( CODEPTR(), tbb::internal::FLOW_OPENCL_NODE, this, &this->my_graph );
+    }
 };
 
 template<typename JP, typename... Ports>
-class opencl_node< tuple<Ports...>, JP > : public opencl_node < tuple<Ports...>, JP, default_opencl_factory > {
-    typedef opencl_node < tuple<Ports...>, JP, default_opencl_factory > base_type;
+class __TBB_DEPRECATED_IN_VERBOSE_MODE
+opencl_node< tuple<Ports...>, JP > : public opencl_node < tuple<Ports...>, JP, opencl_info::default_opencl_factory > {
+    typedef opencl_node < tuple<Ports...>, JP, opencl_info::default_opencl_factory > base_type;
 public:
     typedef typename base_type::kernel_type kernel_type;
 
-    opencl_node( opencl_graph &g, const kernel_type& kernel )
-        : base_type( g, kernel, g.get_opencl_foundation().get_default_device_selector(), g.get_opencl_foundation().get_default_opencl_factory() )
+    opencl_node( graph &g, const kernel_type& kernel )
+        : base_type( g, kernel, opencl_info::default_device_selector< opencl_info::default_opencl_factory >(), opencl_info::default_factory() )
     {}
 
     template <typename DeviceSelector>
-    opencl_node( opencl_graph &g, const kernel_type& kernel, DeviceSelector d )
-        : base_type( g, kernel, d, g.get_opencl_foundation().get_default_opencl_factory() )
+    opencl_node( graph &g, const kernel_type& kernel, DeviceSelector d )
+        : base_type( g, kernel, d, opencl_info::default_factory() )
     {}
 };
 
 template<typename... Ports>
-class opencl_node< tuple<Ports...> > : public opencl_node < tuple<Ports...>, queueing, default_opencl_factory > {
-    typedef opencl_node < tuple<Ports...>, queueing, default_opencl_factory > base_type;
+class __TBB_DEPRECATED_IN_VERBOSE_MODE
+opencl_node< tuple<Ports...> > : public opencl_node < tuple<Ports...>, queueing, opencl_info::default_opencl_factory > {
+    typedef opencl_node < tuple<Ports...>, queueing, opencl_info::default_opencl_factory > base_type;
 public:
     typedef typename base_type::kernel_type kernel_type;
 
-    opencl_node( opencl_graph &g, const kernel_type& kernel )
-        : base_type( g, kernel, g.get_opencl_foundation().get_default_device_selector(), g.get_opencl_foundation().get_default_opencl_factory() )
+    opencl_node( graph &g, const kernel_type& kernel )
+        : base_type( g, kernel, opencl_info::default_device_selector< opencl_info::default_opencl_factory >(), opencl_info::default_factory() )
     {}
 
     template <typename DeviceSelector>
-    opencl_node( opencl_graph &g, const kernel_type& kernel, DeviceSelector d )
-        : base_type( g, kernel, d, g.get_opencl_foundation().get_default_opencl_factory() )
+    opencl_node( graph &g, const kernel_type& kernel, DeviceSelector d )
+        : base_type( g, kernel, d, opencl_info::default_factory() )
     {}
 };
 
-} // namespace interface9
-
-using interface9::opencl_graph;
-using interface9::opencl_node;
-using interface9::read_only;
-using interface9::read_write;
-using interface9::write_only;
-using interface9::opencl_buffer;
-using interface9::opencl_subbuffer;
-using interface9::opencl_device;
-using interface9::opencl_device_list;
-using interface9::opencl_program;
-using interface9::opencl_program_type;
-using interface9::dependency_msg;
-using interface9::opencl_factory;
-using interface9::opencl_range;
+} // namespace interfaceX
+
+using interface11::opencl_node;
+using interface11::read_only;
+using interface11::read_write;
+using interface11::write_only;
+using interface11::opencl_buffer;
+using interface11::opencl_subbuffer;
+using interface11::opencl_device;
+using interface11::opencl_device_list;
+using interface11::opencl_program;
+using interface11::opencl_program_type;
+using interface11::opencl_async_msg;
+using interface11::opencl_factory;
+using interface11::opencl_range;
 
 } // namespace flow
 } // namespace tbb
 #endif /* __TBB_PREVIEW_OPENCL_NODE */
 
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_flow_graph_opencl_node_H_include_area
+
 #endif // __TBB_flow_graph_opencl_node_H
diff --git a/inst/include/tbb/gfx_factory.h b/inst/include/tbb/gfx_factory.h
deleted file mode 100644
index 76ca3559..00000000
--- a/inst/include/tbb/gfx_factory.h
+++ /dev/null
@@ -1,359 +0,0 @@
-/*
-    Copyright (c) 2005-2017 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.
-
-
-
-
-*/
-
-#ifndef __TBB_flow_graph_gfx_factory_H
-#define __TBB_flow_graph_gfx_factory_H
-
-#include "tbb/tbb_config.h"
-
-#if __TBB_PREVIEW_GFX_FACTORY
-
-#include <vector>
-#include <future>
-#include <mutex>
-#include <iostream>
-
-#include <gfx/gfx_rt.h>
-#include <gfx/gfx_intrin.h>
-#include <gfx/gfx_types.h>
-
-namespace tbb {
-
-namespace flow {
-
-namespace interface9 {
-
-template <typename T>
-class gfx_buffer;
-
-namespace gfx_offload {
-
-    typedef GfxTaskId task_id_type;
-
-    //-----------------------------------------------------------------------
-    // GFX errors checkers.
-    // For more debug output, set GFX_LOG_OFFLOAD=2 macro
-    //-----------------------------------------------------------------------
-
-    // TODO: reconsider error handling approach. If exception is the right way
-    // then need to define and document a specific exception type.
-    inline void throw_gfx_exception() {
-        std::string msg = "GFX error occurred: " + std::to_string(_GFX_get_last_error());
-        std::cerr << msg << std::endl;
-        throw msg;
-    }
-
-    inline void check_enqueue_retcode(task_id_type err) {
-        if (err == 0) {
-            throw_gfx_exception();
-        }
-    }
-
-    inline void check_gfx_retcode(task_id_type err) {
-        if (err != GFX_SUCCESS) {
-            throw_gfx_exception();
-        }
-    }
-
-    //---------------------------------------------------------------------
-    // GFX asynchronous offload and share API
-    //---------------------------------------------------------------------
-
-    // Sharing and unsharing data API
-    template<typename DataType, typename SizeType>
-    void share(DataType* p, SizeType n) { check_gfx_retcode(_GFX_share(p, sizeof(*p)*n)); }
-    template<typename DataType>
-    void unshare(DataType* p) { check_gfx_retcode(_GFX_unshare(p)); }
-
-    // Retrieving array pointer from shared gfx_buffer
-    // Other types remain the same
-    template <typename T>
-    T* raw_data(gfx_buffer<T>& buffer) { return buffer.data(); }
-    template <typename T>
-    const T* raw_data(const gfx_buffer<T>& buffer) { return buffer.data(); }
-    template <typename T>
-    T& raw_data(T& data) { return data; }
-    template <typename T>
-    const T& raw_data(const T& data) { return data; }
-
-    // Kernel enqueuing on device with arguments
-    template <typename F, typename ...ArgType>
-    task_id_type run_kernel(F ptr, ArgType&... args) {
-        task_id_type id = _GFX_offload(ptr, raw_data(args)...);
-
-        // Check if something during offload went wrong (ex: driver initialization failure)
-        gfx_offload::check_enqueue_retcode(id);
-
-        return id;
-    }
-
-    // Waiting for tasks completion
-    void wait_for_task(task_id_type id) { check_gfx_retcode(_GFX_wait(id)); }
-
-} // namespace gfx_offload
-
-template <typename T>
-class gfx_buffer {
-public:
-
-    typedef typename std::vector<T>::iterator iterator;
-    typedef typename std::vector<T>::const_iterator const_iterator;
-
-    typedef std::size_t size_type;
-
-    gfx_buffer() : my_vector_ptr(std::make_shared< std::vector<T> >()) {}
-    gfx_buffer(size_type size) : my_vector_ptr(std::make_shared< std::vector<T> >(size)) {}
-
-    T* data() { return &(my_vector_ptr->front()); }
-    const T* data() const { return &(my_vector_ptr->front()); }
-
-    size_type size() const { return my_vector_ptr->size(); }
-
-    const_iterator cbegin() const { return my_vector_ptr->cbegin(); }
-    const_iterator cend() const { return my_vector_ptr->cend(); }
-    iterator begin() { return my_vector_ptr->begin(); }
-    iterator end() { return my_vector_ptr->end(); }
-
-    T& operator[](size_type pos) { return (*my_vector_ptr)[pos]; }
-    const T& operator[](size_type pos) const { return (*my_vector_ptr)[pos]; }
-
-private:
-    std::shared_ptr< std::vector<T> > my_vector_ptr;
-};
-
-template<typename T>
-class gfx_async_msg : public tbb::flow::async_msg<T> {
-public:
-    typedef gfx_offload::task_id_type kernel_id_type;
-
-    gfx_async_msg() : my_task_id(0) {}
-    gfx_async_msg(const T& input_data) : my_data(input_data), my_task_id(0) {}
-
-    T& data() { return my_data; }
-    const T& data() const { return my_data; }
-
-    void set_task_id(kernel_id_type id) { my_task_id = id; }
-    kernel_id_type task_id() const { return my_task_id; }
-
-private:
-    T my_data;
-    kernel_id_type my_task_id;
-};
-
-class gfx_factory {
-private:
-
-    // Wrapper for GFX kernel which is just a function
-    class func_wrapper {
-    public:
-
-        template <typename F>
-        func_wrapper(F ptr) { my_ptr = reinterpret_cast<void*>(ptr); }
-
-        template<typename ...Args>
-        void operator()(Args&&... args) {}
-
-        operator void*() { return my_ptr; }
-
-    private:
-        void* my_ptr;
-    };
-
-public:
-
-    // Device specific types
-    template<typename T> using async_msg_type = gfx_async_msg<T>;
-
-    typedef func_wrapper kernel_type;
-
-    // Empty device type that is needed for Factory Concept
-    // but is not used in gfx_factory
-    typedef struct {} device_type;
-
-    typedef gfx_offload::task_id_type kernel_id_type;
-
-    gfx_factory(tbb::flow::graph& g) : m_graph(g), current_task_id(0) {}
-
-    // Upload data to the device
-    template <typename ...Args>
-    void send_data(device_type /*device*/, Args&... args) {
-        send_data_impl(args...);
-    }
-
-    // Run kernel on the device
-    template <typename ...Args>
-    void send_kernel(device_type /*device*/, const kernel_type& kernel, Args&... args) {
-        // Get packed T data from async_msg<T> and pass it to kernel
-        kernel_id_type id = gfx_offload::run_kernel(kernel, args.data()...);
-
-        // Set id to async_msg
-        set_kernel_id(id, args...);
-
-        // Extend the graph lifetime until the callback completion.
-        m_graph.reserve_wait();
-
-        // Mutex for future assignment
-        std::lock_guard<std::mutex> lock(future_assignment_mutex);
-
-        // Set callback that waits for kernel execution
-        callback_future = std::async(std::launch::async, &gfx_factory::callback<Args...>, this, id, args...);
-    }
-
-    // Finalization action after the kernel run
-    template <typename FinalizeFn, typename ...Args>
-    void finalize(device_type /*device*/, FinalizeFn fn, Args&... /*args*/) {
-        fn();
-    }
-
-    // Empty device selector.
-    // No way to choose a device with GFX API.
-    class dummy_device_selector {
-    public:
-        device_type operator()(gfx_factory& /*factory*/) {
-            return device_type();
-        }
-    };
-
-private:
-
-    //---------------------------------------------------------------------
-    // Callback for kernel result
-    //---------------------------------------------------------------------
-
-    template <typename ...Args>
-    void callback(kernel_id_type id, Args... args) {
-        // Waiting for specific tasks id to complete
-        {
-            std::lock_guard<std::mutex> lock(task_wait_mutex);
-            if (current_task_id < id) {
-                gfx_offload::wait_for_task(id);
-                current_task_id = id;
-            }
-        }
-
-        // Get result from device and set to async_msg (args)
-        receive_data(args...);
-
-        // Data was sent to the graph, release the reference
-        m_graph.release_wait();
-    }
-
-    //---------------------------------------------------------------------
-    // send_data() arguments processing
-    //---------------------------------------------------------------------
-
-    // GFX buffer shared data with device that will be executed on
-    template <typename T>
-    void share_data(T) {}
-
-    template <typename T>
-    void share_data(gfx_buffer<T>& buffer) {
-        gfx_offload::share(buffer.data(), buffer.size());
-    }
-
-    template <typename T>
-    void send_arg(T) {}
-
-    template <typename T>
-    void send_arg(async_msg_type<T>& msg) {
-        share_data(msg.data());
-    }
-
-    void send_data_impl() {}
-
-    template <typename T, typename ...Rest>
-    void send_data_impl(T& arg, Rest&... args) {
-        send_arg(arg);
-        send_data_impl(args...);
-    }
-
-    //----------------------------------------------------------------------
-    // send_kernel() arguments processing
-    //----------------------------------------------------------------------
-
-    template <typename T>
-    void set_kernel_id_arg(kernel_id_type, T) {}
-
-    template <typename T>
-    void set_kernel_id_arg(kernel_id_type id, async_msg_type<T>& msg) {
-        msg.set_task_id(id);
-    }
-
-    void set_kernel_id(kernel_id_type) {}
-
-    template <typename T, typename ...Rest>
-    void set_kernel_id(kernel_id_type id, T& arg, Rest&... args) {
-        set_kernel_id_arg(id, arg);
-        set_kernel_id(id, args...);
-    }
-
-    //-----------------------------------------------------------------------
-    // Arguments processing after kernel execution.
-    // Unsharing buffers and forwarding results to the graph
-    //-----------------------------------------------------------------------
-
-    // After kernel execution the data should be unshared
-    template <typename T>
-    void unshare_data(T) {}
-
-    template <typename T>
-    void unshare_data(gfx_buffer<T>& buffer) {
-        gfx_offload::unshare(buffer.data());
-    }
-
-    template <typename T>
-    void receive_arg(T) {}
-
-    template <typename T>
-    void receive_arg(async_msg_type<T>& msg) {
-        unshare_data(msg.data());
-        msg.set(msg.data());
-    }
-
-    void receive_data() {}
-
-    template <typename T, typename ...Rest>
-    void receive_data(T& arg, Rest&... args) {
-        receive_arg(arg);
-        receive_data(args...);
-    }
-
-    //-----------------------------------------------------------------------
-    int current_task_id;
-
-    std::future<void> callback_future;
-    tbb::flow::graph& m_graph;
-
-    std::mutex future_assignment_mutex;
-    std::mutex task_wait_mutex;
-};
-
-} // namespace interface9
-
-using interface9::gfx_factory;
-using interface9::gfx_buffer;
-
-} // namespace flow
-
-} // namespace tbb
-
-#endif // __TBB_PREVIEW_GFX_FACTORY
-
-#endif // __TBB_flow_graph_gfx_factory_H
diff --git a/inst/include/tbb/global_control.h b/inst/include/tbb/global_control.h
index fe742020..bdcd59a5 100644
--- a/inst/include/tbb/global_control.h
+++ b/inst/include/tbb/global_control.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,19 +12,11 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_global_control_H
 #define __TBB_global_control_H
 
-#if !TBB_PREVIEW_GLOBAL_CONTROL && !__TBB_BUILD
-#error Set TBB_PREVIEW_GLOBAL_CONTROL before including global_control.h
-#endif
-
 #include "tbb_stddef.h"
 
 namespace tbb {
@@ -41,8 +33,8 @@ class global_control {
     global_control(parameter p, size_t value) :
         my_value(value), my_next(NULL), my_param(p) {
         __TBB_ASSERT(my_param < parameter_max, "Invalid parameter");
-#if __TBB_WIN8UI_SUPPORT
-        // For Windows Store* apps it's impossible to set stack size
+#if __TBB_WIN8UI_SUPPORT && (_WIN32_WINNT < 0x0A00)
+        // For Windows 8 Store* apps it's impossible to set stack size
         if (p==thread_stack_size)
             return;
 #elif __TBB_x86_64 && (_WIN32 || _WIN64)
@@ -56,8 +48,8 @@ class global_control {
 
     ~global_control() {
         __TBB_ASSERT(my_param < parameter_max, "Invalid parameter. Probably the object was corrupted.");
-#if __TBB_WIN8UI_SUPPORT
-        // For Windows Store* apps it's impossible to set stack size
+#if __TBB_WIN8UI_SUPPORT && (_WIN32_WINNT < 0x0A00)
+        // For Windows 8 Store* apps it's impossible to set stack size
         if (my_param==thread_stack_size)
             return;
 #endif
diff --git a/inst/include/tbb/index.html b/inst/include/tbb/index.html
index 2eddd450..9ead0e24 100644
--- a/inst/include/tbb/index.html
+++ b/inst/include/tbb/index.html
@@ -19,7 +19,7 @@ <H2>Directories</H2>
 <HR>
 <A HREF="../index.html">Up to parent directory</A>
 <p></p>
-Copyright &copy; 2005-2017 Intel Corporation.  All Rights Reserved.
+Copyright &copy; 2005-2020 Intel Corporation.  All Rights Reserved.
 <P></P>
 Intel is a registered trademark or trademark of Intel Corporation
 or its subsidiaries in the United States and other countries.
diff --git a/inst/include/tbb/info.h b/inst/include/tbb/info.h
new file mode 100644
index 00000000..84b32092
--- /dev/null
+++ b/inst/include/tbb/info.h
@@ -0,0 +1,52 @@
+/*
+    Copyright (c) 2019-2020 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.
+*/
+
+#ifndef __TBB_info_H
+#define __TBB_info_H
+
+#include "tbb_config.h"
+
+#if __TBB_NUMA_SUPPORT
+
+#include <vector>
+
+namespace tbb {
+    namespace internal {
+        namespace numa_topology {
+            unsigned nodes_count();
+            void fill(int* indexes_array);
+            int default_concurrency(int node_id);
+        } //namespace numa_topology
+    } // namespace internal
+
+    typedef int numa_node_id;
+
+    namespace info {
+        inline std::vector<numa_node_id> numa_nodes() {
+            std::vector<numa_node_id> nodes_indexes(tbb::internal::numa_topology::nodes_count());
+            internal::numa_topology::fill(&nodes_indexes.front());
+            return nodes_indexes;
+        }
+
+        inline int default_concurrency(numa_node_id id = -1) {
+            return internal::numa_topology::default_concurrency(id);
+        }
+    } // namespace info
+} // namespace tbb
+
+#endif /*__TBB_NUMA_SUPPORT*/
+
+#endif /*__TBB_info_H*/
diff --git a/inst/include/tbb/internal/_aggregator_impl.h b/inst/include/tbb/internal/_aggregator_impl.h
index 40bbd491..6d89c055 100644
--- a/inst/include/tbb/internal/_aggregator_impl.h
+++ b/inst/include/tbb/internal/_aggregator_impl.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB__aggregator_impl_H
@@ -164,7 +160,7 @@ template<typename aggregating_class, typename operation_list>
 class aggregating_functor {
     aggregating_class *fi;
 public:
-    aggregating_functor() {}
+    aggregating_functor() : fi() {}
     aggregating_functor(aggregating_class *fi_) : fi(fi_) {}
     void operator()(operation_list* op_list) { fi->handle_operations(op_list); }
 };
diff --git a/inst/include/tbb/internal/_allocator_traits.h b/inst/include/tbb/internal/_allocator_traits.h
new file mode 100644
index 00000000..eba986b7
--- /dev/null
+++ b/inst/include/tbb/internal/_allocator_traits.h
@@ -0,0 +1,156 @@
+/*
+    Copyright (c) 2019-2020 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.
+*/
+
+#ifndef __TBB_allocator_traits_H
+#define __TBB_allocator_traits_H
+
+#include "../tbb_stddef.h" // true/false_type
+
+#if __TBB_ALLOCATOR_TRAITS_PRESENT
+#include <memory> // for allocator_traits
+#endif
+
+#if __TBB_CPP11_RVALUE_REF_PRESENT
+#include <utility> // for std::move
+#endif
+
+// For allocator_swap helper
+#include __TBB_STD_SWAP_HEADER
+
+namespace tbb {
+namespace internal {
+
+//! Internal implementation of allocator traits, propagate_on_* use internal boolean_constant.
+//! In order to avoid code duplication, check what implementation of boolean constant will likely be passed.
+#if __TBB_ALLOCATOR_TRAITS_PRESENT
+typedef std::true_type traits_true_type;
+typedef std::false_type traits_false_type;
+#else
+typedef tbb::internal::true_type traits_true_type;
+typedef tbb::internal::false_type traits_false_type;
+#endif
+
+//! Copy assignment implementation for allocator if propagate_on_container_copy_assignment == true_type
+//! Noop if pocca == false_type
+template <typename MyAlloc, typename OtherAlloc>
+inline void allocator_copy_assignment(MyAlloc& my_allocator, OtherAlloc& other_allocator, traits_true_type) {
+    my_allocator = other_allocator;
+}
+template <typename MyAlloc, typename OtherAlloc>
+inline void allocator_copy_assignment(MyAlloc&, OtherAlloc&, traits_false_type) { /* NO COPY */}
+
+#if __TBB_CPP11_RVALUE_REF_PRESENT
+//! Move assignment implementation for allocator if propagate_on_container_move_assignment == true_type.
+//! Noop if pocma == false_type.
+template <typename MyAlloc, typename OtherAlloc>
+inline void allocator_move_assignment(MyAlloc& my_allocator, OtherAlloc& other_allocator, traits_true_type) {
+    my_allocator = std::move(other_allocator);
+}
+template <typename MyAlloc, typename OtherAlloc>
+inline void allocator_move_assignment(MyAlloc&, OtherAlloc&, traits_false_type) { /* NO MOVE */ }
+#endif
+
+//! Swap implementation for allocators if propagate_on_container_swap == true_type.
+//! Noop if pocs == false_type.
+template <typename MyAlloc, typename OtherAlloc>
+inline void allocator_swap(MyAlloc& my_allocator, OtherAlloc& other_allocator, traits_true_type) {
+    using std::swap;
+    swap(my_allocator, other_allocator);
+}
+template <typename MyAlloc, typename OtherAlloc>
+inline void allocator_swap(MyAlloc&, OtherAlloc&, traits_false_type) { /* NO SWAP */ }
+
+#if __TBB_ALLOCATOR_TRAITS_PRESENT
+using std::allocator_traits;
+#else
+//! Internal allocator_traits implementation, which relies on C++03 standard
+//! [20.1.5] allocator requirements
+template<typename Alloc>
+struct allocator_traits {
+    // C++03 allocator doesn't have to be assignable or swappable, therefore
+    // define these traits as false_type to do not require additional operations
+    // that are not supposed to be in.
+    typedef tbb::internal::false_type propagate_on_container_move_assignment;
+    typedef tbb::internal::false_type propagate_on_container_copy_assignment;
+    typedef tbb::internal::false_type propagate_on_container_swap;
+
+    typedef Alloc allocator_type;
+    typedef typename allocator_type::value_type value_type;
+
+    typedef typename allocator_type::pointer pointer;
+    typedef typename allocator_type::const_pointer const_pointer;
+    typedef typename allocator_type::difference_type difference_type;
+    typedef typename allocator_type::size_type size_type;
+
+    template <typename U> struct rebind_alloc {
+        typedef typename Alloc::template rebind<U>::other other;
+    };
+
+    static pointer allocate(Alloc& a, size_type n) {
+        return a.allocate(n);
+    }
+
+    static void deallocate(Alloc& a, pointer p, size_type n) {
+        a.deallocate(p, n);
+    }
+
+    template<typename PT>
+    static void construct(Alloc&, PT* p) {
+        ::new (static_cast<void*>(p)) PT();
+    }
+
+    template<typename PT, typename T1>
+    static void construct(Alloc&, PT* p, __TBB_FORWARDING_REF(T1) t1) {
+        ::new (static_cast<void*>(p)) PT(tbb::internal::forward<T1>(t1));
+    }
+
+    template<typename PT, typename T1, typename T2>
+    static void construct(Alloc&, PT* p, __TBB_FORWARDING_REF(T1) t1, __TBB_FORWARDING_REF(T2) t2) {
+        ::new (static_cast<void*>(p)) PT(tbb::internal::forward<T1>(t1), tbb::internal::forward<T2>(t2));
+    }
+
+    template<typename PT, typename T1, typename T2, typename T3>
+    static void construct(Alloc&, PT* p, __TBB_FORWARDING_REF(T1) t1,
+                          __TBB_FORWARDING_REF(T2) t2, __TBB_FORWARDING_REF(T3) t3) {
+        ::new (static_cast<void*>(p)) PT(tbb::internal::forward<T1>(t1), tbb::internal::forward<T2>(t2),
+                                         tbb::internal::forward<T3>(t3));
+    }
+
+    template<typename T>
+    static void destroy(Alloc&, T* p) {
+        p->~T();
+        tbb::internal::suppress_unused_warning(p);
+    }
+
+    static Alloc select_on_container_copy_construction(const Alloc& a) { return a; }
+};
+#endif // __TBB_ALLOCATOR_TRAITS_PRESENT
+
+//! C++03/C++11 compliant rebind helper, even if no std::allocator_traits available
+//! or rebind is not defined for allocator type
+template<typename Alloc, typename T>
+struct allocator_rebind {
+#if __TBB_ALLOCATOR_TRAITS_PRESENT
+    typedef typename allocator_traits<Alloc>::template rebind_alloc<T> type;
+#else
+    typedef typename allocator_traits<Alloc>::template rebind_alloc<T>::other type;
+#endif
+};
+
+}} // namespace tbb::internal
+
+#endif // __TBB_allocator_traits_H
+
diff --git a/inst/include/tbb/internal/_concurrent_queue_impl.h b/inst/include/tbb/internal/_concurrent_queue_impl.h
index 4283f87c..e3bef772 100644
--- a/inst/include/tbb/internal/_concurrent_queue_impl.h
+++ b/inst/include/tbb/internal/_concurrent_queue_impl.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB__concurrent_queue_impl_H
@@ -34,19 +30,8 @@
 #include "../tbb_profiling.h"
 #include <new>
 #include __TBB_STD_SWAP_HEADER
-
-#if !TBB_USE_EXCEPTIONS && _MSC_VER
-    // Suppress "C++ exception handler used, but unwind semantics are not enabled" warning in STL headers
-    #pragma warning (push)
-    #pragma warning (disable: 4530)
-#endif
-
 #include <iterator>
 
-#if !TBB_USE_EXCEPTIONS && _MSC_VER
-    #pragma warning (pop)
-#endif
-
 namespace tbb {
 
 #if !__TBB_TEMPLATE_FRIENDS_BROKEN
@@ -525,7 +510,7 @@ concurrent_queue_base_v3<T>::concurrent_queue_base_v3() {
     __TBB_ASSERT( (size_t)&my_rep->head_counter % NFS_GetLineSize()==0, "alignment error" );
     __TBB_ASSERT( (size_t)&my_rep->tail_counter % NFS_GetLineSize()==0, "alignment error" );
     __TBB_ASSERT( (size_t)&my_rep->array % NFS_GetLineSize()==0, "alignment error" );
-    memset((void*) my_rep, 0, sizeof(concurrent_queue_rep<T>));
+    memset(static_cast<void*>(my_rep),0,sizeof(concurrent_queue_rep<T>));
     my_rep->item_size = item_size;
     my_rep->items_per_page = item_size<=  8 ? 32 :
                              item_size<= 16 ? 16 :
@@ -658,7 +643,7 @@ bool concurrent_queue_iterator_rep<T>::get_item( T*& item, size_t k ) {
 //! Constness-independent portion of concurrent_queue_iterator.
 /** @ingroup containers */
 template<typename Value>
-class concurrent_queue_iterator_base_v3 : no_assign {
+class concurrent_queue_iterator_base_v3 {
     //! Represents concurrent_queue over which we are iterating.
     /** NULL if one past last element in queue. */
     concurrent_queue_iterator_rep<Value>* my_rep;
@@ -681,8 +666,13 @@ class concurrent_queue_iterator_base_v3 : no_assign {
 
     //! Copy constructor
     concurrent_queue_iterator_base_v3( const concurrent_queue_iterator_base_v3& i )
-    : no_assign(), my_rep(NULL), my_item(NULL) {
+    : my_rep(NULL), my_item(NULL) {
+        assign(i);
+    }
+
+    concurrent_queue_iterator_base_v3& operator=( const concurrent_queue_iterator_base_v3& i ) {
         assign(i);
+        return *this;
     }
 
     //! Construct iterator pointing to head of queue.
@@ -779,8 +769,8 @@ class concurrent_queue_iterator: public concurrent_queue_iterator_base_v3<typena
     {}
 
     //! Iterator assignment
-    concurrent_queue_iterator& operator=( const concurrent_queue_iterator& other ) {
-        this->assign(other);
+    concurrent_queue_iterator& operator=( const concurrent_queue_iterator<Container,typename Container::value_type>& other ) {
+        concurrent_queue_iterator_base_v3<typename tbb_remove_cv<Value>::type>::operator=(other);
         return *this;
     }
 
@@ -900,7 +890,7 @@ class concurrent_queue_base_v3: no_copy {
     //! Get size of queue
     ptrdiff_t __TBB_EXPORTED_METHOD internal_size() const;
 
-    //! Check if the queue is emtpy
+    //! Check if the queue is empty
     bool __TBB_EXPORTED_METHOD internal_empty() const;
 
     //! Set the queue capacity
@@ -991,6 +981,11 @@ class concurrent_queue_iterator_base_v3 {
         assign(i);
     }
 
+    concurrent_queue_iterator_base_v3& operator=( const concurrent_queue_iterator_base_v3& i ) {
+        assign(i);
+        return *this;
+    }
+
     //! Obsolete entry point for constructing iterator pointing to head of queue.
     /** Does not work correctly for SSE types. */
     __TBB_EXPORTED_METHOD concurrent_queue_iterator_base_v3( const concurrent_queue_base_v3& queue );
@@ -1040,8 +1035,8 @@ class concurrent_queue_iterator: public concurrent_queue_iterator_base,
     {}
 
     //! Iterator assignment
-    concurrent_queue_iterator& operator=( const concurrent_queue_iterator& other ) {
-        assign(other);
+    concurrent_queue_iterator& operator=( const concurrent_queue_iterator<Container,typename Container::value_type>& other ) {
+        concurrent_queue_iterator_base_v3::operator=(other);
         return *this;
     }
 
diff --git a/inst/include/tbb/internal/_concurrent_skip_list_impl.h b/inst/include/tbb/internal/_concurrent_skip_list_impl.h
new file mode 100644
index 00000000..8cc1a11d
--- /dev/null
+++ b/inst/include/tbb/internal/_concurrent_skip_list_impl.h
@@ -0,0 +1,1085 @@
+/*
+    Copyright (c) 2019-2020 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.
+*/
+
+#ifndef __TBB_concurrent_skip_list_H
+#define __TBB_concurrent_skip_list_H
+
+#if !defined(__TBB_concurrent_map_H) && !defined(__TBB_concurrent_set_H)
+#error Do not #include this internal file directly; use public TBB headers instead.
+#endif
+
+#include "../tbb_config.h"
+#include "../tbb_stddef.h"
+#include "../tbb_allocator.h"
+#include "../spin_mutex.h"
+#include "../tbb_exception.h"
+#include "../enumerable_thread_specific.h"
+#include "_allocator_traits.h"
+#include "_template_helpers.h"
+#include "_node_handle_impl.h"
+#include <utility> // Need std::pair
+#include <functional>
+#include <initializer_list>
+#include <memory> // Need std::allocator_traits
+#include <atomic>
+#include <mutex>
+#include <vector>
+#include <array>
+#include <type_traits>
+#include <cstdlib>
+#include <random>
+#include <tuple>
+
+#if _MSC_VER
+#pragma warning(disable: 4189) // warning 4189 -- local variable is initialized but not referenced
+#pragma warning(disable: 4127) // warning 4127 -- while (true) has a constant expression in it
+#endif
+
+namespace tbb {
+namespace interface10 {
+namespace internal {
+
+template <typename Value, typename Mutex>
+class skip_list_node {
+
+public:
+    using value_type = Value;
+    using size_type = std::size_t;
+    using reference = value_type & ;
+    using const_reference = const value_type & ;
+    using pointer = value_type * ;
+    using const_pointer = const value_type *;
+    using node_pointer = skip_list_node * ;
+    using atomic_node_pointer = std::atomic<node_pointer>;
+
+    using mutex_type = Mutex;
+    using lock_type = std::unique_lock<mutex_type>;
+
+    skip_list_node(size_type levels) : my_height(levels), my_fullyLinked(false) {
+        for (size_type lev = 0; lev < my_height; ++lev)
+            new(&my_next(lev)) atomic_node_pointer(nullptr);
+        __TBB_ASSERT(height() == levels, "Wrong node height");
+    }
+
+    ~skip_list_node() {
+        for(size_type lev = 0; lev < my_height; ++lev)
+            my_next(lev).~atomic();
+    }
+
+    skip_list_node(const skip_list_node&) = delete;
+
+    skip_list_node(skip_list_node&&) = delete;
+
+    skip_list_node& operator=(const skip_list_node&) = delete;
+
+    pointer storage() {
+        return reinterpret_cast<pointer>(&my_val);
+    }
+
+    reference value() {
+        return *storage();
+    }
+
+    node_pointer next(size_type level) const {
+        __TBB_ASSERT(level < height(), "Cannot get next on the level greater than height");
+        return my_next(level).load(std::memory_order_acquire);
+    }
+
+    void set_next(size_type level, node_pointer next) {
+        __TBB_ASSERT(level < height(), "Cannot set next on the level greater than height");
+
+        my_next(level).store(next, std::memory_order_release);
+    }
+
+    /** @return number of layers */
+    size_type height() const {
+        return my_height;
+    }
+
+    bool fully_linked() const {
+        return my_fullyLinked.load(std::memory_order_acquire);
+    }
+
+    void mark_linked() {
+        my_fullyLinked.store(true, std::memory_order_release);
+    }
+
+    lock_type acquire() {
+        return lock_type(my_mutex);
+    }
+
+private:
+    using aligned_storage_type = typename std::aligned_storage<sizeof(value_type), alignof(value_type)>::type;
+
+    atomic_node_pointer& my_next(size_type level) {
+        atomic_node_pointer* arr = reinterpret_cast<atomic_node_pointer*>(this + 1);
+        return arr[level];
+    }
+
+    const atomic_node_pointer& my_next(size_type level) const {
+        const atomic_node_pointer* arr = reinterpret_cast<const atomic_node_pointer*>(this + 1);
+        return arr[level];
+    }
+
+    mutex_type my_mutex;
+    aligned_storage_type my_val;
+    size_type my_height;
+    std::atomic_bool my_fullyLinked;
+};
+
+template <typename NodeType, bool is_const>
+class skip_list_iterator {
+    using node_type = NodeType;
+    using node_ptr = node_type*;
+public:
+    using iterator_category = std::forward_iterator_tag;
+    using value_type = typename node_type::value_type;
+    using difference_type = std::ptrdiff_t;
+    using pointer = typename std::conditional<is_const, typename node_type::const_pointer,
+                                                        typename node_type::pointer>::type;
+    using reference = typename std::conditional<is_const, typename node_type::const_reference,
+                                                          typename node_type::reference>::type;
+
+    skip_list_iterator() : my_node_ptr(nullptr) {}
+
+    // TODO: the code above does not compile in VS2015 (seems like a bug) - consider enabling it for all other platforms
+    // template <typename T = void, typename = typename std::enable_if<is_const, T>::type>
+    // skip_list_iterator(const skip_list_iterator<node_type, false>& other) : my_node_ptr(other.my_node_ptr) {}
+
+    // skip_list_iterator(const skip_list_iterator& other) : my_node_ptr(other.my_node_ptr) {}
+
+    skip_list_iterator(const skip_list_iterator<node_type, false>& other) : my_node_ptr(other.my_node_ptr) {}
+
+    skip_list_iterator& operator=(const skip_list_iterator<node_type, false>& other) {
+         my_node_ptr = other.my_node_ptr;
+         return *this;
+    }
+
+    template <typename T = void, typename = typename std::enable_if<is_const, T>::type>
+    skip_list_iterator(const skip_list_iterator<node_type, true>& other) : my_node_ptr(other.my_node_ptr) {}
+
+    reference operator*() const { return *(my_node_ptr->storage()); }
+    pointer operator->() const { return &**this; }
+
+    skip_list_iterator& operator++() {
+        __TBB_ASSERT(my_node_ptr != nullptr, NULL);
+        my_node_ptr = my_node_ptr->next(0);
+        return *this;
+    }
+
+    skip_list_iterator operator++(int) {
+        skip_list_iterator tmp = *this;
+        ++*this;
+        return tmp;
+    }
+
+private:
+    skip_list_iterator(node_type* n) : my_node_ptr(n) {}
+
+    node_ptr my_node_ptr;
+
+    template <typename Traits>
+    friend class concurrent_skip_list;
+
+    friend class skip_list_iterator<NodeType, true>;
+
+    friend class const_range;
+    friend class range;
+
+    template <typename T, bool M, bool U>
+    friend bool operator==(const skip_list_iterator<T, M>&, const skip_list_iterator<T, U>&);
+
+    template <typename T, bool M, bool U>
+    friend bool operator!=(const skip_list_iterator<T, M>&, const skip_list_iterator<T, U>&);
+};
+
+template <typename NodeType, bool is_const1, bool is_const2>
+bool operator==(const skip_list_iterator<NodeType, is_const1>& lhs, const skip_list_iterator<NodeType, is_const2>& rhs) {
+    return lhs.my_node_ptr == rhs.my_node_ptr;
+}
+
+template <typename NodeType, bool is_const1, bool is_const2>
+bool operator!=(const skip_list_iterator<NodeType, is_const1>& lhs, const skip_list_iterator<NodeType, is_const2>& rhs) {
+    return lhs.my_node_ptr != rhs.my_node_ptr;
+}
+
+template <typename Traits>
+class concurrent_skip_list {
+protected:
+    using traits_type = Traits;
+    using allocator_type = typename traits_type::allocator_type;
+    using allocator_traits_type = std::allocator_traits<allocator_type>;
+    using key_compare = typename traits_type::compare_type;
+    using value_compare = typename traits_type::value_compare;
+    using key_type = typename traits_type::key_type;
+    using value_type = typename traits_type::value_type;
+    using node_type = typename traits_type::node_type;
+    using list_node_type = skip_list_node<value_type, typename traits_type::mutex_type>;
+
+    using iterator = skip_list_iterator<list_node_type, /*is_const=*/false>;
+    using const_iterator = skip_list_iterator<list_node_type, /*is_const=*/true>;
+    using reverse_iterator = std::reverse_iterator<iterator>;
+    using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+
+    using reference = value_type&;
+    using const_reference = const value_type&;
+    using pointer = typename allocator_traits_type::pointer;
+    using const_pointer = typename allocator_traits_type::const_pointer;
+    using size_type = std::size_t;
+    using difference_type = std::ptrdiff_t;
+
+    using random_level_generator_type = typename traits_type::random_level_generator_type;
+    using node_allocator_type = typename std::allocator_traits<allocator_type>::template rebind_alloc<uint8_t>;
+    using node_allocator_traits = typename std::allocator_traits<allocator_type>::template rebind_traits<uint8_t>;
+    using node_ptr = list_node_type*;
+
+    static constexpr size_type MAX_LEVEL = traits_type::MAX_LEVEL;
+
+    using array_type = std::array<node_ptr, MAX_LEVEL>;
+    using lock_array = std::array<typename list_node_type::lock_type, MAX_LEVEL>;
+
+public:
+    static bool const allow_multimapping = traits_type::allow_multimapping;
+
+    /**
+     * Default constructor. Construct empty skip list.
+     */
+    concurrent_skip_list() : my_size(0) {
+        create_dummy_head();
+    }
+
+    explicit concurrent_skip_list(const key_compare& comp, const allocator_type& alloc = allocator_type())
+        : my_node_allocator(alloc), my_compare(comp), my_size(0)
+    {
+        create_dummy_head();
+    }
+
+    template<class InputIt>
+    concurrent_skip_list(InputIt first, InputIt last, const key_compare& comp = key_compare(),
+                         const allocator_type& alloc = allocator_type())
+        : my_node_allocator(alloc), my_compare(comp), my_size(0)
+    {
+        create_dummy_head();
+        internal_copy(first, last);
+    }
+
+    /** Copy constructor */
+    concurrent_skip_list(const concurrent_skip_list& other)
+        : my_node_allocator(node_allocator_traits::select_on_container_copy_construction(other.get_allocator())),
+          my_compare(other.my_compare), my_rnd_generator(other.my_rnd_generator), my_size(0)
+    {
+        create_dummy_head();
+        internal_copy(other);
+        __TBB_ASSERT(my_size == other.my_size, "Wrong size of copy-constructed container");
+    }
+
+    concurrent_skip_list(const concurrent_skip_list& other, const allocator_type& alloc)
+        : my_node_allocator(alloc), my_compare(other.my_compare),
+          my_rnd_generator(other.my_rnd_generator), my_size(0)
+    {
+        create_dummy_head();
+        internal_copy(other);
+        __TBB_ASSERT(my_size == other.my_size, "Wrong size of copy-constructed container");
+    }
+
+    concurrent_skip_list(concurrent_skip_list&& other)
+        : my_node_allocator(std::move(other.my_node_allocator)), my_compare(other.my_compare),
+          my_rnd_generator(other.my_rnd_generator)
+    {
+        internal_move(std::move(other));
+    }
+
+    concurrent_skip_list(concurrent_skip_list&& other, const allocator_type& alloc)
+        : my_node_allocator(alloc), my_compare(other.my_compare),
+          my_rnd_generator(other.my_rnd_generator)
+    {
+        if (alloc == other.get_allocator()) {
+            internal_move(std::move(other));
+        } else {
+            my_size = 0;
+            create_dummy_head();
+            internal_copy(std::make_move_iterator(other.begin()), std::make_move_iterator(other.end()));
+        }
+    }
+
+    ~concurrent_skip_list() {
+        clear();
+        delete_dummy_head();
+    }
+
+    concurrent_skip_list& operator=(const concurrent_skip_list& other) {
+        if (this != &other) {
+            using pocca_type = typename node_allocator_traits::propagate_on_container_copy_assignment;
+            clear();
+            tbb::internal::allocator_copy_assignment(my_node_allocator, other.my_node_allocator, pocca_type());
+            my_compare = other.my_compare;
+            my_rnd_generator = other.my_rnd_generator;
+            internal_copy(other);
+        }
+        return *this;
+    }
+
+    concurrent_skip_list& operator=(concurrent_skip_list&& other) {
+        if (this != &other) {
+            using pocma_type = typename node_allocator_traits::propagate_on_container_move_assignment;
+            clear();
+            my_compare = other.my_compare;
+            my_rnd_generator = other.my_rnd_generator;
+            internal_move_assign(std::move(other), pocma_type());
+        }
+        return *this;
+    }
+
+    concurrent_skip_list& operator=(std::initializer_list<value_type> il)
+    {
+        clear();
+        insert(il.begin(),il.end());
+        return *this;
+    }
+
+    std::pair<iterator, bool> insert(const value_type& value) {
+        return internal_insert(value);
+    }
+
+    std::pair<iterator, bool> insert(value_type&& value) {
+        return internal_insert(std::move(value));
+    }
+
+    iterator insert(const_iterator, const_reference value) {
+        // Ignore hint
+        return insert(value).first;
+    }
+
+    iterator insert(const_iterator, value_type&& value) {
+        // Ignore hint
+        return insert(std::move(value)).first;
+    }
+
+    template<typename InputIterator>
+    void insert(InputIterator first, InputIterator last) {
+        for (InputIterator it = first; it != last; ++it)
+            insert(*it);
+    }
+
+    void insert(std::initializer_list<value_type> init) {
+        insert(init.begin(), init.end());
+    }
+
+    std::pair<iterator, bool> insert(node_type&& nh) {
+        if(!nh.empty()) {
+            std::pair<iterator, bool> insert_result = internal_insert_node(nh.my_node);
+            if(insert_result.second) {
+                nh.deactivate();
+            }
+            return insert_result;
+        }
+        return std::pair<iterator, bool>(end(), false);
+    }
+
+    iterator insert(const_iterator, node_type&& nh) {
+        // Ignore hint
+        return insert(std::move(nh)).first;
+    }
+
+    template<typename... Args >
+    std::pair<iterator, bool> emplace(Args&&... args) {
+        return internal_insert(std::forward<Args>(args)...);
+    }
+
+    template<typename... Args>
+    iterator emplace_hint(const_iterator, Args&&... args) {
+        // Ignore hint
+        return emplace(std::forward<Args>(args)...).first;
+    }
+
+    iterator unsafe_erase(iterator pos) {
+        std::pair<node_ptr, node_ptr> extract_result = internal_extract(pos);
+        if(extract_result.first) { // node was extracted
+            delete_node(extract_result.first);
+            return iterator(extract_result.second);
+        }
+        return end();
+    }
+
+    iterator unsafe_erase(const_iterator pos) {
+        return unsafe_erase(get_iterator(pos));
+    }
+
+    template <typename K, typename = tbb::internal::is_transparent<key_compare, K>,
+                          typename = typename std::enable_if<!std::is_convertible<K, iterator>::value &&
+                                                             !std::is_convertible<K, const_iterator>::value>::type>
+    size_type unsafe_erase(const K& key) {
+        std::pair<iterator, iterator> range = equal_range(key);
+        size_type sz = std::distance(range.first, range.second);
+        unsafe_erase(range.first, range.second);
+        return sz;
+    }
+
+    iterator unsafe_erase(const_iterator first, const_iterator last) {
+        while(first != last) {
+            first = unsafe_erase(get_iterator(first));
+        }
+        return get_iterator(first);
+    }
+
+    size_type unsafe_erase(const key_type& key) {
+        std::pair<iterator, iterator> range = equal_range(key);
+        size_type sz = std::distance(range.first, range.second);
+        unsafe_erase(range.first, range.second);
+        return sz;
+    }
+
+    node_type unsafe_extract(const_iterator pos) {
+        std::pair<node_ptr, node_ptr> extract_result = internal_extract(pos);
+        return extract_result.first ? node_type(extract_result.first) : node_type();
+    }
+
+    node_type unsafe_extract(const key_type& key) {
+        return unsafe_extract(find(key));
+    }
+
+    iterator lower_bound(const key_type& key) {
+        return internal_get_bound(key, my_compare);
+    }
+
+    const_iterator lower_bound(const key_type& key) const {
+        return internal_get_bound(key, my_compare);
+    }
+
+    template <typename K, typename = typename tbb::internal::is_transparent<key_compare, K> >
+    iterator lower_bound(const K& key) {
+        return internal_get_bound(key, my_compare);
+    }
+
+    template <typename K, typename = typename tbb::internal::is_transparent<key_compare, K> >
+    const_iterator lower_bound(const K& key) const {
+        return internal_get_bound(key, my_compare);
+    }
+
+    iterator upper_bound(const key_type& key) {
+        return internal_get_bound(key, not_greater_compare(my_compare));
+    }
+
+    const_iterator upper_bound(const key_type& key) const {
+        return internal_get_bound(key, not_greater_compare(my_compare));
+    }
+
+    template <typename K, typename = typename tbb::internal::is_transparent<key_compare, K> >
+    iterator upper_bound(const K& key) {
+        return internal_get_bound(key, not_greater_compare(my_compare));
+    }
+
+    template <typename K, typename = typename tbb::internal::is_transparent<key_compare, K> >
+    const_iterator upper_bound(const K& key) const {
+        return internal_get_bound(key, not_greater_compare(my_compare));
+    }
+
+    iterator find(const key_type& key) {
+        return internal_find(key);
+    }
+
+    const_iterator find(const key_type& key) const {
+        return internal_find(key);
+    }
+
+    template <typename K, typename = typename tbb::internal::is_transparent<key_compare, K> >
+    iterator find(const K& key) {
+        return internal_find(key);
+    }
+
+    template <typename K, typename = typename tbb::internal::is_transparent<key_compare, K> >
+    const_iterator find(const K& key) const {
+        return internal_find(key);
+    }
+
+    size_type count( const key_type& key ) const {
+        return internal_count(key);
+    }
+
+    template <typename K, typename = typename tbb::internal::is_transparent<key_compare, K> >
+    size_type count(const K& key) const {
+        return internal_count(key);
+    }
+
+    bool contains(const key_type& key) const {
+        return find(key) != end();
+    }
+
+    template <typename K, typename = typename tbb::internal::is_transparent<key_compare, K> >
+    bool contains(const K& key) const {
+        return find(key) != end();
+    }
+
+    void clear() noexcept {
+        __TBB_ASSERT(dummy_head->height() > 0, NULL);
+
+        node_ptr current = dummy_head->next(0);
+        while (current) {
+            __TBB_ASSERT(current->height() > 0, NULL);
+            node_ptr next = current->next(0);
+            delete_node(current);
+            current = next;
+        }
+
+        my_size = 0;
+        for (size_type i = 0; i < dummy_head->height(); ++i) {
+            dummy_head->set_next(i, nullptr);
+        }
+    }
+
+    iterator begin() {
+        return iterator(dummy_head->next(0));
+    }
+
+    const_iterator begin() const {
+        return const_iterator(dummy_head->next(0));
+    }
+
+    const_iterator cbegin() const {
+        return const_iterator(dummy_head->next(0));
+    }
+
+    iterator end() {
+        return iterator(nullptr);
+    }
+
+    const_iterator end() const {
+        return const_iterator(nullptr);
+    }
+
+    const_iterator cend() const {
+        return const_iterator(nullptr);
+    }
+
+    size_type size() const {
+        return my_size.load(std::memory_order_relaxed);
+    }
+
+    size_type max_size() const {
+        return my_node_allocator.max_size();
+    }
+
+    bool empty() const {
+        return 0 == size();
+    }
+
+    allocator_type get_allocator() const {
+        return my_node_allocator;
+    }
+
+    void swap(concurrent_skip_list& other) {
+        using std::swap;
+        using pocs_type = typename node_allocator_traits::propagate_on_container_swap;
+        tbb::internal::allocator_swap(my_node_allocator, other.my_node_allocator, pocs_type());
+        swap(my_compare, other.my_compare);
+        swap(my_rnd_generator, other.my_rnd_generator);
+        swap(dummy_head, other.dummy_head);
+
+        size_type tmp = my_size;
+        my_size.store(other.my_size);
+        other.my_size.store(tmp);
+    }
+
+    std::pair<iterator, iterator> equal_range(const key_type& key) {
+        return std::pair<iterator, iterator>(lower_bound(key), upper_bound(key));
+    }
+
+    std::pair<const_iterator, const_iterator> equal_range(const key_type& key) const {
+        return std::pair<const_iterator, const_iterator>(lower_bound(key), upper_bound(key));
+    }
+
+    template <typename K, typename = typename tbb::internal::is_transparent<key_compare, K> >
+    std::pair<iterator, iterator> equal_range(const K& key) {
+        return std::pair<iterator, iterator>(lower_bound(key), upper_bound(key));
+    }
+
+    template <typename K, typename = typename tbb::internal::is_transparent<key_compare, K> >
+    std::pair<const_iterator, const_iterator> equal_range(const K& key) const {
+        return std::pair<const_iterator, const_iterator>(lower_bound(key), upper_bound(key));
+    }
+
+    key_compare key_comp() const { return my_compare; }
+
+    value_compare value_comp() const { return traits_type::value_comp(my_compare); }
+
+    class const_range_type : tbb::internal::no_assign {
+    public:
+        using size_type = typename concurrent_skip_list::size_type;
+        using value_type = typename concurrent_skip_list::value_type;
+        using iterator = typename concurrent_skip_list::const_iterator;
+    private:
+        const_iterator my_end;
+        const_iterator my_begin;
+        size_type my_level;
+
+    public:
+
+        bool empty() const {
+            return my_begin.my_node_ptr->next(0) == my_end.my_node_ptr;
+        }
+
+        bool is_divisible() const {
+            return my_level != 0 ? my_begin.my_node_ptr->next(my_level - 1) != my_end.my_node_ptr : false;
+        }
+
+        size_type size() const { return std::distance(my_begin, my_end);}
+
+        const_range_type( const_range_type& r, split)
+            : my_end(r.my_end) {
+            my_begin = iterator(r.my_begin.my_node_ptr->next(r.my_level - 1));
+            my_level = my_begin.my_node_ptr->height();
+            r.my_end = my_begin;
+        }
+
+        const_range_type( const concurrent_skip_list& l)
+            : my_end(l.end()), my_begin(l.begin()), my_level(my_begin.my_node_ptr->height() ) {}
+
+        iterator begin() const { return my_begin; }
+        iterator end() const { return my_end; }
+        size_t grainsize() const { return 1; }
+
+    }; // class const_range_type
+
+    class range_type : public const_range_type {
+    public:
+        using iterator = typename concurrent_skip_list::iterator;
+
+        range_type(range_type& r, split) : const_range_type(r, split()) {}
+        range_type(const concurrent_skip_list& l) : const_range_type(l) {}
+
+        iterator begin() const {
+            node_ptr node = const_range_type::begin().my_node_ptr;
+            return iterator(node);
+        }
+
+        iterator end() const {
+            node_ptr node = const_range_type::end().my_node_ptr;
+            return iterator(node); }
+    }; // class range_type
+
+    range_type range() { return range_type(*this); }
+    const_range_type range() const { return const_range_type(*this); }
+
+private:
+    void internal_move(concurrent_skip_list&& other) {
+        dummy_head = other.dummy_head;
+        other.dummy_head = nullptr;
+        other.create_dummy_head();
+
+        my_size = other.my_size.load();
+        other.my_size = 0;
+    }
+
+    static const key_type& get_key(node_ptr n) {
+        __TBB_ASSERT(n, NULL);
+        return traits_type::get_key(n->value());
+    }
+
+    template <typename K>
+    iterator internal_find(const K& key) {
+        iterator it = lower_bound(key);
+        return (it == end() || my_compare(key, traits_type::get_key(*it))) ? end() : it;
+    }
+
+    template <typename K>
+    const_iterator internal_find(const K& key) const {
+        const_iterator it = lower_bound(key);
+        return (it == end() || my_compare(key, traits_type::get_key(*it))) ? end() : it;
+    }
+
+    template <typename K>
+    size_type internal_count( const K& key ) const {
+        if (allow_multimapping) {
+            std::pair<const_iterator, const_iterator> range = equal_range(key);
+            return std::distance(range.first, range.second);
+        }
+        return (find(key) == end()) ? size_type(0) : size_type(1);
+    }
+
+    /**
+     * Finds position on the @param level using @param cmp
+     * @param level - on which level search prev node
+     * @param prev - pointer to the start node to search
+     * @param key - key to search
+     * @param cmp - callable object to compare two objects
+     *  (my_compare member is default comparator)
+     * @returns pointer to the node which is not satisfy the comparison with @param key
+     */
+    template <typename K, typename pointer_type, typename comparator>
+    pointer_type internal_find_position( size_type level, pointer_type& prev, const K& key,
+                                         const comparator& cmp) const {
+        __TBB_ASSERT(level < prev->height(), "Wrong level to find position");
+        pointer_type curr = prev->next(level);
+
+        while (curr && cmp(get_key(curr), key)) {
+            prev = curr;
+            __TBB_ASSERT(level < prev->height(), NULL);
+            curr = prev->next(level);
+        }
+
+        return curr;
+    }
+
+    template <typename comparator>
+    void fill_prev_next_arrays(array_type& prev_nodes, array_type& next_nodes, node_ptr prev, const key_type& key,
+                               const comparator& cmp) {
+        prev_nodes.fill(dummy_head);
+        next_nodes.fill(nullptr);
+
+        for (size_type h = prev->height(); h > 0; --h) {
+            node_ptr next = internal_find_position(h - 1, prev, key, cmp);
+            prev_nodes[h - 1] = prev;
+            next_nodes[h - 1] = next;
+        }
+    }
+
+    template <typename comparator>
+    void fill_prev_next_by_ptr(array_type& prev_nodes, array_type& next_nodes, const_iterator it, const key_type& key,
+                               const comparator& cmp) {
+        node_ptr prev = dummy_head;
+        node_ptr erase_node = it.my_node_ptr;
+        size_type node_height = erase_node->height();
+
+        for (size_type h = prev->height(); h >= node_height; --h) {
+            internal_find_position(h - 1, prev, key, cmp);
+        }
+
+        for (size_type h = node_height; h > 0; --h) {
+            node_ptr curr = prev->next(h - 1);
+            while (const_iterator(curr) != it) {
+                prev = curr;
+                curr = prev->next(h - 1);
+            }
+            prev_nodes[h - 1] = prev;
+        }
+
+        std::fill(next_nodes.begin(), next_nodes.begin() + node_height, erase_node);
+    }
+
+    template<typename... Args>
+    std::pair<iterator, bool> internal_insert(Args&&... args) {
+        node_ptr new_node = create_node(std::forward<Args>(args)...);
+        std::pair<iterator, bool> insert_result = internal_insert_node(new_node);
+        if(!insert_result.second) {
+            delete_node(new_node);
+        }
+        return insert_result;
+    }
+
+    std::pair<iterator, bool> internal_insert_node(node_ptr new_node) {
+        array_type prev_nodes;
+        array_type next_nodes;
+        __TBB_ASSERT(dummy_head->height() >= new_node->height(), "Wrong height for new node");
+
+        do {
+            if (allow_multimapping) {
+                fill_prev_next_arrays(prev_nodes, next_nodes, dummy_head, get_key(new_node),
+                                      not_greater_compare(my_compare));
+            } else {
+                fill_prev_next_arrays(prev_nodes, next_nodes, dummy_head, get_key(new_node), my_compare);
+            }
+
+            node_ptr next = next_nodes[0];
+            if (next && !allow_multimapping && !my_compare(get_key(new_node), get_key(next))) {
+                // TODO: do we really need to wait?
+                while (!next->fully_linked()) {
+                    // TODO: atomic backoff
+                }
+
+                return std::pair<iterator, bool>(iterator(next), false);
+            }
+            __TBB_ASSERT(allow_multimapping || !next || my_compare(get_key(new_node), get_key(next)),
+                         "Wrong elements order");
+
+        } while (!try_insert_node(new_node, prev_nodes, next_nodes));
+
+        __TBB_ASSERT(new_node, NULL);
+        return std::pair<iterator, bool>(iterator(new_node), true);
+    }
+
+    bool try_insert_node(node_ptr new_node, array_type& prev_nodes, array_type& next_nodes) {
+        __TBB_ASSERT(dummy_head->height() >= new_node->height(), NULL);
+
+        lock_array locks;
+
+        if (!try_lock_nodes(new_node->height(), prev_nodes, next_nodes, locks)) {
+            return false;
+        }
+
+        __TBB_ASSERT(allow_multimapping ||
+                    ((prev_nodes[0] == dummy_head ||
+                      my_compare(get_key(prev_nodes[0]), get_key(new_node))) &&
+                      (next_nodes[0] == nullptr || my_compare(get_key(new_node), get_key(next_nodes[0])))),
+                    "Wrong elements order");
+
+        for (size_type level = 0; level < new_node->height(); ++level) {
+            __TBB_ASSERT(prev_nodes[level]->height() > level, NULL);
+            __TBB_ASSERT(prev_nodes[level]->next(level) == next_nodes[level], NULL);
+            new_node->set_next(level, next_nodes[level]);
+            prev_nodes[level]->set_next(level, new_node);
+        }
+        new_node->mark_linked();
+
+        ++my_size;
+
+        return true;
+    }
+
+    bool try_lock_nodes(size_type height, array_type& prevs, array_type& next_nodes, lock_array& locks) {
+        for (size_type l = 0; l < height; ++l) {
+            if (l == 0 || prevs[l] != prevs[l - 1])
+                locks[l] = prevs[l]->acquire();
+
+            node_ptr next = prevs[l]->next(l);
+            if ( next != next_nodes[l]) return false;
+        }
+
+        return true;
+    }
+
+    template <typename K, typename comparator>
+    const_iterator internal_get_bound(const K& key, const comparator& cmp) const {
+        node_ptr prev = dummy_head;
+        __TBB_ASSERT(dummy_head->height() > 0, NULL);
+        node_ptr next = nullptr;
+
+        for (size_type h = prev->height(); h > 0; --h) {
+            next = internal_find_position(h - 1, prev, key, cmp);
+        }
+
+        return const_iterator(next);
+    }
+
+    template <typename K, typename comparator>
+    iterator internal_get_bound(const K& key, const comparator& cmp){
+        node_ptr prev = dummy_head;
+        __TBB_ASSERT(dummy_head->height() > 0, NULL);
+        node_ptr next = nullptr;
+
+        for (size_type h = prev->height(); h > 0; --h) {
+            next = internal_find_position(h - 1, prev, key, cmp);
+        }
+
+        return iterator(next);
+    }
+
+    // Returns node_ptr to the extracted node and node_ptr to the next node after the extracted
+    std::pair<node_ptr, node_ptr> internal_extract(const_iterator it) {
+        if ( it != end() ) {
+            key_type key = traits_type::get_key(*it);
+            __TBB_ASSERT(dummy_head->height() > 0, NULL);
+
+            array_type prev_nodes;
+            array_type next_nodes;
+
+            fill_prev_next_by_ptr(prev_nodes, next_nodes, it, key, my_compare);
+
+            node_ptr erase_node = next_nodes[0];
+            __TBB_ASSERT(erase_node != nullptr, NULL);
+            node_ptr next_node = erase_node->next(0);
+
+            if (!my_compare(key, get_key(erase_node))) {
+                for(size_type level = 0; level < erase_node->height(); ++level) {
+                    __TBB_ASSERT(prev_nodes[level]->height() > level, NULL);
+                    __TBB_ASSERT(next_nodes[level] == erase_node, NULL);
+                    prev_nodes[level]->set_next(level, erase_node->next(level));
+                }
+                --my_size;
+                return std::pair<node_ptr, node_ptr>(erase_node, next_node);
+            }
+        }
+        return std::pair<node_ptr, node_ptr>(nullptr, nullptr);
+    }
+
+protected:
+    template<typename SourceType>
+    void internal_merge(SourceType&& source) {
+        using source_type = typename std::decay<SourceType>::type;
+        using source_iterator = typename source_type::iterator;
+        __TBB_STATIC_ASSERT((std::is_same<node_type, typename source_type::node_type>::value), "Incompatible containers cannot be merged");
+
+        for(source_iterator it = source.begin(); it != source.end();) {
+            source_iterator where = it++;
+            if (allow_multimapping || !contains(traits_type::get_key(*where))) {
+                std::pair<node_ptr, node_ptr> extract_result = source.internal_extract(where);
+
+                //If the insertion fails - return the node into source
+                node_type handle(extract_result.first);
+                __TBB_ASSERT(!handle.empty(), "Extracted handle in merge is empty");
+
+                if (!insert(std::move(handle)).second) {
+                    source.insert(std::move(handle));
+                }
+                handle.deactivate();
+            }
+        }
+    }
+
+private:
+    void internal_copy(const concurrent_skip_list& other) {
+        internal_copy(other.begin(), other.end());
+    }
+
+    template<typename Iterator>
+    void internal_copy(Iterator first, Iterator last) {
+        clear();
+        try {
+            for (auto it = first; it != last; ++it)
+                insert(*it);
+        }
+        catch (...) {
+            clear();
+            delete_dummy_head();
+            throw;
+        }
+    }
+
+    /** Generate random level */
+    size_type random_level() {
+        return my_rnd_generator();
+    }
+
+    static size_type calc_node_size(size_type height) {
+        return sizeof(list_node_type) + height*sizeof(typename list_node_type::atomic_node_pointer);
+    }
+
+    /** Creates new node */
+    template <typename... Args>
+    node_ptr create_node(Args&&... args) {
+        size_type levels = random_level();
+
+        size_type sz = calc_node_size(levels);
+
+        node_ptr node = reinterpret_cast<node_ptr>(node_allocator_traits::allocate(my_node_allocator, sz));
+
+        try {
+            node_allocator_traits::construct(my_node_allocator, node, levels);
+
+        }
+        catch(...) {
+            deallocate_node(node, sz);
+            throw;
+        }
+
+        try {
+            node_allocator_traits::construct(my_node_allocator, node->storage(), std::forward<Args>(args)...);
+        }
+        catch (...) {
+            node_allocator_traits::destroy(my_node_allocator, node);
+            deallocate_node(node, sz);
+            throw;
+        }
+
+        return node;
+    }
+
+    void create_dummy_head() {
+        size_type sz = calc_node_size(MAX_LEVEL);
+
+        dummy_head = reinterpret_cast<node_ptr>(node_allocator_traits::allocate(my_node_allocator, sz));
+        // TODO: investigate linkage fail in debug without this workaround
+        auto max_level = MAX_LEVEL;
+
+        try {
+            node_allocator_traits::construct(my_node_allocator, dummy_head, max_level);
+        }
+        catch(...) {
+            deallocate_node(dummy_head, sz);
+            throw;
+        }
+    }
+
+    template <bool is_dummy = false>
+    void delete_node(node_ptr node) {
+        size_type sz = calc_node_size(node->height());
+        // Destroy value
+        if (!is_dummy) node_allocator_traits::destroy(my_node_allocator, node->storage());
+        // Destroy node
+        node_allocator_traits::destroy(my_node_allocator, node);
+        // Deallocate memory
+        deallocate_node(node, sz);
+    }
+
+    void deallocate_node(node_ptr node, size_type sz) {
+        node_allocator_traits::deallocate(my_node_allocator, reinterpret_cast<uint8_t*>(node), sz);
+    }
+
+    void delete_dummy_head() {
+        delete_node<true>(dummy_head);
+    }
+
+    static iterator get_iterator(const_iterator it) {
+        return iterator(it.my_node_ptr);
+    }
+
+    void internal_move_assign(concurrent_skip_list&& other, /*POCMA=*/std::true_type) {
+        delete_dummy_head();
+        tbb::internal::allocator_move_assignment(my_node_allocator, other.my_node_allocator, std::true_type());
+        internal_move(std::move(other));
+    }
+
+    void internal_move_assign(concurrent_skip_list&& other, /*POCMA=*/std::false_type) {
+        if (my_node_allocator == other.my_node_allocator) {
+            delete_dummy_head();
+            internal_move(std::move(other));
+        } else {
+            internal_copy(std::make_move_iterator(other.begin()), std::make_move_iterator(other.end()));
+        }
+    }
+
+    struct not_greater_compare {
+        const key_compare& my_less_compare;
+
+        not_greater_compare(const key_compare& less_compare) : my_less_compare(less_compare) {}
+
+        template <typename K1, typename K2>
+        bool operator()(const K1& first, const K2& second) const {
+            return !my_less_compare(second, first);
+        }
+    };
+
+    node_allocator_type my_node_allocator;
+    key_compare my_compare;
+    random_level_generator_type my_rnd_generator;
+    node_ptr dummy_head;
+
+    template<typename OtherTraits>
+    friend class concurrent_skip_list;
+
+    std::atomic<size_type> my_size;
+}; // class concurrent_skip_list
+
+template <size_t MAX_LEVEL>
+class concurrent_geometric_level_generator {
+public:
+    static constexpr size_t max_level = MAX_LEVEL;
+
+    concurrent_geometric_level_generator() : engines(time(NULL)) {}
+
+    size_t operator()() {
+        return (distribution(engines.local()) % MAX_LEVEL) + 1;
+    }
+
+private:
+    tbb::enumerable_thread_specific<std::mt19937_64> engines;
+    std::geometric_distribution<size_t> distribution;
+};
+
+} // namespace internal
+} // namespace interface10
+} // namespace tbb
+
+#endif // __TBB_concurrent_skip_list_H
diff --git a/inst/include/tbb/internal/_concurrent_unordered_impl.h b/inst/include/tbb/internal/_concurrent_unordered_impl.h
index 211a5c3d..b4bbefa5 100644
--- a/inst/include/tbb/internal/_concurrent_unordered_impl.h
+++ b/inst/include/tbb/internal/_concurrent_unordered_impl.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 /* Container implementations in this header are based on PPL implementations
@@ -29,12 +25,6 @@
 
 #include "../tbb_stddef.h"
 
-#if !TBB_USE_EXCEPTIONS && _MSC_VER
-    // Suppress "C++ exception handler used, but unwind semantics are not enabled" warning in STL headers
-    #pragma warning (push)
-    #pragma warning (disable: 4530)
-#endif
-
 #include <iterator>
 #include <utility>      // Need std::pair
 #include <functional>   // Need std::equal_to (in ../concurrent_unordered_*.h)
@@ -42,10 +32,6 @@
 #include <cstring>      // Need std::memset
 #include __TBB_STD_SWAP_HEADER
 
-#if !TBB_USE_EXCEPTIONS && _MSC_VER
-    #pragma warning (pop)
-#endif
-
 #include "../atomic.h"
 #include "../tbb_exception.h"
 #include "../tbb_allocator.h"
@@ -54,7 +40,17 @@
     #include <initializer_list>
 #endif
 
+#if __TBB_CPP11_RVALUE_REF_PRESENT && !__TBB_IMPLICIT_COPY_DELETION_BROKEN
+    #define __TBB_UNORDERED_NODE_HANDLE_PRESENT 1
+#endif
+
+#include "_allocator_traits.h"
 #include "_tbb_hash_compare_impl.h"
+#include "_template_helpers.h"
+
+#if __TBB_UNORDERED_NODE_HANDLE_PRESENT
+#include "_node_handle_impl.h"
+#endif // __TBB_UNORDERED_NODE_HANDLE_PRESENT
 
 namespace tbb {
 namespace interface5 {
@@ -88,6 +84,11 @@ class flist_iterator : public std::iterator<std::forward_iterator_tag, Value>
     flist_iterator( const flist_iterator<Solist, typename Solist::value_type> &other )
         : my_node_ptr(other.my_node_ptr) {}
 
+    flist_iterator& operator=( const flist_iterator<Solist, typename Solist::value_type> &other ) {
+        my_node_ptr = other.my_node_ptr;
+        return *this;
+    }
+
     reference operator*() const { return my_node_ptr->my_element; }
     pointer operator->() const { return &**this; }
 
@@ -134,6 +135,8 @@ class solist_iterator : public flist_iterator<Solist, Value>
     friend class split_ordered_list;
     template<class M, typename V>
     friend class solist_iterator;
+    template <typename Traits>
+    friend class concurrent_unordered_base;
     template<typename M, typename T, typename U>
     friend bool operator==( const solist_iterator<M,T> &i, const solist_iterator<M,U> &j );
     template<typename M, typename T, typename U>
@@ -149,9 +152,15 @@ class solist_iterator : public flist_iterator<Solist, Value>
     typedef typename Solist::reference reference;
 
     solist_iterator() {}
-    solist_iterator(const solist_iterator<Solist, typename Solist::value_type> &other )
+    solist_iterator( const solist_iterator<Solist, typename Solist::value_type> &other )
         : base_type(other), my_list_ptr(other.my_list_ptr) {}
 
+    solist_iterator& operator=( const solist_iterator<Solist, typename Solist::value_type> &other ) {
+        base_type::my_node_ptr = other.get_node_ptr();
+        my_list_ptr = other.my_list_ptr;
+        return *this;
+    }
+
     reference operator*() const {
         return this->base_type::operator*();
     }
@@ -195,17 +204,20 @@ class split_ordered_list
 {
 public:
     typedef split_ordered_list<T, Allocator> self_type;
-    typedef typename Allocator::template rebind<T>::other allocator_type;
+
+    typedef typename tbb::internal::allocator_rebind<Allocator, T>::type allocator_type;
+
     struct node;
     typedef node *nodeptr_t;
 
-    typedef typename allocator_type::size_type size_type;
-    typedef typename allocator_type::difference_type difference_type;
-    typedef typename allocator_type::pointer pointer;
-    typedef typename allocator_type::const_pointer const_pointer;
-    typedef typename allocator_type::reference reference;
-    typedef typename allocator_type::const_reference const_reference;
-    typedef typename allocator_type::value_type value_type;
+    typedef typename tbb::internal::allocator_traits<allocator_type>::value_type value_type;
+    typedef typename tbb::internal::allocator_traits<allocator_type>::size_type size_type;
+    typedef typename tbb::internal::allocator_traits<allocator_type>::difference_type difference_type;
+    typedef typename tbb::internal::allocator_traits<allocator_type>::pointer pointer;
+    typedef typename tbb::internal::allocator_traits<allocator_type>::const_pointer const_pointer;
+    // No support for reference/const_reference in allocator traits
+    typedef value_type& reference;
+    typedef const value_type& const_reference;
 
     typedef solist_iterator<self_type, const value_type> const_iterator;
     typedef solist_iterator<self_type, value_type> iterator;
@@ -230,6 +242,15 @@ class split_ordered_list
             return my_order_key;
         }
 
+        // get() and value() is a common interface for getting access to node`s element (required by node_handle)
+        value_type* storage() {
+            return reinterpret_cast<value_type*>(&my_element);
+        }
+
+        value_type& value() {
+        return *storage();
+        }
+
         // Inserts the new element in the list in an atomic fashion
         nodeptr_t atomic_set_next(nodeptr_t new_node, nodeptr_t current_node)
         {
@@ -574,27 +595,49 @@ class split_ordered_list
 
     }
 
-    // This erase function can handle both real and dummy nodes
-    void erase_node(raw_iterator previous, raw_const_iterator& where)
-    {
+    nodeptr_t  erase_node_impl(raw_iterator previous, raw_const_iterator& where) {
         nodeptr_t pnode = (where++).get_node_ptr();
         nodeptr_t prevnode = previous.get_node_ptr();
         __TBB_ASSERT(prevnode->my_next == pnode, "Erase must take consecutive iterators");
         prevnode->my_next = pnode->my_next;
+        return pnode;
+    }
 
+    // This erase function can handle both real and dummy nodes
+    void erase_node(raw_iterator previous, raw_const_iterator& where,
+                    /*allow_destroy*/tbb::internal::true_type)
+    {
+        nodeptr_t pnode = erase_node_impl(previous, where);
         destroy_node(pnode);
     }
 
+    void erase_node(raw_iterator previous, raw_const_iterator& where,
+                    /*allow_destroy*/tbb::internal::false_type)
+    {
+        erase_node_impl(previous, where);
+    }
+
+    void erase_node(raw_iterator previous, raw_const_iterator& where) {
+        erase_node(previous, where, /*allow_destroy*/tbb::internal::true_type());
+    }
+
     // Erase the element (previous node needs to be passed because this is a forward only list)
-    iterator erase_node(raw_iterator previous, const_iterator where)
+    template<typename AllowDestroy>
+    iterator erase_node(raw_iterator previous, const_iterator where, AllowDestroy)
     {
         raw_const_iterator it = where;
-        erase_node(previous, it);
+        erase_node(previous, it, AllowDestroy());
         my_element_count--;
 
         return get_iterator(first_real_iterator(it));
     }
 
+    iterator erase_node(raw_iterator previous, const_iterator& where) {
+        return erase_node(previous, where, /*allow_destroy*/tbb::internal::true_type());
+    }
+
+
+
     // Move all elements from the passed in split-ordered list to this one
     void move_all(self_type& source)
     {
@@ -649,7 +692,7 @@ class split_ordered_list
 #endif
     }
 
-    typename allocator_type::template rebind<node>::other my_node_allocator;  // allocator object for nodes
+    typename tbb::internal::allocator_rebind<allocator_type, node>::type my_node_allocator; // allocator object for nodes
     size_type                                             my_element_count;   // Total item count, not counting dummy nodes
     nodeptr_t                                             my_head;            // pointer to head node
 };
@@ -671,12 +714,15 @@ class concurrent_unordered_base : public Traits
     typedef typename Traits::allocator_type allocator_type;
     typedef typename hash_compare::hasher hasher;
     typedef typename hash_compare::key_equal key_equal;
-    typedef typename allocator_type::pointer pointer;
-    typedef typename allocator_type::const_pointer const_pointer;
-    typedef typename allocator_type::reference reference;
-    typedef typename allocator_type::const_reference const_reference;
-    typedef typename allocator_type::size_type size_type;
-    typedef typename allocator_type::difference_type difference_type;
+
+    typedef typename tbb::internal::allocator_traits<allocator_type>::size_type size_type;
+    typedef typename tbb::internal::allocator_traits<allocator_type>::difference_type difference_type;
+    typedef typename tbb::internal::allocator_traits<allocator_type>::pointer pointer;
+    typedef typename tbb::internal::allocator_traits<allocator_type>::const_pointer const_pointer;
+    // No support for reference/const_reference in allocator
+    typedef typename allocator_type::value_type& reference;
+    typedef const typename allocator_type::value_type& const_reference;
+
     typedef split_ordered_list<value_type, typename Traits::allocator_type> solist_t;
     typedef typename solist_t::nodeptr_t nodeptr_t;
     // Iterators that walk the entire split-order list, including dummy nodes
@@ -686,12 +732,19 @@ class concurrent_unordered_base : public Traits
     typedef typename solist_t::const_iterator const_iterator;
     typedef iterator local_iterator;
     typedef const_iterator const_local_iterator;
+#if __TBB_UNORDERED_NODE_HANDLE_PRESENT
+    typedef typename Traits::node_type node_type;
+#endif // __TBB_UNORDERED_NODE_HANDLE_PRESENT
     using Traits::my_hash_compare;
     using Traits::get_key;
     using Traits::allow_multimapping;
 
     static const size_type initial_bucket_number = 8;                               // Initial number of buckets
+
 private:
+    template<typename OtherTraits>
+    friend class concurrent_unordered_base;
+
     typedef std::pair<iterator, iterator> pairii_t;
     typedef std::pair<const_iterator, const_iterator> paircc_t;
 
@@ -737,8 +790,10 @@ class concurrent_unordered_base : public Traits
 
 #if __TBB_CPP11_RVALUE_REF_PRESENT
     concurrent_unordered_base(concurrent_unordered_base&& right)
-        : Traits(right.my_hash_compare), my_solist(right.get_allocator()), my_allocator(right.get_allocator())
+        : Traits(right.my_hash_compare), my_solist(right.get_allocator()), my_allocator(right.get_allocator()),
+          my_maximum_bucket_size(float(initial_bucket_load))
     {
+        my_number_of_buckets = initial_bucket_number;
         internal_init();
         swap(right);
     }
@@ -750,6 +805,8 @@ class concurrent_unordered_base : public Traits
 
         internal_init();
         if (a == right.get_allocator()){
+            my_number_of_buckets = initial_bucket_number;
+            my_maximum_bucket_size = float(initial_bucket_load);
             this->swap(right);
         }else{
             my_maximum_bucket_size = right.my_maximum_bucket_size;
@@ -830,6 +887,49 @@ class concurrent_unordered_base : public Traits
         internal_clear();
     }
 
+#if __TBB_UNORDERED_NODE_HANDLE_PRESENT
+    template<typename SourceType>
+    void internal_merge(SourceType& source) {
+        typedef typename SourceType::iterator source_iterator;
+        __TBB_STATIC_ASSERT((tbb::internal::is_same_type<node_type,
+                            typename SourceType::node_type>::value),
+                            "Incompatible containers cannot be merged");
+
+        for(source_iterator it = source.begin(); it != source.end();) {
+            source_iterator where = it++;
+            if (allow_multimapping || find(get_key(*where)) == end()) {
+                std::pair<node_type, raw_iterator> extract_result = source.internal_extract(where);
+
+                // Remember the old order key
+                sokey_t old_order_key = extract_result.first.my_node->get_order_key();
+
+                // If the insertion fails, it returns ownership of the node to extract_result.first
+                // extract_result.first remains valid node handle
+                if (!insert(std::move(extract_result.first)).second) {
+                    raw_iterator next = extract_result.second;
+                    raw_iterator current = next++;
+
+                    // Revert order key to old value
+                    extract_result.first.my_node->init(old_order_key);
+
+                    __TBB_ASSERT(extract_result.first.my_node->get_order_key() >= current.get_node_ptr()->get_order_key(),
+                                "Wrong nodes order in source container");
+                    __TBB_ASSERT(next==source.my_solist.raw_end() ||
+                                 extract_result.first.my_node->get_order_key() <= next.get_node_ptr()->get_order_key(),
+                                 "Wrong nodes order in source container");
+
+                    size_t new_count = 0;// To use try_insert()
+                    bool insert_result =
+                        source.my_solist.try_insert(current, next, extract_result.first.my_node, &new_count).second;
+                    __TBB_ASSERT_EX(insert_result, "Return to source must be successful. "
+                                                   "Changing source container while merging is unsafe.");
+                }
+                extract_result.first.deactivate();
+            }
+        }
+    }
+#endif // __TBB_UNORDERED_NODE_HANDLE_PRESENT
+
 public:
     allocator_type get_allocator() const {
         return my_solist.get_allocator();
@@ -966,7 +1066,8 @@ class concurrent_unordered_base : public Traits
 
     // Modifiers
     std::pair<iterator, bool> insert(const value_type& value) {
-        return internal_insert</*AllowCreate=*/tbb::internal::true_type>(value);
+        return internal_insert</*AllowCreate=*/tbb::internal::true_type,
+                               /*AllowDestroy=*/tbb::internal::true_type>(value);
     }
 
     iterator insert(const_iterator, const value_type& value) {
@@ -976,23 +1077,43 @@ class concurrent_unordered_base : public Traits
 
 #if __TBB_CPP11_RVALUE_REF_PRESENT
     std::pair<iterator, bool> insert(value_type&& value) {
-        return internal_insert</*AllowCreate=*/tbb::internal::true_type>(std::move(value));
+        return internal_insert</*AllowCreate=*/tbb::internal::true_type,
+                               /*AllowDestroy=*/tbb::internal::true_type>(std::move(value));
     }
 
     iterator insert(const_iterator, value_type&& value) {
         // Ignore hint
         return insert(std::move(value)).first;
     }
+#endif /*__TBB_CPP11_RVALUE_REF_PRESENT*/
+
+#if __TBB_UNORDERED_NODE_HANDLE_PRESENT
+    std::pair<iterator, bool> insert(node_type&& nh) {
+        if (!nh.empty()) {
+            nodeptr_t handled_node = nh.my_node;
+            std::pair<iterator, bool> insert_result =
+                                      internal_insert</*AllowCreate=*/tbb::internal::false_type,
+                                                      /*AllowDestroy=*/tbb::internal::false_type>
+                                                      (handled_node->my_element, handled_node);
+            if (insert_result.second)
+                nh.deactivate();
+            return insert_result;
+        }
+        return std::pair<iterator, bool>(end(), false);
+    }
 
-#if __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT
+    iterator insert(const_iterator, node_type&& nh) {
+        return insert(std::move(nh)).first;
+    }
+#endif // __TBB_UNORDERED_NODE_HANDLE_PRESENT
+
+#if __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT && __TBB_CPP11_RVALUE_REF_PRESENT
     template<typename... Args>
     std::pair<iterator, bool> emplace(Args&&... args) {
         nodeptr_t pnode = my_solist.create_node_v(tbb::internal::forward<Args>(args)...);
-        const sokey_t hashed_element_key = (sokey_t) my_hash_compare(get_key(pnode->my_element));
-        const sokey_t order_key = split_order_key_regular(hashed_element_key);
-        pnode->init(order_key);
 
-        return internal_insert</*AllowCreate=*/tbb::internal::false_type>(pnode->my_element, pnode);
+        return internal_insert</*AllowCreate=*/tbb::internal::false_type,
+                               /*AllowDestroy=*/tbb::internal::true_type>(pnode->my_element, pnode);
     }
 
     template<typename... Args>
@@ -1000,9 +1121,8 @@ class concurrent_unordered_base : public Traits
         // Ignore hint
         return emplace(tbb::internal::forward<Args>(args)...).first;
     }
+#endif // __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT && __TBB_CPP11_RVALUE_REF_PRESENT
 
-#endif // __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT
-#endif // __TBB_CPP11_RVALUE_REF_PRESENT
 
     template<class Iterator>
     void insert(Iterator first, Iterator last) {
@@ -1034,9 +1154,21 @@ class concurrent_unordered_base : public Traits
         return item_count;
     }
 
+#if __TBB_UNORDERED_NODE_HANDLE_PRESENT
+    node_type unsafe_extract(const_iterator where) {
+        return internal_extract(where).first;
+    }
+
+    node_type unsafe_extract(const key_type& key) {
+        pairii_t where = equal_range(key);
+        if (where.first == end()) return node_type(); // element was not found
+        return internal_extract(where.first).first;
+    }
+#endif // __TBB_UNORDERED_NODE_HANDLE_PRESENT
+
     void swap(concurrent_unordered_base& right) {
         if (this != &right) {
-            std::swap(my_hash_compare, right.my_hash_compare); // TODO: check what ADL meant here
+            std::swap(my_hash_compare, right.my_hash_compare);
             my_solist.swap(right.my_solist);
             internal_swap_buckets(right);
             std::swap(my_number_of_buckets, right.my_number_of_buckets);
@@ -1209,8 +1341,8 @@ class concurrent_unordered_base : public Traits
 
     // Initialize the hash and keep the first bucket open
     void internal_init() {
-        // Allocate an array of segment pointers
-        memset((void*) my_buckets, 0, pointers_per_table * sizeof(void *));
+        // Initialize the array of segment pointers
+        memset(my_buckets, 0, sizeof(my_buckets));
 
         // Initialize bucket 0
         raw_iterator dummy_node = my_solist.raw_begin();
@@ -1268,7 +1400,7 @@ class concurrent_unordered_base : public Traits
     }
 
     // Insert an element in the hash given its value
-    template<typename AllowCreate, typename ValueType>
+    template<typename AllowCreate, typename AllowDestroy, typename ValueType>
     std::pair<iterator, bool> internal_insert(__TBB_FORWARDING_REF(ValueType) value, nodeptr_t pnode = NULL)
     {
         const key_type *pkey = &get_key(value);
@@ -1279,6 +1411,11 @@ class concurrent_unordered_base : public Traits
         raw_iterator last = my_solist.raw_end();
         __TBB_ASSERT(previous != last, "Invalid head node");
 
+        if (pnode) {
+            // Set new order_key to node
+            pnode->init(order_key);
+        }
+
         // First node is a dummy node
         for (raw_iterator where = previous;;)
         {
@@ -1317,7 +1454,7 @@ class concurrent_unordered_base : public Traits
             else if (!allow_multimapping && solist_t::get_order_key(where) == order_key &&
                      !my_hash_compare(get_key(*where), *pkey)) // TODO: fix negation
             { // Element already in the list, return it
-                 if (pnode)
+                 if (pnode && AllowDestroy::value)
                      my_solist.destroy_node(pnode);
                 return std::pair<iterator, bool>(my_solist.get_iterator(where), false);
             }
@@ -1363,14 +1500,33 @@ class concurrent_unordered_base : public Traits
         __TBB_ASSERT(previous != last, "Invalid head node");
 
         // First node is a dummy node
-        for (raw_iterator where = previous; ; previous = where) {
+        for (raw_iterator where = previous; where != last; previous = where) {
             ++where;
-            if (where == last)
-                return end();
-            else if (my_solist.get_iterator(where) == it)
+            if (my_solist.get_iterator(where) == it)
                 return my_solist.erase_node(previous, it);
         }
+        return end();
+    }
+
+#if __TBB_UNORDERED_NODE_HANDLE_PRESENT
+    std::pair<node_type, raw_iterator> internal_extract(const_iterator it) {
+        sokey_t hash_key = sokey_t(my_hash_compare(get_key(*it)));
+        raw_iterator previous = prepare_bucket(hash_key);
+        raw_iterator last = my_solist.raw_end();
+        __TBB_ASSERT(previous != last, "Invalid head node");
+
+        for(raw_iterator where = previous; where != last; previous = where) {
+            ++where;
+            if (my_solist.get_iterator(where) == it) {
+                const_iterator result = it;
+                my_solist.erase_node(previous, it, /*allow_destroy*/tbb::internal::false_type());
+                return std::pair<node_type, raw_iterator>( node_type(result.get_node_ptr()),
+                                                           previous);
+            }
+        }
+        return std::pair<node_type, iterator>(node_type(), end());
     }
+#endif // __TBB_UNORDERED_NODE_HANDLE_PRESENT
 
     // Return the [begin, end) pair of iterators with the same key values.
     // This operation makes sense only if mapping is many-to-one.
@@ -1478,7 +1634,7 @@ class concurrent_unordered_base : public Traits
         if (my_buckets[segment] == NULL) {
             size_type sz = segment_size(segment);
             raw_iterator * new_segment = my_allocator.allocate(sz);
-            std::memset((void*) new_segment, 0, sz*sizeof(raw_iterator));
+            std::memset(static_cast<void*>(new_segment), 0, sz*sizeof(raw_iterator));
 
             if (my_buckets[segment].compare_and_swap( new_segment, NULL) != NULL)
                 my_allocator.deallocate(new_segment, sz);
@@ -1513,7 +1669,7 @@ class concurrent_unordered_base : public Traits
     // Shared variables
     atomic<size_type>                                             my_number_of_buckets;       // Current table size
     solist_t                                                      my_solist;                  // List where all the elements are kept
-    typename allocator_type::template rebind<raw_iterator>::other my_allocator;               // Allocator object for segments
+    typename tbb::internal::allocator_rebind<allocator_type, raw_iterator>::type my_allocator; // Allocator object for segments
     float                                                         my_maximum_bucket_size;     // Maximum size of the bucket
     atomic<raw_iterator*>                                         my_buckets[pointers_per_table]; // The segment table
 };
diff --git a/inst/include/tbb/internal/_deprecated_header_message_guard.h b/inst/include/tbb/internal/_deprecated_header_message_guard.h
new file mode 100644
index 00000000..fa993572
--- /dev/null
+++ b/inst/include/tbb/internal/_deprecated_header_message_guard.h
@@ -0,0 +1,69 @@
+/*
+    Copyright (c) 2005-2020 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 "tbb/tbb_config.h"
+
+#if (!defined(TBB_SUPPRESS_DEPRECATED_MESSAGES) || (TBB_SUPPRESS_DEPRECATED_MESSAGES == 0)) && !defined(__TBB_INTERNAL_INCLUDES_DEPRECATION_MESSAGE) && \
+!defined(__TBB_condition_variable_H_include_area) && \
+!defined(__TBB_ppl_H_include_area) && \
+!defined(__TBB_thread_H_include_area) && \
+!defined(__TBB_tuple_H_include_area) && \
+!defined(__TBB_aggregator_H_include_area) && \
+!defined(__TBB_aligned_space_H_include_area) && \
+!defined(__TBB_atomic_H_include_area) && \
+!defined(__TBB_combinable_H_include_area) && \
+!defined(__TBB_concurrent_hash_map_H_include_area) && \
+!defined(__TBB_concurrent_lru_cache_H_include_area) && \
+!defined(__TBB_concurrent_map_H_include_area) && \
+!defined(__TBB_concurrent_priority_queue_H_include_area) && \
+!defined(__TBB_concurrent_queue_H_include_area) && \
+!defined(__TBB_concurrent_set_H_include_area) && \
+!defined(__TBB_concurrent_unordered_map_H_include_area) && \
+!defined(__TBB_concurrent_unordered_set_H_include_area) && \
+!defined(__TBB_concurrent_vector_H_include_area) && \
+!defined(__TBB_critical_section_H_include_area) && \
+!defined(__TBB_enumerable_thread_specific_H_include_area) && \
+!defined(__TBB_flow_graph_opencl_node_H_include_area) && \
+!defined(__TBB_flow_graph_H_include_area) && \
+!defined(__TBB_mutex_H_include_area) && \
+!defined(__TBB_parallel_do_H_include_area) && \
+!defined(__TBB_parallel_for_H_include_area) && \
+!defined(__TBB_parallel_invoke_H_include_area) && \
+!defined(__TBB_parallel_reduce_H_include_area) && \
+!defined(__TBB_parallel_scan_H_include_area) && \
+!defined(__TBB_parallel_sort_H_include_area) && \
+!defined(__TBB_parallel_while_H_include_area) && \
+!defined(__TBB_partitioner_H_include_area) && \
+!defined(__TBB_pipeline_H_include_area) && \
+!defined(__TBB_queuing_mutex_H_include_area) && \
+!defined(__TBB_queuing_rw_mutex_H_include_area) && \
+!defined(__TBB_reader_writer_lock_H_include_area) && \
+!defined(__TBB_recursive_mutex_H_include_area) && \
+!defined(__TBB_runtime_loader_H_include_area) && \
+!defined(__TBB_task_scheduler_init_H_include_area) && \
+!defined(__TBB_spin_mutex_H_include_area) && \
+!defined(__TBB_task_arena_H_include_area) && \
+!defined(__TBB_task_group_H_include_area) && \
+!defined(__TBB_task_scheduler_observer_H_include_area) && \
+!defined(__TBB_task_H_include_area) && \
+!defined(__TBB_tbb_exception_H_include_area) && \
+!defined(__TBB_tbb_profiling_H_include_area) && \
+!defined(__TBB_tbb_thread_H_include_area) && \
+!defined(__TBB_tbb_H_include_area)
+
+#define __TBB_show_deprecated_header_message
+
+#endif
diff --git a/inst/include/tbb/internal/_flow_graph_async_msg_impl.h b/inst/include/tbb/internal/_flow_graph_async_msg_impl.h
index 7d2c3aef..9f269ffd 100644
--- a/inst/include/tbb/internal/_flow_graph_async_msg_impl.h
+++ b/inst/include/tbb/internal/_flow_graph_async_msg_impl.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB__flow_graph_async_msg_impl_H
@@ -25,101 +21,28 @@
 #error Do not #include this internal file directly; use public TBB headers instead.
 #endif
 
-// included in namespace tbb::flow::interfaceX (in flow_graph.h)
-
-template< typename T > class async_msg;
-
 namespace internal {
 
-template< typename T, typename = void >
-struct async_helpers {
-    typedef async_msg<T> async_type;
-    typedef T filtered_type;
-
-    static const bool is_async_type = false;
-
-    static const void* to_void_ptr(const T& t) {
-        return static_cast<const void*>(&t);
-    }
-
-    static void* to_void_ptr(T& t) {
-        return static_cast<void*>(&t);
-    }
-
-    static const T& from_void_ptr(const void* p) {
-        return *static_cast<const T*>(p);
-    }
-
-    static T& from_void_ptr(void* p) {
-        return *static_cast<T*>(p);
-    }
-
-    static task* try_put_task_wrapper_impl( receiver<T>* const this_recv, const void *p, bool is_async ) {
-        if ( is_async ) {
-            // This (T) is NOT async and incoming 'A<X> t' IS async
-            // Get data from async_msg
-            const async_msg<filtered_type>& msg = async_helpers< async_msg<filtered_type> >::from_void_ptr(p);
-            task* const new_task = msg.my_storage->subscribe(*this_recv);
-            // finalize() must be called after subscribe() because set() can be called in finalize()
-            // and 'this_recv' client must be subscribed by this moment
-            msg.finalize();
-            return new_task;
-        } else {
-            // Incoming 't' is NOT async
-            return this_recv->try_put_task( from_void_ptr(p) );
-        }
-    }
-};
-
-template< typename T >
-struct async_helpers< T, typename std::enable_if< std::is_base_of<async_msg<typename T::async_msg_data_type>, T>::value >::type > {
-    typedef T async_type;
-    typedef typename T::async_msg_data_type filtered_type;
-
-    static const bool is_async_type = true;
-
-    // Receiver-classes use const interfaces
-    static const void* to_void_ptr(const T& t) {
-        return static_cast<const void*>( &static_cast<const async_msg<filtered_type>&>(t) );
-    }
-
-    static void* to_void_ptr(T& t) {
-        return static_cast<void*>( &static_cast<async_msg<filtered_type>&>(t) );
-    }
-
-    // Sender-classes use non-const interfaces
-    static const T& from_void_ptr(const void* p) {
-        return *static_cast<const T*>( static_cast<const async_msg<filtered_type>*>(p) );
-    }
-
-    static T& from_void_ptr(void* p) {
-        return *static_cast<T*>( static_cast<async_msg<filtered_type>*>(p) );
-    }
-
-    // Used in receiver<T> class
-    static task* try_put_task_wrapper_impl(receiver<T>* const this_recv, const void *p, bool is_async) {
-        if ( is_async ) {
-            // Both are async
-            return this_recv->try_put_task( from_void_ptr(p) );
-        } else {
-            // This (T) is async and incoming 'X t' is NOT async
-            // Create async_msg for X
-            const filtered_type& t = async_helpers<filtered_type>::from_void_ptr(p);
-            const T msg(t);
-            return this_recv->try_put_task(msg);
-        }
-    }
-};
-
 template <typename T>
 class async_storage {
 public:
     typedef receiver<T> async_storage_client;
 
-    async_storage() { my_data_ready.store<tbb::relaxed>(false); }
+    async_storage() : my_graph(nullptr) {
+        my_data_ready.store<tbb::relaxed>(false);
+    }
+
+    ~async_storage() {
+        // Release reference to the graph if async_storage
+        // was destructed before set() call
+        if (my_graph) {
+            my_graph->release_wait();
+            my_graph = nullptr;
+        }
+    }
 
     template<typename C>
-    async_storage(C&& data) : my_data( std::forward<C>(data) ) {
+    async_storage(C&& data) : my_graph(nullptr), my_data( std::forward<C>(data) ) {
         using namespace tbb::internal;
         __TBB_STATIC_ASSERT( (is_same_type<typename strip<C>::type, typename strip<T>::type>::value), "incoming type must be T" );
 
@@ -148,10 +71,16 @@ class async_storage {
             (*it)->try_put(my_data);
         }
 
+        // Data was sent, release reference to the graph
+        if (my_graph) {
+            my_graph->release_wait();
+            my_graph = nullptr;
+        }
+
         return true;
     }
 
-    task* subscribe(async_storage_client& client) {
+    task* subscribe(async_storage_client& client, graph& g) {
         if (! my_data_ready.load<tbb::acquire>())
         {
             tbb::spin_mutex::scoped_lock locker(my_mutex);
@@ -163,6 +92,10 @@ class async_storage {
                 }
 #endif // TBB_USE_ASSERT
 
+                // Increase graph lifetime
+                my_graph = &g;
+                my_graph->reserve_wait();
+
                 // Subscribe
                 my_clients.push_back(&client);
                 return SUCCESSFULLY_ENQUEUED;
@@ -174,11 +107,10 @@ class async_storage {
     }
 
 private:
+    graph* my_graph;
     tbb::spin_mutex my_mutex;
-
     tbb::atomic<bool> my_data_ready;
     T my_data;
-
     typedef std::vector<async_storage_client*> subscriber_list_type;
     subscriber_list_type my_clients;
 };
@@ -186,7 +118,7 @@ class async_storage {
 } // namespace internal
 
 template <typename T>
-class async_msg {
+class __TBB_DEPRECATED async_msg {
     template< typename > friend class receiver;
     template< typename, typename > friend struct internal::async_helpers;
 public:
diff --git a/inst/include/tbb/internal/_flow_graph_body_impl.h b/inst/include/tbb/internal/_flow_graph_body_impl.h
index 54f37411..e75f50da 100644
--- a/inst/include/tbb/internal/_flow_graph_body_impl.h
+++ b/inst/include/tbb/internal/_flow_graph_body_impl.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,15 +12,13 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB__flow_graph_body_impl_H
 #define __TBB__flow_graph_body_impl_H
 
+#include "tbb/internal/_template_helpers.h"
+
 #ifndef __TBB_flow_graph_H
 #error Do not #include this internal file directly; use public TBB headers instead.
 #endif
@@ -33,11 +31,46 @@ typedef tbb::internal::uint64_t tag_value;
 
 using tbb::internal::strip;
 
+#if __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT
+
+template<typename ... Policies> struct Policy {};
+
+template<typename ... Policies> struct has_policy;
+
+template<typename ExpectedPolicy, typename FirstPolicy, typename ...Policies>
+struct has_policy<ExpectedPolicy, FirstPolicy, Policies...> :
+    tbb::internal::bool_constant<has_policy<ExpectedPolicy, FirstPolicy>::value ||
+                                 has_policy<ExpectedPolicy, Policies...>::value> {};
+
+template<typename ExpectedPolicy, typename SinglePolicy>
+struct has_policy<ExpectedPolicy, SinglePolicy> :
+    tbb::internal::bool_constant<tbb::internal::is_same_type<ExpectedPolicy, SinglePolicy>::value> {};
+
+template<typename ExpectedPolicy, typename ...Policies>
+struct has_policy<ExpectedPolicy, Policy<Policies...> > : has_policy<ExpectedPolicy, Policies...> {};
+
+#else
+
+template<typename P1, typename P2 = void> struct Policy {};
+
+template<typename ExpectedPolicy, typename SinglePolicy>
+struct has_policy : tbb::internal::bool_constant<tbb::internal::is_same_type<ExpectedPolicy, SinglePolicy>::value> {};
+
+template<typename ExpectedPolicy, typename P>
+struct has_policy<ExpectedPolicy, Policy<P> > : has_policy<ExpectedPolicy, P> {};
+
+template<typename ExpectedPolicy, typename P1, typename P2>
+struct has_policy<ExpectedPolicy, Policy<P1, P2> > :
+    tbb::internal::bool_constant<has_policy<ExpectedPolicy, P1>::value || has_policy<ExpectedPolicy, P2>::value> {};
+
+#endif
+
 namespace graph_policy_namespace {
 
     struct rejecting { };
     struct reserving { };
     struct queueing  { };
+    struct lightweight  { };
 
     // K == type of field used for key-matching.  Each tag-matching port will be provided
     // functor that, given an object accepted by the port, will return the
@@ -52,11 +85,68 @@ namespace graph_policy_namespace {
     // old tag_matching join's new specifier
     typedef key_matching<tag_value> tag_matching;
 
+    // Aliases for Policy combinations
+    typedef interface11::internal::Policy<queueing, lightweight> queueing_lightweight;
+    typedef interface11::internal::Policy<rejecting, lightweight>  rejecting_lightweight;
+
 } // namespace graph_policy_namespace
 
 // -------------- function_body containers ----------------------
-
 //! A functor that takes no input and generates a value of type Output
+template< typename Output >
+class input_body : tbb::internal::no_assign {
+public:
+    virtual ~input_body() {}
+
+#if TBB_DEPRECATED_INPUT_NODE_BODY
+    virtual bool operator()(Output &output) = 0;
+#else
+    virtual Output operator()(flow_control& fc) = 0;
+#endif
+    virtual input_body* clone() = 0;
+};
+
+template <typename Body>
+void check_input_node_body_input_type_impl(Body) {
+    __TBB_STATIC_ASSERT((tbb::internal::is_same_type<typename tbb::internal::body_arg_detector<Body>::arg_type, flow_control&>::value),
+        "TBB Warning: input_node body requirements have been changed."
+        "To temporarily enforce deprecated API specify TBB_DEPRECATED_INPUT_NODE_BODY.");
+}
+
+template <typename Body>
+void check_input_node_body_input_type(Body) {
+    check_input_node_body_input_type_impl(&Body::operator());
+}
+
+template <typename ReturnType, typename T>
+void check_input_node_body_input_type(ReturnType(*)(T)) {
+    __TBB_STATIC_ASSERT((tbb::internal::is_same_type<T, flow_control&>::value),
+        "TBB Warning: input_node body requirements have been changed."
+        "To temporarily enforce deprecated API specify TBB_DEPRECATED_INPUT_NODE_BODY.");
+}
+
+//! The leaf for input_body
+template< typename Output, typename Body>
+class input_body_leaf : public input_body<Output> {
+public:
+    input_body_leaf( const Body &_body ) : body(_body) { }
+
+#if TBB_DEPRECATED_INPUT_NODE_BODY
+    bool operator()(Output &output) __TBB_override { return body( output ); }
+#else
+    Output operator()(flow_control& fc) __TBB_override {
+        check_input_node_body_input_type(body);
+        return body(fc);
+    }
+#endif
+    input_body_leaf* clone() __TBB_override {
+        return new input_body_leaf< Output, Body >(body);
+    }
+    Body get_body() { return body; }
+private:
+    Body body;
+};
+
 template< typename Output >
 class source_body : tbb::internal::no_assign {
 public:
@@ -70,10 +160,13 @@ template< typename Output, typename Body>
 class source_body_leaf : public source_body<Output> {
 public:
     source_body_leaf( const Body &_body ) : body(_body) { }
+
     bool operator()(Output &output) __TBB_override { return body( output ); }
+
     source_body_leaf* clone() __TBB_override {
         return new source_body_leaf< Output, Body >(body);
     }
+
     Body get_body() { return body; }
 private:
     Body body;
@@ -232,13 +325,20 @@ class type_to_key_function_body_leaf<Input,Output&,B> : public type_to_key_funct
 
 //! A task that calls a node's forward_task function
 template< typename NodeType >
-class forward_task_bypass : public task {
+class forward_task_bypass : public graph_task {
 
     NodeType &my_node;
 
 public:
 
-    forward_task_bypass( NodeType &n ) : my_node(n) {}
+    forward_task_bypass( NodeType &n
+#if __TBB_PREVIEW_FLOW_GRAPH_PRIORITIES
+                         , node_priority_t node_priority = no_priority
+    ) : graph_task(node_priority),
+#else
+    ) :
+#endif
+    my_node(n) {}
 
     task *execute() __TBB_override {
         task * new_task = my_node.forward_task();
@@ -250,14 +350,21 @@ class forward_task_bypass : public task {
 //! A task that calls a node's apply_body_bypass function, passing in an input of type Input
 //  return the task* unless it is SUCCESSFULLY_ENQUEUED, in which case return NULL
 template< typename NodeType, typename Input >
-class apply_body_task_bypass : public task {
+class apply_body_task_bypass : public graph_task {
 
     NodeType &my_node;
     Input my_input;
 
 public:
 
-    apply_body_task_bypass( NodeType &n, const Input &i ) : my_node(n), my_input(i) {}
+    apply_body_task_bypass( NodeType &n, const Input &i
+#if __TBB_PREVIEW_FLOW_GRAPH_PRIORITIES
+                            , node_priority_t node_priority = no_priority
+    ) : graph_task(node_priority),
+#else
+    ) :
+#endif
+        my_node(n), my_input(i) {}
 
     task *execute() __TBB_override {
         task * next_task = my_node.apply_body_bypass( my_input );
@@ -268,7 +375,7 @@ class apply_body_task_bypass : public task {
 
 //! A task that calls a node's apply_body_bypass function with no input
 template< typename NodeType >
-class source_task_bypass : public task {
+class source_task_bypass : public graph_task {
 
     NodeType &my_node;
 
@@ -291,18 +398,90 @@ struct empty_body {
     Output operator()( const Input & ) const { return Output(); }
 };
 
+template<typename T, typename DecrementType, typename DummyType = void>
+class decrementer;
+
+template<typename T, typename DecrementType>
+class decrementer<T, DecrementType,
+                  typename tbb::internal::enable_if<
+                      tbb::internal::is_integral<DecrementType>::value, void>::type
+                  > : public receiver<DecrementType>, tbb::internal::no_copy {
+    T* my_node;
+protected:
+
+    task* try_put_task( const DecrementType& value ) __TBB_override {
+        task* result = my_node->decrement_counter( value );
+        if( !result )
+            result = SUCCESSFULLY_ENQUEUED;
+        return result;
+    }
+
+    graph& graph_reference() const __TBB_override {
+        return my_node->my_graph;
+    }
+
+    template<typename U, typename V> friend class tbb::flow::interface11::limiter_node;
+    void reset_receiver( reset_flags f ) __TBB_override {
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
+        if (f & rf_clear_edges)
+            my_built_predecessors.clear();
+#else
+        tbb::internal::suppress_unused_warning( f );
+#endif
+    }
+
+public:
+    // Since decrementer does not make use of possibly unconstructed owner inside its
+    // constructor, my_node can be directly initialized with 'this' pointer passed from the
+    // owner, hence making method 'set_owner' needless.
+    decrementer() : my_node(NULL) {}
+    void set_owner( T *node ) { my_node = node; }
+
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
+    spin_mutex my_mutex;
+    //! The predecessor type for this node
+    typedef typename receiver<DecrementType>::predecessor_type predecessor_type;
+
+    typedef internal::edge_container<predecessor_type> built_predecessors_type;
+    typedef typename built_predecessors_type::edge_list_type predecessor_list_type;
+    built_predecessors_type &built_predecessors() __TBB_override { return my_built_predecessors; }
+
+    void internal_add_built_predecessor( predecessor_type &s) __TBB_override {
+        spin_mutex::scoped_lock l(my_mutex);
+        my_built_predecessors.add_edge( s );
+    }
+
+    void internal_delete_built_predecessor( predecessor_type &s) __TBB_override {
+        spin_mutex::scoped_lock l(my_mutex);
+        my_built_predecessors.delete_edge(s);
+    }
+
+    void copy_predecessors( predecessor_list_type &v) __TBB_override {
+        spin_mutex::scoped_lock l(my_mutex);
+        my_built_predecessors.copy_edges(v);
+    }
+
+    size_t predecessor_count() __TBB_override {
+        spin_mutex::scoped_lock l(my_mutex);
+        return my_built_predecessors.edge_count();
+    }
+protected:
+    built_predecessors_type my_built_predecessors;
+#endif  /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
+};
+
 template<typename T>
-class decrementer : public continue_receiver, tbb::internal::no_copy {
+class decrementer<T, continue_msg, void> : public continue_receiver, tbb::internal::no_copy {
 
     T *my_node;
 
     task *execute() __TBB_override {
-        return my_node->decrement_counter();
+        return my_node->decrement_counter( 1 );
     }
 
 protected:
 
-    graph& graph_reference() __TBB_override {
+    graph& graph_reference() const __TBB_override {
         return my_node->my_graph;
     }
 
@@ -310,7 +489,15 @@ class decrementer : public continue_receiver, tbb::internal::no_copy {
 
     typedef continue_msg input_type;
     typedef continue_msg output_type;
-    decrementer( int number_of_predecessors = 0 ) : continue_receiver( number_of_predecessors ) { }
+    decrementer( int number_of_predecessors = 0 )
+        : continue_receiver(
+            __TBB_FLOW_GRAPH_PRIORITY_ARG1(number_of_predecessors, tbb::flow::internal::no_priority)
+        )
+          // Since decrementer does not make use of possibly unconstructed owner inside its
+          // constructor, my_node can be directly initialized with 'this' pointer passed from the
+          // owner, hence making method 'set_owner' needless.
+        , my_node(NULL)
+    {}
     void set_owner( T *node ) { my_node = node; }
 };
 
diff --git a/inst/include/tbb/internal/_flow_graph_cache_impl.h b/inst/include/tbb/internal/_flow_graph_cache_impl.h
index 7fac84e8..b670ae65 100644
--- a/inst/include/tbb/internal/_flow_graph_cache_impl.h
+++ b/inst/include/tbb/internal/_flow_graph_cache_impl.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB__flow_graph_cache_impl_H
@@ -57,12 +53,12 @@ class node_cache {
 
     void clear() {
         while( !my_q.empty()) (void)my_q.pop();
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
         my_built_predecessors.clear();
 #endif
     }
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
     typedef edge_container<T> built_predecessors_type;
     built_predecessors_type &built_predecessors() { return my_built_predecessors; }
 
@@ -86,14 +82,14 @@ class node_cache {
         typename mutex_type::scoped_lock lock(my_mutex);
         return (size_t)(my_built_predecessors.edge_count());
     }
-#endif  /* TBB_PREVIEW_FLOW_GRAPH_FEATURES */
+#endif  /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
 
 protected:
 
     typedef M mutex_type;
     mutex_type my_mutex;
     std::queue< T * > my_q;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
     built_predecessors_type my_built_predecessors;
 #endif
 
@@ -189,7 +185,7 @@ class predecessor_cache : public node_cache< sender<T>, M > {
 
 protected:
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
     using node_cache< predecessor_type, M >::my_built_predecessors;
 #endif
     successor_type *my_owner;
@@ -290,7 +286,7 @@ class successor_cache : tbb::internal::no_copy {
     typedef sender<T> owner_type;
 #endif // __TBB_PREVIEW_ASYNC_MSG
     typedef std::list< pointer_type > successors_type;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
     edge_container<successor_type> my_built_successors;
 #endif
     successors_type my_successors;
@@ -298,7 +294,7 @@ class successor_cache : tbb::internal::no_copy {
     owner_type *my_owner;
 
 public:
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
     typedef typename edge_container<successor_type>::edge_list_type successor_list_type;
 
     edge_container<successor_type> &built_successors() { return my_built_successors; }
@@ -323,7 +319,7 @@ class successor_cache : tbb::internal::no_copy {
         return my_built_successors.edge_count();
     }
 
-#endif /* TBB_PREVIEW_FLOW_GRAPH_FEATURES */
+#endif /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
 
     successor_cache( ) : my_owner(NULL) {}
 
@@ -354,7 +350,7 @@ class successor_cache : tbb::internal::no_copy {
 
     void clear() {
         my_successors.clear();
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
         my_built_successors.clear();
 #endif
     }
@@ -365,11 +361,11 @@ class successor_cache : tbb::internal::no_copy {
  };  // successor_cache<T>
 
 //! An abstract cache of successors, specialized to continue_msg
-template<>
-class successor_cache< continue_msg > : tbb::internal::no_copy {
+template<typename M>
+class successor_cache< continue_msg, M > : tbb::internal::no_copy {
 protected:
 
-    typedef spin_rw_mutex mutex_type;
+    typedef M mutex_type;
     mutex_type my_mutex;
 
 #if __TBB_PREVIEW_ASYNC_MSG
@@ -381,7 +377,7 @@ class successor_cache< continue_msg > : tbb::internal::no_copy {
 #endif // __TBB_PREVIEW_ASYNC_MSG
     typedef std::list< pointer_type > successors_type;
     successors_type my_successors;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
     edge_container<successor_type> my_built_successors;
     typedef edge_container<successor_type>::edge_list_type successor_list_type;
 #endif
@@ -390,31 +386,31 @@ class successor_cache< continue_msg > : tbb::internal::no_copy {
 
 public:
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
 
     edge_container<successor_type> &built_successors() { return my_built_successors; }
 
     void internal_add_built_successor( successor_type &r) {
-        mutex_type::scoped_lock l(my_mutex, true);
+        typename mutex_type::scoped_lock l(my_mutex, true);
         my_built_successors.add_edge( r );
     }
 
     void internal_delete_built_successor( successor_type &r) {
-        mutex_type::scoped_lock l(my_mutex, true);
+        typename mutex_type::scoped_lock l(my_mutex, true);
         my_built_successors.delete_edge(r);
     }
 
     void copy_successors( successor_list_type &v) {
-        mutex_type::scoped_lock l(my_mutex, false);
+        typename mutex_type::scoped_lock l(my_mutex, false);
         my_built_successors.copy_edges(v);
     }
 
     size_t successor_count() {
-        mutex_type::scoped_lock l(my_mutex,false);
+        typename mutex_type::scoped_lock l(my_mutex,false);
         return my_built_successors.edge_count();
     }
 
-#endif  /* TBB_PREVIEW_FLOW_GRAPH_FEATURES */
+#endif  /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
 
     successor_cache( ) : my_owner(NULL) {}
 
@@ -423,7 +419,7 @@ class successor_cache< continue_msg > : tbb::internal::no_copy {
     virtual ~successor_cache() {}
 
     void register_successor( successor_type &r ) {
-        mutex_type::scoped_lock l(my_mutex, true);
+        typename mutex_type::scoped_lock l(my_mutex, true);
         my_successors.push_back( &r );
         if ( my_owner && r.is_continue_receiver() ) {
             r.register_predecessor( *my_owner );
@@ -431,7 +427,7 @@ class successor_cache< continue_msg > : tbb::internal::no_copy {
     }
 
     void remove_successor( successor_type &r ) {
-        mutex_type::scoped_lock l(my_mutex, true);
+        typename mutex_type::scoped_lock l(my_mutex, true);
         for ( successors_type::iterator i = my_successors.begin();
               i != my_successors.end(); ++i ) {
             if ( *i == & r ) {
@@ -446,13 +442,13 @@ class successor_cache< continue_msg > : tbb::internal::no_copy {
     }
 
     bool empty() {
-        mutex_type::scoped_lock l(my_mutex, false);
+        typename mutex_type::scoped_lock l(my_mutex, false);
         return my_successors.empty();
     }
 
     void clear() {
         my_successors.clear();
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
         my_built_successors.clear();
 #endif
     }
@@ -508,6 +504,40 @@ class broadcast_cache : public successor_cache<T, M> {
         return last_task;
     }
 
+    // call try_put_task and return list of received tasks
+#if __TBB_PREVIEW_ASYNC_MSG
+    template<typename X>
+    bool gather_successful_try_puts( const X &t, task_list &tasks ) {
+#else
+    bool gather_successful_try_puts( const T &t, task_list &tasks ) {
+#endif // __TBB_PREVIEW_ASYNC_MSG
+        bool upgraded = true;
+        bool is_at_least_one_put_successful = false;
+        typename mutex_type::scoped_lock l(this->my_mutex, upgraded);
+        typename successors_type::iterator i = this->my_successors.begin();
+        while ( i != this->my_successors.end() ) {
+            task * new_task = (*i)->try_put_task(t);
+            if(new_task) {
+                ++i;
+                if(new_task != SUCCESSFULLY_ENQUEUED) {
+                    tasks.push_back(*new_task);
+                }
+                is_at_least_one_put_successful = true;
+            }
+            else {  // failed
+                if ( (*i)->register_predecessor(*this->my_owner) ) {
+                    if (!upgraded) {
+                        l.upgrade_to_writer();
+                        upgraded = true;
+                    }
+                    i = this->my_successors.erase(i);
+                } else {
+                    ++i;
+                }
+            }
+        }
+        return is_at_least_one_put_successful;
+    }
 };
 
 //! A cache of successors that are put in a round-robin fashion
diff --git a/inst/include/tbb/internal/_flow_graph_impl.h b/inst/include/tbb/internal/_flow_graph_impl.h
index 92278caf..7859e944 100644
--- a/inst/include/tbb/internal/_flow_graph_impl.h
+++ b/inst/include/tbb/internal/_flow_graph_impl.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,828 +12,536 @@
     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.
+*/
 
+#ifndef __TBB_flow_graph_impl_H
+#define __TBB_flow_graph_impl_H
 
+#include "../tbb_stddef.h"
+#include "../task.h"
+#include "../task_arena.h"
+#include "../flow_graph_abstractions.h"
 
+#if __TBB_PREVIEW_FLOW_GRAPH_PRIORITIES
+#include "../concurrent_priority_queue.h"
+#endif
 
-*/
-
-#ifndef __TBB__flow_graph_impl_H
-#define __TBB__flow_graph_impl_H
+#include <list>
 
-#ifndef __TBB_flow_graph_H
-#error Do not #include this internal file directly; use public TBB headers instead.
+#if TBB_DEPRECATED_FLOW_ENQUEUE
+#define FLOW_SPAWN(a) tbb::task::enqueue((a))
+#else
+#define FLOW_SPAWN(a) tbb::task::spawn((a))
 #endif
 
-// included in namespace tbb::flow::interfaceX (in flow_graph.h)
+#if __TBB_PREVIEW_FLOW_GRAPH_PRIORITIES
+#define __TBB_FLOW_GRAPH_PRIORITY_EXPR( expr ) expr
+#define __TBB_FLOW_GRAPH_PRIORITY_ARG0( priority ) , priority
+#define __TBB_FLOW_GRAPH_PRIORITY_ARG1( arg1, priority ) arg1, priority
+#else
+#define __TBB_FLOW_GRAPH_PRIORITY_EXPR( expr )
+#define __TBB_FLOW_GRAPH_PRIORITY_ARG0( priority )
+#define __TBB_FLOW_GRAPH_PRIORITY_ARG1( arg1, priority ) arg1
+#endif // __TBB_PREVIEW_FLOW_GRAPH_PRIORITIES
+
+#if TBB_DEPRECATED_LIMITER_NODE_CONSTRUCTOR
+#define __TBB_DEPRECATED_LIMITER_EXPR( expr ) expr
+#define __TBB_DEPRECATED_LIMITER_ARG2( arg1, arg2 ) arg1, arg2
+#define __TBB_DEPRECATED_LIMITER_ARG4( arg1, arg2, arg3, arg4 ) arg1, arg3, arg4
+#else
+#define __TBB_DEPRECATED_LIMITER_EXPR( expr )
+#define __TBB_DEPRECATED_LIMITER_ARG2( arg1, arg2 ) arg1
+#define __TBB_DEPRECATED_LIMITER_ARG4( arg1, arg2, arg3, arg4 ) arg1, arg2
+#endif // TBB_DEPRECATED_LIMITER_NODE_CONSTRUCTOR
+
+namespace tbb {
+namespace flow {
 
 namespace internal {
+static tbb::task * const SUCCESSFULLY_ENQUEUED = (task *)-1;
+#if __TBB_PREVIEW_FLOW_GRAPH_PRIORITIES
+typedef unsigned int node_priority_t;
+static const node_priority_t no_priority = node_priority_t(0);
+#endif
+}
 
-    typedef tbb::internal::uint64_t tag_value;
+namespace interface10 {
+class graph;
+}
 
-    using tbb::internal::strip;
+namespace interface11 {
 
-    namespace graph_policy_namespace {
+using tbb::flow::internal::SUCCESSFULLY_ENQUEUED;
 
-        struct rejecting { };
-        struct reserving { };
-        struct queueing  { };
+#if __TBB_PREVIEW_FLOW_GRAPH_PRIORITIES
+using tbb::flow::internal::node_priority_t;
+using tbb::flow::internal::no_priority;
+//! Base class for tasks generated by graph nodes.
+struct graph_task : public task {
+    graph_task( node_priority_t node_priority = no_priority ) : priority( node_priority ) {}
+    node_priority_t priority;
+};
+#else
+typedef task graph_task;
+#endif /* __TBB_PREVIEW_FLOW_GRAPH_PRIORITIES */
 
-        // K == type of field used for key-matching.  Each tag-matching port will be provided
-        // functor that, given an object accepted by the port, will return the
-        /// field of type K being used for matching.
-        template<typename K, typename KHash=tbb_hash_compare<typename strip<K>::type > >
-        struct key_matching {
-            typedef K key_type;
-            typedef typename strip<K>::type base_key_type;
-            typedef KHash hash_compare_type;
-        };
+class graph_node;
 
-        // old tag_matching join's new specifier
-        typedef key_matching<tag_value> tag_matching;
+template <typename GraphContainerType, typename GraphNodeType>
+class graph_iterator {
+    friend class tbb::flow::interface10::graph;
+    friend class graph_node;
+public:
+    typedef size_t size_type;
+    typedef GraphNodeType value_type;
+    typedef GraphNodeType* pointer;
+    typedef GraphNodeType& reference;
+    typedef const GraphNodeType& const_reference;
+    typedef std::forward_iterator_tag iterator_category;
+
+    //! Default constructor
+    graph_iterator() : my_graph(NULL), current_node(NULL) {}
+
+    //! Copy constructor
+    graph_iterator(const graph_iterator& other) :
+        my_graph(other.my_graph), current_node(other.current_node)
+    {}
+
+    //! Assignment
+    graph_iterator& operator=(const graph_iterator& other) {
+        if (this != &other) {
+            my_graph = other.my_graph;
+            current_node = other.current_node;
+        }
+        return *this;
     }
 
-// -------------- function_body containers ----------------------
+    //! Dereference
+    reference operator*() const;
 
-    //! A functor that takes no input and generates a value of type Output
-    template< typename Output >
-    class source_body : tbb::internal::no_assign {
-    public:
-        virtual ~source_body() {}
-        virtual bool operator()(Output &output) = 0;
-        virtual source_body* clone() = 0;
-    };
-
-    //! The leaf for source_body
-    template< typename Output, typename Body>
-    class source_body_leaf : public source_body<Output> {
-    public:
-        source_body_leaf( const Body &_body ) : body(_body) { }
-        bool operator()(Output &output) __TBB_override { return body( output ); }
-        source_body_leaf* clone() __TBB_override {
-            return new source_body_leaf< Output, Body >(body);
-        }
-        Body get_body() { return body; }
-    private:
-        Body body;
-    };
-
-    //! A functor that takes an Input and generates an Output
-    template< typename Input, typename Output >
-    class function_body : tbb::internal::no_assign {
-    public:
-        virtual ~function_body() {}
-        virtual Output operator()(const Input &input) = 0;
-        virtual function_body* clone() = 0;
-    };
-
-    //! the leaf for function_body
-    template <typename Input, typename Output, typename B>
-    class function_body_leaf : public function_body< Input, Output > {
-    public:
-        function_body_leaf( const B &_body ) : body(_body) { }
-        Output operator()(const Input &i) __TBB_override { return body(i); }
-        B get_body() { return body; }
-        function_body_leaf* clone() __TBB_override {
-            return new function_body_leaf< Input, Output, B >(body);
-        }
-    private:
-        B body;
-    };
+    //! Dereference
+    pointer operator->() const;
 
-    //! the leaf for function_body specialized for Input and output of continue_msg
-    template <typename B>
-    class function_body_leaf< continue_msg, continue_msg, B> : public function_body< continue_msg, continue_msg > {
-    public:
-        function_body_leaf( const B &_body ) : body(_body) { }
-        continue_msg operator()( const continue_msg &i ) __TBB_override {
-            body(i);
-            return i;
-        }
-        B get_body() { return body; }
-        function_body_leaf* clone() __TBB_override {
-           return new function_body_leaf< continue_msg, continue_msg, B >(body);
-        }
-    private:
-        B body;
-    };
-
-    //! the leaf for function_body specialized for Output of continue_msg
-    template <typename Input, typename B>
-    class function_body_leaf< Input, continue_msg, B> : public function_body< Input, continue_msg > {
-    public:
-        function_body_leaf( const B &_body ) : body(_body) { }
-        continue_msg operator()(const Input &i) __TBB_override {
-            body(i);
-            return continue_msg();
-        }
-        B get_body() { return body; }
-        function_body_leaf* clone() __TBB_override {
-            return new function_body_leaf< Input, continue_msg, B >(body);
-        }
-    private:
-        B body;
-    };
-
-    //! the leaf for function_body specialized for Input of continue_msg
-    template <typename Output, typename B>
-    class function_body_leaf< continue_msg, Output, B > : public function_body< continue_msg, Output > {
-    public:
-        function_body_leaf( const B &_body ) : body(_body) { }
-        Output operator()(const continue_msg &i) __TBB_override {
-            return body(i);
-        }
-        B get_body() { return body; }
-        function_body_leaf* clone() __TBB_override {
-            return new function_body_leaf< continue_msg, Output, B >(body);
-        }
-    private:
-        B body;
-    };
-
-    //! function_body that takes an Input and a set of output ports
-    template<typename Input, typename OutputSet>
-    class multifunction_body : tbb::internal::no_assign {
-    public:
-        virtual ~multifunction_body () {}
-        virtual void operator()(const Input &/* input*/, OutputSet &/*oset*/) = 0;
-        virtual multifunction_body* clone() = 0;
-        virtual void* get_body_ptr() = 0;
-    };
+    //! Equality
+    bool operator==(const graph_iterator& other) const {
+        return ((my_graph == other.my_graph) && (current_node == other.current_node));
+    }
 
-    //! leaf for multifunction.  OutputSet can be a std::tuple or a vector.
-    template<typename Input, typename OutputSet, typename B >
-    class multifunction_body_leaf : public multifunction_body<Input, OutputSet> {
-    public:
-        multifunction_body_leaf(const B &_body) : body(_body) { }
-        void operator()(const Input &input, OutputSet &oset) __TBB_override {
-            body(input, oset); // body may explicitly put() to one or more of oset.
-        }
-        void* get_body_ptr() __TBB_override { return &body; }
-        multifunction_body_leaf* clone() __TBB_override {
-            return new multifunction_body_leaf<Input, OutputSet,B>(body);
-        }
+    //! Inequality
+    bool operator!=(const graph_iterator& other) const { return !(operator==(other)); }
 
-    private:
-        B body;
-    };
+    //! Pre-increment
+    graph_iterator& operator++() {
+        internal_forward();
+        return *this;
+    }
 
-// ------ function bodies for hash_buffers and key-matching joins.
+    //! Post-increment
+    graph_iterator operator++(int) {
+        graph_iterator result = *this;
+        operator++();
+        return result;
+    }
 
-template<typename Input, typename Output>
-class type_to_key_function_body : tbb::internal::no_assign {
-    public:
-        virtual ~type_to_key_function_body() {}
-        virtual Output operator()(const Input &input) = 0;  // returns an Output
-        virtual type_to_key_function_body* clone() = 0;
+private:
+    // the graph over which we are iterating
+    GraphContainerType *my_graph;
+    // pointer into my_graph's my_nodes list
+    pointer current_node;
+
+    //! Private initializing constructor for begin() and end() iterators
+    graph_iterator(GraphContainerType *g, bool begin);
+    void internal_forward();
+};  // class graph_iterator
+
+// flags to modify the behavior of the graph reset().  Can be combined.
+enum reset_flags {
+    rf_reset_protocol = 0,
+    rf_reset_bodies = 1 << 0,  // delete the current node body, reset to a copy of the initial node body.
+    rf_clear_edges = 1 << 1   // delete edges
 };
 
-// specialization for ref output
-template<typename Input, typename Output>
-class type_to_key_function_body<Input,Output&> : tbb::internal::no_assign {
-    public:
-        virtual ~type_to_key_function_body() {}
-        virtual const Output & operator()(const Input &input) = 0;  // returns a const Output&
-        virtual type_to_key_function_body* clone() = 0;
-};
+namespace internal {
 
-template <typename Input, typename Output, typename B>
-class type_to_key_function_body_leaf : public type_to_key_function_body<Input, Output> {
-public:
-    type_to_key_function_body_leaf( const B &_body ) : body(_body) { }
-    Output operator()(const Input &i) __TBB_override { return body(i); }
-    B get_body() { return body; }
-    type_to_key_function_body_leaf* clone() __TBB_override {
-        return new type_to_key_function_body_leaf< Input, Output, B>(body);
+void activate_graph(tbb::flow::interface10::graph& g);
+void deactivate_graph(tbb::flow::interface10::graph& g);
+bool is_graph_active(tbb::flow::interface10::graph& g);
+tbb::task& prioritize_task(tbb::flow::interface10::graph& g, tbb::task& arena_task);
+void spawn_in_graph_arena(tbb::flow::interface10::graph& g, tbb::task& arena_task);
+void enqueue_in_graph_arena(tbb::flow::interface10::graph &g, tbb::task& arena_task);
+void add_task_to_graph_reset_list(tbb::flow::interface10::graph& g, tbb::task *tp);
+
+#if __TBB_PREVIEW_FLOW_GRAPH_PRIORITIES
+struct graph_task_comparator {
+    bool operator()(const graph_task* left, const graph_task* right) {
+        return left->priority < right->priority;
     }
-private:
-    B body;
 };
 
-template <typename Input, typename Output, typename B>
-class type_to_key_function_body_leaf<Input,Output&,B> : public type_to_key_function_body< Input, Output&> {
+typedef tbb::concurrent_priority_queue<graph_task*, graph_task_comparator> graph_task_priority_queue_t;
+
+class priority_task_selector : public task {
 public:
-    type_to_key_function_body_leaf( const B &_body ) : body(_body) { }
-    const Output& operator()(const Input &i) __TBB_override {
-        return body(i);
-    }
-    B get_body() { return body; }
-    type_to_key_function_body_leaf* clone() __TBB_override {
-        return new type_to_key_function_body_leaf< Input, Output&, B>(body);
+    priority_task_selector(graph_task_priority_queue_t& priority_queue)
+        : my_priority_queue(priority_queue) {}
+    task* execute() __TBB_override {
+        graph_task* t = NULL;
+        bool result = my_priority_queue.try_pop(t);
+        __TBB_ASSERT_EX( result, "Number of critical tasks for scheduler and tasks"
+                         " in graph's priority queue mismatched" );
+        __TBB_ASSERT( t && t != SUCCESSFULLY_ENQUEUED,
+                      "Incorrect task submitted to graph priority queue" );
+        __TBB_ASSERT( t->priority != tbb::flow::internal::no_priority,
+                      "Tasks from graph's priority queue must have priority" );
+        task* t_next = t->execute();
+        task::destroy(*t);
+        return t_next;
     }
 private:
-    B body;
+    graph_task_priority_queue_t& my_priority_queue;
 };
+#endif /* __TBB_PREVIEW_FLOW_GRAPH_PRIORITIES */
 
-// --------------------------- end of function_body containers ------------------------
-
-// --------------------------- node task bodies ---------------------------------------
-
-    //! A task that calls a node's forward_task function
-    template< typename NodeType >
-    class forward_task_bypass : public task {
+}
 
-        NodeType &my_node;
+} // namespace interfaceX
+namespace interface10 {
+//! The graph class
+/** This class serves as a handle to the graph */
+class graph : tbb::internal::no_copy, public tbb::flow::graph_proxy {
+    friend class tbb::flow::interface11::graph_node;
 
+    template< typename Body >
+    class run_task : public tbb::flow::interface11::graph_task {
     public:
-
-        forward_task_bypass( NodeType &n ) : my_node(n) {}
-
-        task *execute() __TBB_override {
-            task * new_task = my_node.forward_task();
-            if (new_task == SUCCESSFULLY_ENQUEUED) new_task = NULL;
-            return new_task;
+        run_task(Body& body
+#if __TBB_PREVIEW_FLOW_GRAPH_PRIORITIES
+                 , tbb::flow::interface11::node_priority_t node_priority = tbb::flow::interface11::no_priority
+        ) : tbb::flow::interface11::graph_task(node_priority),
+#else
+        ) :
+#endif
+        my_body(body) { }
+        tbb::task *execute() __TBB_override {
+            my_body();
+            return NULL;
         }
+    private:
+        Body my_body;
     };
 
-    //! A task that calls a node's apply_body_bypass function, passing in an input of type Input
-    //  return the task* unless it is SUCCESSFULLY_ENQUEUED, in which case return NULL
-    template< typename NodeType, typename Input >
-    class apply_body_task_bypass : public task {
-
-        NodeType &my_node;
-        Input my_input;
-
+    template< typename Receiver, typename Body >
+    class run_and_put_task : public tbb::flow::interface11::graph_task {
     public:
-
-        apply_body_task_bypass( NodeType &n, const Input &i ) : my_node(n), my_input(i) {}
-
-        task *execute() __TBB_override {
-            task * next_task = my_node.apply_body_bypass( my_input );
-            if(next_task == SUCCESSFULLY_ENQUEUED) next_task = NULL;
-            return next_task;
+        run_and_put_task(Receiver &r, Body& body) : my_receiver(r), my_body(body) {}
+        tbb::task *execute() __TBB_override {
+            tbb::task *res = my_receiver.try_put_task(my_body());
+            if (res == tbb::flow::interface11::SUCCESSFULLY_ENQUEUED) res = NULL;
+            return res;
         }
+    private:
+        Receiver &my_receiver;
+        Body my_body;
     };
+    typedef std::list<tbb::task *> task_list_type;
 
-    //! A task that calls a node's apply_body_bypass function with no input
-    template< typename NodeType >
-    class source_task_bypass : public task {
-
-        NodeType &my_node;
-
+    class wait_functor {
+        tbb::task* graph_root_task;
     public:
-
-        source_task_bypass( NodeType &n ) : my_node(n) {}
-
-        task *execute() __TBB_override {
-            task *new_task = my_node.apply_body_bypass( );
-            if(new_task == SUCCESSFULLY_ENQUEUED) return NULL;
-            return new_task;
-        }
+        wait_functor(tbb::task* t) : graph_root_task(t) {}
+        void operator()() const { graph_root_task->wait_for_all(); }
     };
 
-// ------------------------ end of node task bodies -----------------------------------
-
-    //! An empty functor that takes an Input and returns a default constructed Output
-    template< typename Input, typename Output >
-    struct empty_body {
-       Output operator()( const Input & ) const { return Output(); }
-    };
-
-    //! A node_cache maintains a std::queue of elements of type T.  Each operation is protected by a lock.
-    template< typename T, typename M=spin_mutex >
-    class node_cache {
-        public:
-
-        typedef size_t size_type;
-
-        bool empty() {
-            typename mutex_type::scoped_lock lock( my_mutex );
-            return internal_empty();
-        }
-
-        void add( T &n ) {
-            typename mutex_type::scoped_lock lock( my_mutex );
-            internal_push(n);
-        }
-
-        void remove( T &n ) {
-            typename mutex_type::scoped_lock lock( my_mutex );
-            for ( size_t i = internal_size(); i != 0; --i ) {
-                T &s = internal_pop();
-                if ( &s == &n )  return;  // only remove one predecessor per request
-                internal_push(s);
-            }
-        }
-
-        void clear() {
-            while( !my_q.empty()) (void)my_q.pop();
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
-            my_built_predecessors.clear();
-#endif
+    //! A functor that spawns a task
+    class spawn_functor : tbb::internal::no_assign {
+        tbb::task& spawn_task;
+    public:
+        spawn_functor(tbb::task& t) : spawn_task(t) {}
+        void operator()() const {
+            FLOW_SPAWN(spawn_task);
         }
+    };
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
-        typedef edge_container<T> built_predecessors_type;
-        built_predecessors_type &built_predecessors() { return my_built_predecessors; }
-
-        typedef typename edge_container<T>::edge_list_type predecessor_list_type;
-        void internal_add_built_predecessor( T &n ) {
-            typename mutex_type::scoped_lock lock( my_mutex );
-            my_built_predecessors.add_edge(n);
+    void prepare_task_arena(bool reinit = false) {
+        if (reinit) {
+            __TBB_ASSERT(my_task_arena, "task arena is NULL");
+            my_task_arena->terminate();
+            my_task_arena->initialize(tbb::task_arena::attach());
         }
-
-        void internal_delete_built_predecessor( T &n ) {
-            typename mutex_type::scoped_lock lock( my_mutex );
-            my_built_predecessors.delete_edge(n);
+        else {
+            __TBB_ASSERT(my_task_arena == NULL, "task arena is not NULL");
+            my_task_arena = new tbb::task_arena(tbb::task_arena::attach());
         }
+        if (!my_task_arena->is_active()) // failed to attach
+            my_task_arena->initialize(); // create a new, default-initialized arena
+        __TBB_ASSERT(my_task_arena->is_active(), "task arena is not active");
+    }
 
-        void copy_predecessors( predecessor_list_type &v) {
-            typename mutex_type::scoped_lock lock( my_mutex );
-            my_built_predecessors.copy_edges(v);
-        }
+public:
+    //! Constructs a graph with isolated task_group_context
+    graph();
 
-        size_t predecessor_count() {
-            typename mutex_type::scoped_lock lock(my_mutex);
-            return (size_t)(my_built_predecessors.edge_count());
-        }
-#endif  /* TBB_PREVIEW_FLOW_GRAPH_FEATURES */
+    //! Constructs a graph with use_this_context as context
+    explicit graph(tbb::task_group_context& use_this_context);
 
-    protected:
+    //! Destroys the graph.
+    /** Calls wait_for_all, then destroys the root task and context. */
+    ~graph();
 
-        typedef M mutex_type;
-        mutex_type my_mutex;
-        std::queue< T * > my_q;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
-        built_predecessors_type my_built_predecessors;
+#if TBB_PREVIEW_FLOW_GRAPH_TRACE
+    void set_name(const char *name);
 #endif
 
-        // Assumes lock is held
-        inline bool internal_empty( )  {
-            return my_q.empty();
-        }
-
-        // Assumes lock is held
-        inline size_type internal_size( )  {
-            return my_q.size();
-        }
+    __TBB_DEPRECATED void increment_wait_count() {
+        reserve_wait();
+    }
 
-        // Assumes lock is held
-        inline void internal_push( T &n )  {
-            my_q.push(&n);
-        }
+    __TBB_DEPRECATED void decrement_wait_count() {
+        release_wait();
+    }
 
-        // Assumes lock is held
-        inline T &internal_pop() {
-            T *v = my_q.front();
-            my_q.pop();
-            return *v;
+    //! Used to register that an external entity may still interact with the graph.
+    /** The graph will not return from wait_for_all until a matching number of decrement_wait_count calls
+    is made. */
+    void reserve_wait() __TBB_override;
+
+    //! Deregisters an external entity that may have interacted with the graph.
+    /** The graph will not return from wait_for_all until all the number of decrement_wait_count calls
+    matches the number of increment_wait_count calls. */
+    void release_wait() __TBB_override;
+
+    //! Spawns a task that runs a body and puts its output to a specific receiver
+    /** The task is spawned as a child of the graph. This is useful for running tasks
+    that need to block a wait_for_all() on the graph.  For example a one-off source. */
+    template< typename Receiver, typename Body >
+    __TBB_DEPRECATED void run(Receiver &r, Body body) {
+        if (tbb::flow::interface11::internal::is_graph_active(*this)) {
+            task* rtask = new (task::allocate_additional_child_of(*root_task()))
+                run_and_put_task< Receiver, Body >(r, body);
+            my_task_arena->execute(spawn_functor(*rtask));
         }
+    }
 
-    };
-
-    //! A cache of predecessors that only supports try_get
-    template< typename T, typename M=spin_mutex >
-#if __TBB_PREVIEW_ASYNC_MSG
-    // TODO: make predecessor_cache type T-independent when async_msg becomes regular feature
-    class predecessor_cache : public node_cache< untyped_sender, M > {
-#else
-    class predecessor_cache : public node_cache< sender<T>, M > {
-#endif // __TBB_PREVIEW_ASYNC_MSG
-    public:
-        typedef M mutex_type;
-        typedef T output_type;
-#if __TBB_PREVIEW_ASYNC_MSG
-        typedef untyped_sender predecessor_type;
-        typedef untyped_receiver successor_type;
-#else
-        typedef sender<output_type> predecessor_type;
-        typedef receiver<output_type> successor_type;
-#endif // __TBB_PREVIEW_ASYNC_MSG
-
-        predecessor_cache( ) : my_owner( NULL ) { }
-
-        void set_owner( successor_type *owner ) { my_owner = owner; }
-
-        bool get_item( output_type &v ) {
-
-            bool msg = false;
-
-            do {
-                predecessor_type *src;
-                {
-                    typename mutex_type::scoped_lock lock(this->my_mutex);
-                    if ( this->internal_empty() ) {
-                        break;
-                    }
-                    src = &this->internal_pop();
-                }
-
-                // Try to get from this sender
-                msg = src->try_get( v );
-
-                if (msg == false) {
-                    // Relinquish ownership of the edge
-                    if (my_owner)
-                        src->register_successor( *my_owner );
-                } else {
-                    // Retain ownership of the edge
-                    this->add(*src);
-                }
-            } while ( msg == false );
-            return msg;
+    //! Spawns a task that runs a function object
+    /** The task is spawned as a child of the graph. This is useful for running tasks
+    that need to block a wait_for_all() on the graph. For example a one-off source. */
+    template< typename Body >
+    __TBB_DEPRECATED void run(Body body) {
+        if (tbb::flow::interface11::internal::is_graph_active(*this)) {
+            task* rtask = new (task::allocate_additional_child_of(*root_task())) run_task< Body >(body);
+            my_task_arena->execute(spawn_functor(*rtask));
         }
+    }
 
-        // If we are removing arcs (rf_clear_edges), call clear() rather than reset().
-        void reset() {
-            if (my_owner) {
-                for(;;) {
-                    predecessor_type *src;
-                    {
-                        if (this->internal_empty()) break;
-                        src = &this->internal_pop();
-                    }
-                    src->register_successor( *my_owner );
-                }
+    //! Wait until graph is idle and decrement_wait_count calls equals increment_wait_count calls.
+    /** The waiting thread will go off and steal work while it is block in the wait_for_all. */
+    void wait_for_all() {
+        cancelled = false;
+        caught_exception = false;
+        if (my_root_task) {
+#if TBB_USE_EXCEPTIONS
+            try {
+#endif
+                my_task_arena->execute(wait_functor(my_root_task));
+#if __TBB_TASK_GROUP_CONTEXT
+                cancelled = my_context->is_group_execution_cancelled();
+#endif
+#if TBB_USE_EXCEPTIONS
+            }
+            catch (...) {
+                my_root_task->set_ref_count(1);
+                my_context->reset();
+                caught_exception = true;
+                cancelled = true;
+                throw;
             }
-        }
-
-    protected:
-
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
-        using node_cache< predecessor_type, M >::my_built_predecessors;
 #endif
-        successor_type *my_owner;
-    };
-
-    //! An cache of predecessors that supports requests and reservations
-    // TODO: make reservable_predecessor_cache type T-independent when async_msg becomes regular feature
-    template< typename T, typename M=spin_mutex >
-    class reservable_predecessor_cache : public predecessor_cache< T, M > {
-    public:
-        typedef M mutex_type;
-        typedef T output_type;
-#if __TBB_PREVIEW_ASYNC_MSG
-        typedef untyped_sender predecessor_type;
-        typedef untyped_receiver successor_type;
-#else
-        typedef sender<T> predecessor_type;
-        typedef receiver<T> successor_type;
-#endif // __TBB_PREVIEW_ASYNC_MSG
-
-        reservable_predecessor_cache( ) : reserved_src(NULL) { }
-
-        bool
-        try_reserve( output_type &v ) {
-            bool msg = false;
-
-            do {
-                {
-                    typename mutex_type::scoped_lock lock(this->my_mutex);
-                    if ( reserved_src || this->internal_empty() )
-                        return false;
-
-                    reserved_src = &this->internal_pop();
-                }
-
-                // Try to get from this sender
-                msg = reserved_src->try_reserve( v );
-
-                if (msg == false) {
-                    typename mutex_type::scoped_lock lock(this->my_mutex);
-                    // Relinquish ownership of the edge
-                    reserved_src->register_successor( *this->my_owner );
-                    reserved_src = NULL;
-                } else {
-                    // Retain ownership of the edge
-                    this->add( *reserved_src );
-                }
-            } while ( msg == false );
-
-            return msg;
-        }
-
-        bool
-        try_release( ) {
-            reserved_src->try_release( );
-            reserved_src = NULL;
-            return true;
-        }
-
-        bool
-        try_consume( ) {
-            reserved_src->try_consume( );
-            reserved_src = NULL;
-            return true;
-        }
-
-        void reset( ) {
-            reserved_src = NULL;
-            predecessor_cache<T,M>::reset( );
-        }
-
-        void clear() {
-            reserved_src = NULL;
-            predecessor_cache<T,M>::clear();
-        }
-
-    private:
-        predecessor_type *reserved_src;
-    };
-
-
-    //! An abstract cache of successors
-    // TODO: make successor_cache type T-independent when async_msg becomes regular feature
-    template<typename T, typename M=spin_rw_mutex >
-    class successor_cache : tbb::internal::no_copy {
-    protected:
-
-        typedef M mutex_type;
-        mutex_type my_mutex;
-
-#if __TBB_PREVIEW_ASYNC_MSG
-        typedef untyped_receiver successor_type;
-        typedef untyped_receiver *pointer_type;
-        typedef untyped_sender owner_type;
-#else
-        typedef receiver<T> successor_type;
-        typedef receiver<T> *pointer_type;
-        typedef sender<T> owner_type;
-#endif // __TBB_PREVIEW_ASYNC_MSG
-        typedef std::list< pointer_type > successors_type;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
-        edge_container<successor_type> my_built_successors;
+#if __TBB_TASK_GROUP_CONTEXT
+            // TODO: the "if" condition below is just a work-around to support the concurrent wait
+            // mode. The cancellation and exception mechanisms are still broken in this mode.
+            // Consider using task group not to re-implement the same functionality.
+            if (!(my_context->traits() & tbb::task_group_context::concurrent_wait)) {
+                my_context->reset();  // consistent with behavior in catch()
 #endif
-        successors_type my_successors;
-
-        owner_type *my_owner;
-
-    public:
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
-        typedef typename edge_container<successor_type>::edge_list_type successor_list_type;
-
-        edge_container<successor_type> &built_successors() { return my_built_successors; }
-
-        void internal_add_built_successor( successor_type &r) {
-            typename mutex_type::scoped_lock l(my_mutex, true);
-            my_built_successors.add_edge( r );
-        }
-
-        void internal_delete_built_successor( successor_type &r) {
-            typename mutex_type::scoped_lock l(my_mutex, true);
-            my_built_successors.delete_edge(r);
-        }
-
-        void copy_successors( successor_list_type &v) {
-            typename mutex_type::scoped_lock l(my_mutex, false);
-            my_built_successors.copy_edges(v);
-        }
-
-        size_t successor_count() {
-            typename mutex_type::scoped_lock l(my_mutex,false);
-            return my_built_successors.edge_count();
-        }
-
-#endif /* TBB_PREVIEW_FLOW_GRAPH_FEATURES */
-
-        successor_cache( ) : my_owner(NULL) {}
-
-        void set_owner( owner_type *owner ) { my_owner = owner; }
-
-        virtual ~successor_cache() {}
-
-        void register_successor( successor_type &r ) {
-            typename mutex_type::scoped_lock l(my_mutex, true);
-            my_successors.push_back( &r );
-        }
-
-        void remove_successor( successor_type &r ) {
-            typename mutex_type::scoped_lock l(my_mutex, true);
-            for ( typename successors_type::iterator i = my_successors.begin();
-                  i != my_successors.end(); ++i ) {
-                if ( *i == & r ) {
-                    my_successors.erase(i);
-                    break;
-                }
+                my_root_task->set_ref_count(1);
+#if __TBB_TASK_GROUP_CONTEXT
             }
-        }
-
-        bool empty() {
-            typename mutex_type::scoped_lock l(my_mutex, false);
-            return my_successors.empty();
-        }
-
-        void clear() {
-            my_successors.clear();
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
-            my_built_successors.clear();
 #endif
         }
+    }
 
-#if !__TBB_PREVIEW_ASYNC_MSG
-        virtual task * try_put_task( const T &t ) = 0;
-#endif // __TBB_PREVIEW_ASYNC_MSG
-     };  // successor_cache<T>
-
-    //! An abstract cache of successors, specialized to continue_msg
-    template<>
-    class successor_cache< continue_msg > : tbb::internal::no_copy {
-    protected:
+    //! Returns the root task of the graph
+    __TBB_DEPRECATED tbb::task * root_task() {
+        return my_root_task;
+    }
 
-        typedef spin_rw_mutex mutex_type;
-        mutex_type my_mutex;
+    // ITERATORS
+    template<typename C, typename N>
+    friend class tbb::flow::interface11::graph_iterator;
+
+    // Graph iterator typedefs
+    typedef tbb::flow::interface11::graph_iterator<graph, tbb::flow::interface11::graph_node> iterator;
+    typedef tbb::flow::interface11::graph_iterator<const graph, const tbb::flow::interface11::graph_node> const_iterator;
+
+    // Graph iterator constructors
+    //! start iterator
+    iterator begin();
+    //! end iterator
+    iterator end();
+    //! start const iterator
+    const_iterator begin() const;
+    //! end const iterator
+    const_iterator end() const;
+    //! start const iterator
+    const_iterator cbegin() const;
+    //! end const iterator
+    const_iterator cend() const;
+
+    //! return status of graph execution
+    bool is_cancelled() { return cancelled; }
+    bool exception_thrown() { return caught_exception; }
+
+    // thread-unsafe state reset.
+    void reset(tbb::flow::interface11::reset_flags f = tbb::flow::interface11::rf_reset_protocol);
 
-#if __TBB_PREVIEW_ASYNC_MSG
-        typedef untyped_receiver successor_type;
-        typedef untyped_receiver *pointer_type;
-#else
-        typedef receiver<continue_msg> successor_type;
-        typedef receiver<continue_msg> *pointer_type;
-#endif // __TBB_PREVIEW_ASYNC_MSG
-        typedef std::list< pointer_type > successors_type;
-        successors_type my_successors;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
-        edge_container<successor_type> my_built_successors;
-        typedef edge_container<successor_type>::edge_list_type successor_list_type;
+private:
+    tbb::task *my_root_task;
+#if __TBB_TASK_GROUP_CONTEXT
+    tbb::task_group_context *my_context;
 #endif
+    bool own_context;
+    bool cancelled;
+    bool caught_exception;
+    bool my_is_active;
+    task_list_type my_reset_task_list;
 
-        sender<continue_msg> *my_owner;
-
-    public:
-
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
-
-        edge_container<successor_type> &built_successors() { return my_built_successors; }
+    tbb::flow::interface11::graph_node *my_nodes, *my_nodes_last;
 
-        void internal_add_built_successor( successor_type &r) {
-            mutex_type::scoped_lock l(my_mutex, true);
-            my_built_successors.add_edge( r );
-        }
-
-        void internal_delete_built_successor( successor_type &r) {
-            mutex_type::scoped_lock l(my_mutex, true);
-            my_built_successors.delete_edge(r);
-        }
-
-        void copy_successors( successor_list_type &v) {
-            mutex_type::scoped_lock l(my_mutex, false);
-            my_built_successors.copy_edges(v);
-        }
-
-        size_t successor_count() {
-            mutex_type::scoped_lock l(my_mutex,false);
-            return my_built_successors.edge_count();
-        }
+    tbb::spin_mutex nodelist_mutex;
+    void register_node(tbb::flow::interface11::graph_node *n);
+    void remove_node(tbb::flow::interface11::graph_node *n);
 
-#endif  /* TBB_PREVIEW_FLOW_GRAPH_FEATURES */
+    tbb::task_arena* my_task_arena;
 
-        successor_cache( ) : my_owner(NULL) {}
+#if __TBB_PREVIEW_FLOW_GRAPH_PRIORITIES
+    tbb::flow::interface11::internal::graph_task_priority_queue_t my_priority_queue;
+#endif
 
-        void set_owner( sender<continue_msg> *owner ) { my_owner = owner; }
+    friend void tbb::flow::interface11::internal::activate_graph(graph& g);
+    friend void tbb::flow::interface11::internal::deactivate_graph(graph& g);
+    friend bool tbb::flow::interface11::internal::is_graph_active(graph& g);
+    friend tbb::task& tbb::flow::interface11::internal::prioritize_task(graph& g, tbb::task& arena_task);
+    friend void tbb::flow::interface11::internal::spawn_in_graph_arena(graph& g, tbb::task& arena_task);
+    friend void tbb::flow::interface11::internal::enqueue_in_graph_arena(graph &g, tbb::task& arena_task);
+    friend void tbb::flow::interface11::internal::add_task_to_graph_reset_list(graph& g, tbb::task *tp);
 
-        virtual ~successor_cache() {}
+    friend class tbb::interface7::internal::task_arena_base;
 
-        void register_successor( successor_type &r ) {
-            mutex_type::scoped_lock l(my_mutex, true);
-            my_successors.push_back( &r );
-            if ( my_owner && r.is_continue_receiver() ) {
-                r.register_predecessor( *my_owner );
-            }
-        }
+};  // class graph
+} // namespace interface10
 
-        void remove_successor( successor_type &r ) {
-            mutex_type::scoped_lock l(my_mutex, true);
-            for ( successors_type::iterator i = my_successors.begin();
-                  i != my_successors.end(); ++i ) {
-                if ( *i == & r ) {
-                    // TODO: Check if we need to test for continue_receiver before
-                    // removing from r.
-                    if ( my_owner )
-                        r.remove_predecessor( *my_owner );
-                    my_successors.erase(i);
-                    break;
-                }
-            }
-        }
+namespace interface11 {
 
-        bool empty() {
-            mutex_type::scoped_lock l(my_mutex, false);
-            return my_successors.empty();
-        }
+using tbb::flow::interface10::graph;
 
-        void clear() {
-            my_successors.clear();
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
-            my_built_successors.clear();
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+namespace internal{
+class get_graph_helper;
+}
 #endif
-        }
 
-#if !__TBB_PREVIEW_ASYNC_MSG
-        virtual task * try_put_task( const continue_msg &t ) = 0;
-#endif // __TBB_PREVIEW_ASYNC_MSG
+//! The base of all graph nodes.
+class graph_node : tbb::internal::no_copy {
+    friend class graph;
+    template<typename C, typename N>
+    friend class graph_iterator;
 
-    };  // successor_cache< continue_msg >
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+    friend class internal::get_graph_helper;
+#endif
 
-    //! A cache of successors that are broadcast to
-    // TODO: make broadcast_cache type T-independent when async_msg becomes regular feature
-    template<typename T, typename M=spin_rw_mutex>
-    class broadcast_cache : public successor_cache<T, M> {
-        typedef M mutex_type;
-        typedef typename successor_cache<T,M>::successors_type successors_type;
+protected:
+    graph& my_graph;
+    graph_node *next, *prev;
+public:
+    explicit graph_node(graph& g);
 
-    public:
+    virtual ~graph_node();
 
-        broadcast_cache( ) {}
+#if TBB_PREVIEW_FLOW_GRAPH_TRACE
+    virtual void set_name(const char *name) = 0;
+#endif
 
-        // as above, but call try_put_task instead, and return the last task we received (if any)
-#if __TBB_PREVIEW_ASYNC_MSG
-        template<typename X>
-        task * try_put_task( const X &t ) {
-#else
-        task * try_put_task( const T &t ) __TBB_override {
-#endif // __TBB_PREVIEW_ASYNC_MSG
-            task * last_task = NULL;
-            bool upgraded = true;
-            typename mutex_type::scoped_lock l(this->my_mutex, upgraded);
-            typename successors_type::iterator i = this->my_successors.begin();
-            while ( i != this->my_successors.end() ) {
-                task *new_task = (*i)->try_put_task(t);
-                last_task = combine_tasks(last_task, new_task);  // enqueue if necessary
-                if(new_task) {
-                    ++i;
-                }
-                else {  // failed
-                    if ( (*i)->register_predecessor(*this->my_owner) ) {
-                        if (!upgraded) {
-                            l.upgrade_to_writer();
-                            upgraded = true;
-                        }
-                        i = this->my_successors.erase(i);
-                    } else {
-                        ++i;
-                    }
-                }
-            }
-            return last_task;
-        }
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
+    virtual void extract() = 0;
+#endif
 
-    };
+protected:
+    // performs the reset on an individual node.
+    virtual void reset_node(reset_flags f = rf_reset_protocol) = 0;
+};  // class graph_node
 
-    //! A cache of successors that are put in a round-robin fashion
-    // TODO: make round_robin_cache type T-independent when async_msg becomes regular feature
-    template<typename T, typename M=spin_rw_mutex >
-    class round_robin_cache : public successor_cache<T, M> {
-        typedef size_t size_type;
-        typedef M mutex_type;
-        typedef typename successor_cache<T,M>::successors_type successors_type;
+namespace internal {
 
-    public:
+inline void activate_graph(graph& g) {
+    g.my_is_active = true;
+}
 
-        round_robin_cache( ) {}
+inline void deactivate_graph(graph& g) {
+    g.my_is_active = false;
+}
 
-        size_type size() {
-            typename mutex_type::scoped_lock l(this->my_mutex, false);
-            return this->my_successors.size();
-        }
+inline bool is_graph_active(graph& g) {
+    return g.my_is_active;
+}
 
-#if __TBB_PREVIEW_ASYNC_MSG
-        template<typename X>
-        task * try_put_task( const X &t ) {
+#if __TBB_PREVIEW_FLOW_GRAPH_PRIORITIES
+inline tbb::task& prioritize_task(graph& g, tbb::task& t) {
+    task* critical_task = &t;
+    // TODO: change flow graph's interfaces to work with graph_task type instead of tbb::task.
+    graph_task* gt = static_cast<graph_task*>(&t);
+    if( gt->priority != no_priority ) {
+        //! Non-preemptive priority pattern. The original task is submitted as a work item to the
+        //! priority queue, and a new critical task is created to take and execute a work item with
+        //! the highest known priority. The reference counting responsibility is transferred (via
+        //! allocate_continuation) to the new task.
+        critical_task = new( gt->allocate_continuation() ) priority_task_selector(g.my_priority_queue);
+        tbb::internal::make_critical( *critical_task );
+        g.my_priority_queue.push(gt);
+    }
+    return *critical_task;
+}
 #else
-        task *try_put_task( const T &t ) __TBB_override {
-#endif // __TBB_PREVIEW_ASYNC_MSG
-            bool upgraded = true;
-            typename mutex_type::scoped_lock l(this->my_mutex, upgraded);
-            typename successors_type::iterator i = this->my_successors.begin();
-            while ( i != this->my_successors.end() ) {
-                task *new_task = (*i)->try_put_task(t);
-                if ( new_task ) {
-                    return new_task;
-                } else {
-                   if ( (*i)->register_predecessor(*this->my_owner) ) {
-                       if (!upgraded) {
-                           l.upgrade_to_writer();
-                           upgraded = true;
-                       }
-                       i = this->my_successors.erase(i);
-                   }
-                   else {
-                       ++i;
-                   }
-                }
-            }
-            return NULL;
-        }
-    };
-
-    template<typename T>
-    class decrementer : public continue_receiver, tbb::internal::no_copy {
-
-        T *my_node;
-
-        task *execute() __TBB_override {
-            return my_node->decrement_counter();
-        }
-
-    public:
+inline tbb::task& prioritize_task(graph&, tbb::task& t) {
+    return t;
+}
+#endif /* __TBB_PREVIEW_FLOW_GRAPH_PRIORITIES */
+
+//! Spawns a task inside graph arena
+inline void spawn_in_graph_arena(graph& g, tbb::task& arena_task) {
+    if (is_graph_active(g)) {
+        graph::spawn_functor s_fn(prioritize_task(g, arena_task));
+        __TBB_ASSERT(g.my_task_arena && g.my_task_arena->is_active(), NULL);
+        g.my_task_arena->execute(s_fn);
+    }
+}
 
-        typedef continue_msg input_type;
-        typedef continue_msg output_type;
-        decrementer( int number_of_predecessors = 0 ) : continue_receiver( number_of_predecessors ) { }
-        void set_owner( T *node ) { my_node = node; }
-    };
+//! Enqueues a task inside graph arena
+inline void enqueue_in_graph_arena(graph &g, tbb::task& arena_task) {
+    if (is_graph_active(g)) {
+        __TBB_ASSERT( g.my_task_arena && g.my_task_arena->is_active(), "Is graph's arena initialized and active?" );
+        task::enqueue(prioritize_task(g, arena_task), *g.my_task_arena);
+    }
+}
 
+inline void add_task_to_graph_reset_list(graph& g, tbb::task *tp) {
+    g.my_reset_task_list.push_back(tp);
 }
 
-#endif // __TBB__flow_graph_impl_H
+} // namespace internal
+
+} // namespace interfaceX
+} // namespace flow
+} // namespace tbb
 
+#endif // __TBB_flow_graph_impl_H
diff --git a/inst/include/tbb/internal/_flow_graph_indexer_impl.h b/inst/include/tbb/internal/_flow_graph_indexer_impl.h
index 1fc6690c..2900db91 100644
--- a/inst/include/tbb/internal/_flow_graph_indexer_impl.h
+++ b/inst/include/tbb/internal/_flow_graph_indexer_impl.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB__flow_graph_indexer_impl_H
@@ -43,18 +39,18 @@ namespace internal {
     template<typename TupleTypes,int N>
     struct indexer_helper {
         template<typename IndexerNodeBaseType, typename PortTuple>
-        static inline void set_indexer_node_pointer(PortTuple &my_input, IndexerNodeBaseType *p) {
+        static inline void set_indexer_node_pointer(PortTuple &my_input, IndexerNodeBaseType *p, graph& g) {
             typedef typename tuple_element<N-1, TupleTypes>::type T;
             task *(*indexer_node_put_task)(const T&, void *) = do_try_put<IndexerNodeBaseType, T, N-1>;
-            tbb::flow::get<N-1>(my_input).set_up(p, indexer_node_put_task);
-            indexer_helper<TupleTypes,N-1>::template set_indexer_node_pointer<IndexerNodeBaseType,PortTuple>(my_input, p);
+            tbb::flow::get<N-1>(my_input).set_up(p, indexer_node_put_task, g);
+            indexer_helper<TupleTypes,N-1>::template set_indexer_node_pointer<IndexerNodeBaseType,PortTuple>(my_input, p, g);
         }
         template<typename InputTuple>
         static inline void reset_inputs(InputTuple &my_input, reset_flags f) {
             indexer_helper<TupleTypes,N-1>::reset_inputs(my_input, f);
             tbb::flow::get<N-1>(my_input).reset_receiver(f);
         }
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
         template<typename InputTuple>
         static inline void extract(InputTuple &my_input) {
             indexer_helper<TupleTypes,N-1>::extract(my_input);
@@ -66,16 +62,16 @@ namespace internal {
     template<typename TupleTypes>
     struct indexer_helper<TupleTypes,1> {
         template<typename IndexerNodeBaseType, typename PortTuple>
-        static inline void set_indexer_node_pointer(PortTuple &my_input, IndexerNodeBaseType *p) {
+        static inline void set_indexer_node_pointer(PortTuple &my_input, IndexerNodeBaseType *p, graph& g) {
             typedef typename tuple_element<0, TupleTypes>::type T;
             task *(*indexer_node_put_task)(const T&, void *) = do_try_put<IndexerNodeBaseType, T, 0>;
-            tbb::flow::get<0>(my_input).set_up(p, indexer_node_put_task);
+            tbb::flow::get<0>(my_input).set_up(p, indexer_node_put_task, g);
         }
         template<typename InputTuple>
         static inline void reset_inputs(InputTuple &my_input, reset_flags f) {
             tbb::flow::get<0>(my_input).reset_receiver(f);
         }
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
         template<typename InputTuple>
         static inline void extract(InputTuple &my_input) {
             tbb::flow::get<0>(my_input).extract_receiver();
@@ -89,22 +85,24 @@ namespace internal {
         void* my_indexer_ptr;
         typedef task* (* forward_function_ptr)(T const &, void* );
         forward_function_ptr my_try_put_task;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
         spin_mutex my_pred_mutex;
         typedef typename receiver<T>::built_predecessors_type built_predecessors_type;
         built_predecessors_type my_built_predecessors;
-#endif  /* TBB_PREVIEW_FLOW_GRAPH_FEATURES */
+#endif  /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
+        graph* my_graph;
     public:
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
-        indexer_input_port() : my_pred_mutex() {}
-        indexer_input_port( const indexer_input_port & /*other*/ ) : receiver<T>(), my_pred_mutex() {
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
+        indexer_input_port() : my_pred_mutex(), my_graph(NULL) {}
+        indexer_input_port( const indexer_input_port & other) : receiver<T>(), my_pred_mutex(), my_graph(other.my_graph) {
         }
-#endif  /* TBB_PREVIEW_FLOW_GRAPH_FEATURES */
-        void set_up(void *p, forward_function_ptr f) {
-                my_indexer_ptr = p;
-                my_try_put_task = f;
-            }
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#endif  /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
+        void set_up(void* p, forward_function_ptr f, graph& g) {
+            my_indexer_ptr = p;
+            my_try_put_task = f;
+            my_graph = &g;
+        }
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
         typedef typename receiver<T>::predecessor_list_type predecessor_list_type;
         typedef typename receiver<T>::predecessor_type predecessor_type;
 
@@ -126,7 +124,7 @@ namespace internal {
             spin_mutex::scoped_lock l(my_pred_mutex);
             my_built_predecessors.copy_edges(v);
         }
-#endif  /* TBB_PREVIEW_FLOW_GRAPH_FEATURES */
+#endif  /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
     protected:
         template< typename R, typename B > friend class run_and_put_task;
         template<typename X, typename Y> friend class internal::broadcast_cache;
@@ -135,14 +133,18 @@ namespace internal {
             return my_try_put_task(v, my_indexer_ptr);
         }
 
+        graph& graph_reference() const __TBB_override {
+            return *my_graph;
+        }
+
     public:
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
         void reset_receiver(reset_flags f) __TBB_override { if(f&rf_clear_edges) my_built_predecessors.clear(); }
 #else
         void reset_receiver(reset_flags /*f*/) __TBB_override { }
 #endif
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
         void extract_receiver() { my_built_predecessors.receiver_extract(*this); }
 #endif
     };
@@ -154,7 +156,7 @@ namespace internal {
         typedef OutputType output_type;
         typedef InputTuple input_type;
 
-        // Some versions of Intel C++ compiler fail to generate an implicit constructor for the class which has std::tuple as a member.
+        // Some versions of Intel(R) C++ Compiler fail to generate an implicit constructor for the class which has std::tuple as a member.
         indexer_node_FE() : my_inputs() {}
 
         input_type &input_ports() { return my_inputs; }
@@ -174,7 +176,7 @@ namespace internal {
         typedef StructTypes tuple_types;
         typedef typename sender<output_type>::successor_type successor_type;
         typedef indexer_node_FE<InputTuple, output_type,StructTypes> input_ports_type;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
         typedef typename sender<output_type>::built_successors_type built_successors_type;
         typedef typename sender<output_type>::successor_list_type successor_list_type;
 #endif
@@ -182,7 +184,7 @@ namespace internal {
     private:
         // ----------- Aggregator ------------
         enum op_type { reg_succ, rem_succ, try__put_task
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
             , add_blt_succ, del_blt_succ,
              blt_succ_cnt, blt_succ_cpy
 #endif
@@ -196,7 +198,7 @@ namespace internal {
                 output_type const *my_arg;
                 successor_type *my_succ;
                 task *bypass_t;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
                 size_t cnt_val;
                 successor_list_type *succv;
 #endif
@@ -233,7 +235,7 @@ namespace internal {
                         __TBB_store_with_release(current->status, SUCCEEDED);  // return of try_put_task actual return value
                     }
                     break;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
                 case add_blt_succ:
                     my_successors.internal_add_built_successor(*(current->my_succ));
                     __TBB_store_with_release(current->status, SUCCEEDED);
@@ -250,20 +252,20 @@ namespace internal {
                     my_successors.copy_successors(*(current->succv));
                     __TBB_store_with_release(current->status, SUCCEEDED);
                     break;
-#endif  /* TBB_PREVIEW_FLOW_GRAPH_FEATURES */
+#endif  /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
                 }
             }
         }
         // ---------- end aggregator -----------
     public:
         indexer_node_base(graph& g) : graph_node(g), input_ports_type() {
-            indexer_helper<StructTypes,N>::set_indexer_node_pointer(this->my_inputs, this);
+            indexer_helper<StructTypes,N>::set_indexer_node_pointer(this->my_inputs, this, g);
             my_successors.set_owner(this);
             my_aggregator.initialize_handler(handler_type(this));
         }
 
         indexer_node_base(const indexer_node_base& other) : graph_node(other.my_graph), input_ports_type(), sender<output_type>() {
-            indexer_helper<StructTypes,N>::set_indexer_node_pointer(this->my_inputs, this);
+            indexer_helper<StructTypes,N>::set_indexer_node_pointer(this->my_inputs, this, other.my_graph);
             my_successors.set_owner(this);
             my_aggregator.initialize_handler(handler_type(this));
         }
@@ -286,7 +288,7 @@ namespace internal {
             return op_data.bypass_t;
         }
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
 
         built_successors_type &built_successors() __TBB_override { return my_successors.built_successors(); }
 
@@ -315,7 +317,7 @@ namespace internal {
             my_successors.built_successors().sender_extract(*this);
             indexer_helper<StructTypes,N>::extract(this->my_inputs);
         }
-#endif /* TBB_PREVIEW_FLOW_GRAPH_FEATURES */
+#endif /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
     protected:
         void reset_node(reset_flags f) __TBB_override {
             if(f & rf_clear_edges) {
diff --git a/inst/include/tbb/internal/_flow_graph_item_buffer_impl.h b/inst/include/tbb/internal/_flow_graph_item_buffer_impl.h
index 85d2686d..e5a97d1c 100644
--- a/inst/include/tbb/internal/_flow_graph_item_buffer_impl.h
+++ b/inst/include/tbb/internal/_flow_graph_item_buffer_impl.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB__flow_graph_item_buffer_impl_H
@@ -48,8 +44,7 @@ namespace internal {
     protected:
         typedef size_t size_type;
         typedef typename aligned_pair<item_type, buffer_item_state>::type buffer_item_type;
-        typedef typename A::template rebind<buffer_item_type>::other allocator_type;
-
+        typedef typename tbb::internal::allocator_rebind<A, buffer_item_type>::type allocator_type;
         buffer_item_type *my_array;
         size_type my_array_size;
         static const size_type initial_buffer_size = 4;
@@ -144,7 +139,7 @@ namespace internal {
             return get_my_item(my_tail - 1);
         }
 
-        // following methods are for reservation of the front of a bufffer.
+        // following methods are for reservation of the front of a buffer.
         void reserve_item(size_type i) { __TBB_ASSERT(my_item_valid(i) && !my_item_reserved(i), "item cannot be reserved"); item(i).second = reserved_item; }
         void release_item(size_type i) { __TBB_ASSERT(my_item_reserved(i), "item is not reserved"); item(i).second = has_item; }
 
diff --git a/inst/include/tbb/internal/_flow_graph_join_impl.h b/inst/include/tbb/internal/_flow_graph_join_impl.h
index 4999bef7..16837c7a 100644
--- a/inst/include/tbb/internal/_flow_graph_join_impl.h
+++ b/inst/include/tbb/internal/_flow_graph_join_impl.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB__flow_graph_join_impl_H
@@ -27,21 +23,21 @@
 
 namespace internal {
 
-    struct forwarding_base {
-        forwarding_base(graph &g) : graph_pointer(&g) {}
+    struct forwarding_base : tbb::internal::no_assign {
+        forwarding_base(graph &g) : graph_ref(g) {}
         virtual ~forwarding_base() {}
         // decrement_port_count may create a forwarding task.  If we cannot handle the task
         // ourselves, ask decrement_port_count to deal with it.
         virtual task * decrement_port_count(bool handle_task) = 0;
         virtual void increment_port_count() = 0;
         // moved here so input ports can queue tasks
-        graph* graph_pointer;
+        graph& graph_ref;
     };
 
     // specialization that lets us keep a copy of the current_key for building results.
     // KeyType can be a reference type.
     template<typename KeyType>
-    struct matching_forwarding_base :public forwarding_base {
+    struct matching_forwarding_base : public forwarding_base {
         typedef typename tbb::internal::strip<KeyType>::type current_key_type;
         matching_forwarding_base(graph &g) : forwarding_base(g) { }
         virtual task * increment_key_count(current_key_type const & /*t*/, bool /*handle_task*/) = 0; // {return NULL;}
@@ -126,7 +122,7 @@ namespace internal {
             tbb::flow::get<N-1>(my_input).reset_receiver(f);
         }
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
         template<typename InputTuple>
         static inline void extract_inputs(InputTuple &my_input) {
             join_helper<N-1>::extract_inputs(my_input);
@@ -200,7 +196,7 @@ namespace internal {
             tbb::flow::get<0>(my_input).reset_receiver(f);
         }
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
         template<typename InputTuple>
         static inline void extract_inputs(InputTuple &my_input) {
             tbb::flow::get<0>(my_input).extract_receiver();
@@ -214,18 +210,17 @@ namespace internal {
     public:
         typedef T input_type;
         typedef typename receiver<input_type>::predecessor_type predecessor_type;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
         typedef typename receiver<input_type>::predecessor_list_type predecessor_list_type;
         typedef typename receiver<input_type>::built_predecessors_type built_predecessors_type;
 #endif
     private:
         // ----------- Aggregator ------------
         enum op_type { reg_pred, rem_pred, res_item, rel_res, con_res
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
             , add_blt_pred, del_blt_pred, blt_pred_cnt, blt_pred_cpy
 #endif
         };
-        enum op_stat {WAIT=0, SUCCEEDED, FAILED};
         typedef reserving_port<T> class_type;
 
         class reserving_port_operation : public aggregated_operation<reserving_port_operation> {
@@ -234,7 +229,7 @@ namespace internal {
             union {
                 T *my_arg;
                 predecessor_type *my_pred;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
                 size_t cnt_val;
                 predecessor_list_type *plist;
 #endif
@@ -294,7 +289,7 @@ namespace internal {
                     my_predecessors.try_consume( );
                     __TBB_store_with_release(current->status, SUCCEEDED);
                     break;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
                 case add_blt_pred:
                     my_predecessors.internal_add_built_predecessor(*(current->my_pred));
                     __TBB_store_with_release(current->status, SUCCEEDED);
@@ -311,7 +306,7 @@ namespace internal {
                     my_predecessors.copy_predecessors(*(current->plist));
                     __TBB_store_with_release(current->status, SUCCEEDED);
                     break;
-#endif  /* TBB_PREVIEW_FLOW_GRAPH_FEATURES */
+#endif  /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
                 }
             }
         }
@@ -324,6 +319,10 @@ namespace internal {
             return NULL;
         }
 
+        graph& graph_reference() const __TBB_override {
+            return my_join->graph_ref;
+        }
+
     public:
 
         //! Constructor
@@ -378,7 +377,7 @@ namespace internal {
             my_aggregator.execute(&op_data);
         }
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
         built_predecessors_type &built_predecessors() __TBB_override { return my_predecessors.built_predecessors(); }
         void internal_add_built_predecessor(predecessor_type &src) __TBB_override {
             reserving_port_operation op_data(src, add_blt_pred);
@@ -406,7 +405,7 @@ namespace internal {
             my_predecessors.built_predecessors().receiver_extract(*this);
         }
 
-#endif  /* TBB_PREVIEW_FLOW_GRAPH_FEATURES */
+#endif  /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
 
         void reset_receiver( reset_flags f) __TBB_override {
             if(f & rf_clear_edges) my_predecessors.clear();
@@ -417,6 +416,10 @@ namespace internal {
         }
 
     private:
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+        friend class get_graph_helper;
+#endif
+
         forwarding_base *my_join;
         reservable_predecessor_cache< T, null_mutex > my_predecessors;
         bool reserved;
@@ -429,7 +432,7 @@ namespace internal {
         typedef T input_type;
         typedef typename receiver<input_type>::predecessor_type predecessor_type;
         typedef queueing_port<T> class_type;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
         typedef typename receiver<input_type>::built_predecessors_type built_predecessors_type;
         typedef typename receiver<input_type>::predecessor_list_type predecessor_list_type;
 #endif
@@ -437,18 +440,17 @@ namespace internal {
     // ----------- Aggregator ------------
     private:
         enum op_type { get__item, res_port, try__put_task
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
             , add_blt_pred, del_blt_pred, blt_pred_cnt, blt_pred_cpy
 #endif
         };
-        enum op_stat {WAIT=0, SUCCEEDED, FAILED};
 
         class queueing_port_operation : public aggregated_operation<queueing_port_operation> {
         public:
             char type;
             T my_val;
             T *my_arg;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
             predecessor_type *pred;
             size_t cnt_val;
             predecessor_list_type *plist;
@@ -509,7 +511,7 @@ namespace internal {
                     }
                     __TBB_store_with_release(current->status, SUCCEEDED);
                     break;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
                 case add_blt_pred:
                     my_built_predecessors.add_edge(*(current->pred));
                     __TBB_store_with_release(current->status, SUCCEEDED);
@@ -526,7 +528,7 @@ namespace internal {
                     my_built_predecessors.copy_edges(*(current->plist));
                     __TBB_store_with_release(current->status, SUCCEEDED);
                     break;
-#endif  /* TBB_PREVIEW_FLOW_GRAPH_FEATURES */
+#endif  /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
                 }
             }
         }
@@ -544,6 +546,10 @@ namespace internal {
             return op_data.bypass_t;
         }
 
+        graph& graph_reference() const __TBB_override {
+            return my_join->graph_ref;
+        }
+
     public:
 
         //! Constructor
@@ -577,7 +583,7 @@ namespace internal {
             return;
         }
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
         built_predecessors_type &built_predecessors() __TBB_override { return my_built_predecessors; }
 
         void internal_add_built_predecessor(predecessor_type &p) __TBB_override {
@@ -608,20 +614,24 @@ namespace internal {
             item_buffer<T>::reset();
             my_built_predecessors.receiver_extract(*this);
         }
-#endif  /* TBB_PREVIEW_FLOW_GRAPH_FEATURES */
+#endif  /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
 
         void reset_receiver(reset_flags f) __TBB_override {
             tbb::internal::suppress_unused_warning(f);
             item_buffer<T>::reset();
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
             if (f & rf_clear_edges)
                 my_built_predecessors.clear();
 #endif
         }
 
     private:
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+        friend class get_graph_helper;
+#endif
+
         forwarding_base *my_join;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
         edge_container<predecessor_type> my_built_predecessors;
 #endif
     };  // queueing_port
@@ -659,7 +669,7 @@ namespace internal {
         typedef typename TraitsType::TtoK type_to_key_func_type;
         typedef typename TraitsType::KHash hash_compare_type;
         typedef hash_buffer< key_type, input_type, type_to_key_func_type, hash_compare_type > buffer_type;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
         typedef typename receiver<input_type>::built_predecessors_type built_predecessors_type;
         typedef typename receiver<input_type>::predecessor_list_type predecessor_list_type;
 #endif
@@ -667,18 +677,17 @@ namespace internal {
 // ----------- Aggregator ------------
     private:
         enum op_type { try__put, get__item, res_port
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
            , add_blt_pred, del_blt_pred, blt_pred_cnt, blt_pred_cpy
 #endif
         };
-        enum op_stat {WAIT=0, SUCCEEDED, FAILED};
 
         class key_matching_port_operation : public aggregated_operation<key_matching_port_operation> {
         public:
             char type;
             input_type my_val;
             input_type *my_arg;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
             predecessor_type *pred;
             size_t cnt_val;
             predecessor_list_type *plist;
@@ -721,7 +730,7 @@ namespace internal {
                     this->delete_with_key(my_join->current_key);
                     __TBB_store_with_release(current->status, SUCCEEDED);
                     break;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
                 case add_blt_pred:
                     my_built_predecessors.add_edge(*(current->pred));
                     __TBB_store_with_release(current->status, SUCCEEDED);
@@ -759,6 +768,10 @@ namespace internal {
             return rtask;
         }
 
+        graph& graph_reference() const __TBB_override {
+            return my_join->graph_ref;
+        }
+
     public:
 
         key_matching_port() : receiver<input_type>(), buffer_type() {
@@ -789,7 +802,7 @@ namespace internal {
             return op_data.status == SUCCEEDED;
         }
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
         built_predecessors_type &built_predecessors() __TBB_override { return my_built_predecessors; }
 
         void internal_add_built_predecessor(predecessor_type &p) __TBB_override {
@@ -825,7 +838,7 @@ namespace internal {
             return;
         }
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
         void extract_receiver() {
             buffer_type::reset();
             my_built_predecessors.receiver_extract(*this);
@@ -834,7 +847,7 @@ namespace internal {
         void reset_receiver(reset_flags f ) __TBB_override {
             tbb::internal::suppress_unused_warning(f);
             buffer_type::reset();
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
            if (f & rf_clear_edges)
               my_built_predecessors.clear();
 #endif
@@ -844,7 +857,7 @@ namespace internal {
         // my_join forwarding base used to count number of inputs that
         // received key.
         matching_forwarding_base<key_type> *my_join;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
         edge_container<predecessor_type> my_built_predecessors;
 #endif
     };  // key_matching_port
@@ -871,7 +884,7 @@ namespace internal {
             join_helper<N>::set_join_node_pointer(my_inputs, this);
         }
 
-        join_node_FE(const join_node_FE& other) : forwarding_base(*(other.forwarding_base::graph_pointer)), my_node(NULL) {
+        join_node_FE(const join_node_FE& other) : forwarding_base((other.forwarding_base::graph_ref)), my_node(NULL) {
             ports_with_no_inputs = N;
             join_helper<N>::set_join_node_pointer(my_inputs, this);
         }
@@ -885,11 +898,11 @@ namespace internal {
         // if all input_ports have predecessors, spawn forward to try and consume tuples
         task * decrement_port_count(bool handle_task) __TBB_override {
             if(ports_with_no_inputs.fetch_and_decrement() == 1) {
-                if(this->graph_pointer->is_active()) {
-                    task *rtask = new ( task::allocate_additional_child_of( *(this->graph_pointer->root_task()) ) )
+                if(internal::is_graph_active(this->graph_ref)) {
+                    task *rtask = new ( task::allocate_additional_child_of( *(this->graph_ref.root_task()) ) )
                         forward_task_bypass<base_node_type>(*my_node);
                     if(!handle_task) return rtask;
-                    FLOW_SPAWN(*rtask);
+                    internal::spawn_in_graph_arena(this->graph_ref, *rtask);
                 }
             }
             return NULL;
@@ -905,7 +918,7 @@ namespace internal {
             join_helper<N>::reset_inputs(my_inputs, f);
         }
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
         void extract( ) {
             // called outside of parallel contexts
             ports_with_no_inputs = N;
@@ -949,7 +962,7 @@ namespace internal {
             join_helper<N>::set_join_node_pointer(my_inputs, this);
         }
 
-        join_node_FE(const join_node_FE& other) : forwarding_base(*(other.forwarding_base::graph_pointer)), my_node(NULL) {
+        join_node_FE(const join_node_FE& other) : forwarding_base((other.forwarding_base::graph_ref)), my_node(NULL) {
             ports_with_no_items = N;
             join_helper<N>::set_join_node_pointer(my_inputs, this);
         }
@@ -965,11 +978,11 @@ namespace internal {
         task * decrement_port_count(bool handle_task) __TBB_override
         {
             if(ports_with_no_items.fetch_and_decrement() == 1) {
-                if(this->graph_pointer->is_active()) {
-                    task *rtask = new ( task::allocate_additional_child_of( *(this->graph_pointer->root_task()) ) )
+                if(internal::is_graph_active(this->graph_ref)) {
+                    task *rtask = new ( task::allocate_additional_child_of( *(this->graph_ref.root_task()) ) )
                         forward_task_bypass <base_node_type>(*my_node);
                     if(!handle_task) return rtask;
-                    FLOW_SPAWN( *rtask);
+                    internal::spawn_in_graph_arena(this->graph_ref, *rtask);
                 }
             }
             return NULL;
@@ -986,7 +999,7 @@ namespace internal {
             join_helper<N>::reset_inputs(my_inputs, f );
         }
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
         void extract() {
             reset_port_count();
             join_helper<N>::extract_inputs(my_inputs);
@@ -1055,7 +1068,6 @@ namespace internal {
         // and the output_buffer_type base class
     private:
         enum op_type { res_count, inc_count, may_succeed, try_make };
-        enum op_stat {WAIT=0, SUCCEEDED, FAILED};
         typedef join_node_FE<key_matching<key_type,key_hash_compare>, InputTuple, OutputTuple> class_type;
 
         class key_matching_FE_operation : public aggregated_operation<key_matching_FE_operation> {
@@ -1084,16 +1096,16 @@ namespace internal {
         task * fill_output_buffer(unref_key_type &t, bool should_enqueue, bool handle_task) {
             output_type l_out;
             task *rtask = NULL;
-            bool do_fwd = should_enqueue && this->buffer_empty() && this->graph_pointer->is_active();
+            bool do_fwd = should_enqueue && this->buffer_empty() && internal::is_graph_active(this->graph_ref);
             this->current_key = t;
             this->delete_with_key(this->current_key);   // remove the key
             if(join_helper<N>::get_items(my_inputs, l_out)) {  //  <== call back
                 this->push_back(l_out);
                 if(do_fwd) {  // we enqueue if receiving an item from predecessor, not if successor asks for item
-                    rtask = new ( task::allocate_additional_child_of( *(this->graph_pointer->root_task()) ) )
+                    rtask = new ( task::allocate_additional_child_of( *(this->graph_ref.root_task()) ) )
                         forward_task_bypass<base_node_type>(*my_node);
                     if(handle_task) {
-                        FLOW_SPAWN(*rtask);
+                        internal::spawn_in_graph_arena(this->graph_ref, *rtask);
                         rtask = NULL;
                     }
                     do_fwd = false;
@@ -1167,7 +1179,7 @@ namespace internal {
             this->set_key_func(cfb);
         }
 
-        join_node_FE(const join_node_FE& other) : forwarding_base_type(*(other.forwarding_base_type::graph_pointer)), key_to_count_buffer_type(),
+        join_node_FE(const join_node_FE& other) : forwarding_base_type((other.forwarding_base_type::graph_ref)), key_to_count_buffer_type(),
         output_buffer_type() {
             my_node = NULL;
             join_helper<N>::set_join_node_pointer(my_inputs, this);
@@ -1210,7 +1222,7 @@ namespace internal {
             output_buffer_type::reset();
         }
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
         void extract() {
             // called outside of parallel contexts
             join_helper<N>::extract_inputs(my_inputs);
@@ -1262,7 +1274,7 @@ namespace internal {
         using input_ports_type::try_to_make_tuple;
         using input_ports_type::tuple_accepted;
         using input_ports_type::tuple_rejected;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
         typedef typename sender<output_type>::built_successors_type built_successors_type;
         typedef typename sender<output_type>::successor_list_type successor_list_type;
 #endif
@@ -1270,11 +1282,10 @@ namespace internal {
     private:
         // ----------- Aggregator ------------
         enum op_type { reg_succ, rem_succ, try__get, do_fwrd, do_fwrd_bypass
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
             , add_blt_succ, del_blt_succ, blt_succ_cnt, blt_succ_cpy
 #endif
         };
-        enum op_stat {WAIT=0, SUCCEEDED, FAILED};
         typedef join_node_base<JP,InputTuple,OutputTuple> class_type;
 
         class join_node_base_operation : public aggregated_operation<join_node_base_operation> {
@@ -1283,7 +1294,7 @@ namespace internal {
             union {
                 output_type *my_arg;
                 successor_type *my_succ;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
                 size_t cnt_val;
                 successor_list_type *slist;
 #endif
@@ -1309,11 +1320,11 @@ namespace internal {
                 switch(current->type) {
                 case reg_succ: {
                         my_successors.register_successor(*(current->my_succ));
-                        if(tuple_build_may_succeed() && !forwarder_busy && this->graph_node::my_graph.is_active()) {
-                            task *rtask = new ( task::allocate_additional_child_of(*(this->graph_node::my_graph.root_task())) )
+                        if(tuple_build_may_succeed() && !forwarder_busy && internal::is_graph_active(my_graph)) {
+                            task *rtask = new ( task::allocate_additional_child_of(*(my_graph.root_task())) )
                                     forward_task_bypass
                                     <join_node_base<JP,InputTuple,OutputTuple> >(*this);
-                            FLOW_SPAWN(*rtask);
+                            internal::spawn_in_graph_arena(my_graph, *rtask);
                             forwarder_busy = true;
                         }
                         __TBB_store_with_release(current->status, SUCCEEDED);
@@ -1342,7 +1353,7 @@ namespace internal {
                                 build_succeeded = try_to_make_tuple(out);  // fetch front_end of queue
                                 if(build_succeeded) {
                                     task *new_task = my_successors.try_put_task(out);
-                                    last_task = combine_tasks(last_task, new_task);
+                                    last_task = combine_tasks(my_graph, last_task, new_task);
                                     if(new_task) {
                                         tuple_accepted();
                                     }
@@ -1358,7 +1369,7 @@ namespace internal {
                         forwarder_busy = false;
                     }
                     break;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
                 case add_blt_succ:
                     my_successors.internal_add_built_successor(*(current->my_succ));
                     __TBB_store_with_release(current->status, SUCCEEDED);
@@ -1375,7 +1386,7 @@ namespace internal {
                     my_successors.copy_successors(*(current->slist));
                     __TBB_store_with_release(current->status, SUCCEEDED);
                     break;
-#endif  /* TBB_PREVIEW_FLOW_GRAPH_FEATURES */
+#endif  /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
                 }
             }
         }
@@ -1420,7 +1431,7 @@ namespace internal {
             return op_data.status == SUCCEEDED;
         }
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
         built_successors_type &built_successors() __TBB_override { return my_successors.built_successors(); }
 
         void internal_add_built_successor( successor_type &r) __TBB_override {
@@ -1444,9 +1455,9 @@ namespace internal {
             op_data.slist = &l;
             my_aggregator.execute(&op_data);
         }
-#endif  /* TBB_PREVIEW_FLOW_GRAPH_FEATURES */
+#endif  /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
         void extract() __TBB_override {
             input_ports_type::extract();
             my_successors.built_successors().sender_extract(*this);
diff --git a/inst/include/tbb/internal/_flow_graph_node_impl.h b/inst/include/tbb/internal/_flow_graph_node_impl.h
index eeff72bc..dbc56ecd 100644
--- a/inst/include/tbb/internal/_flow_graph_node_impl.h
+++ b/inst/include/tbb/internal/_flow_graph_node_impl.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB__flow_graph_node_impl_H
@@ -61,15 +57,15 @@ namespace internal {
     //! Input and scheduling for a function node that takes a type Input as input
     //  The only up-ref is apply_body_impl, which should implement the function
     //  call and any handling of the result.
-    template< typename Input, typename A, typename ImplType >
+    template< typename Input, typename Policy, typename A, typename ImplType >
     class function_input_base : public receiver<Input>, tbb::internal::no_assign {
-        enum op_type {reg_pred, rem_pred, app_body, try_fwd, tryput_bypass, app_body_bypass
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+        enum op_type {reg_pred, rem_pred, try_fwd, tryput_bypass, app_body_bypass, occupy_concurrency
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
             , add_blt_pred, del_blt_pred,
             blt_pred_cnt, blt_pred_cpy   // create vector copies of preds and succs
 #endif
         };
-        typedef function_input_base<Input, A, ImplType> class_type;
+        typedef function_input_base<Input, Policy, A, ImplType> class_type;
 
     public:
 
@@ -78,26 +74,33 @@ namespace internal {
         typedef typename receiver<input_type>::predecessor_type predecessor_type;
         typedef predecessor_cache<input_type, null_mutex > predecessor_cache_type;
         typedef function_input_queue<input_type, A> input_queue_type;
-        typedef typename A::template rebind< input_queue_type >::other queue_allocator_type;
+        typedef typename tbb::internal::allocator_rebind<A, input_queue_type>::type queue_allocator_type;
+        __TBB_STATIC_ASSERT(!((internal::has_policy<queueing, Policy>::value) && (internal::has_policy<rejecting, Policy>::value)),
+                              "queueing and rejecting policies can't be specified simultaneously");
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
         typedef typename predecessor_cache_type::built_predecessors_type built_predecessors_type;
         typedef typename receiver<input_type>::predecessor_list_type predecessor_list_type;
 #endif
 
         //! Constructor for function_input_base
-        function_input_base( graph &g, size_t max_concurrency, input_queue_type *q = NULL)
-            : my_graph_ptr(&g), my_max_concurrency(max_concurrency), my_concurrency(0),
-              my_queue(q), forwarder_busy(false) {
+        function_input_base(
+            graph &g, __TBB_FLOW_GRAPH_PRIORITY_ARG1(size_t max_concurrency, node_priority_t priority)
+        ) : my_graph_ref(g), my_max_concurrency(max_concurrency)
+          , __TBB_FLOW_GRAPH_PRIORITY_ARG1(my_concurrency(0), my_priority(priority))
+          , my_queue(!internal::has_policy<rejecting, Policy>::value ? new input_queue_type() : NULL)
+          , forwarder_busy(false)
+        {
             my_predecessors.set_owner(this);
             my_aggregator.initialize_handler(handler_type(this));
         }
 
         //! Copy constructor
-        function_input_base( const function_input_base& src, input_queue_type *q = NULL) :
-            receiver<Input>(), tbb::internal::no_assign(),
-            my_graph_ptr(src.my_graph_ptr), my_max_concurrency(src.my_max_concurrency),
-            my_concurrency(0), my_queue(q), forwarder_busy(false)
+        function_input_base( const function_input_base& src)
+            : receiver<Input>(), tbb::internal::no_assign()
+            , my_graph_ref(src.my_graph_ref), my_max_concurrency(src.my_max_concurrency)
+            , __TBB_FLOW_GRAPH_PRIORITY_ARG1(my_concurrency(0), my_priority(src.my_priority))
+            , my_queue(src.my_queue ? new input_queue_type() : NULL), forwarder_busy(false)
         {
             my_predecessors.set_owner(this);
             my_aggregator.initialize_handler(handler_type(this));
@@ -111,18 +114,8 @@ namespace internal {
             if ( my_queue ) delete my_queue;
         }
 
-        //! Put to the node, returning a task if available
-        task * try_put_task( const input_type &t ) __TBB_override {
-           if ( my_max_concurrency == 0 ) {
-               return create_body_task( t );
-           } else {
-               operation_type op_data(t, tryput_bypass);
-               my_aggregator.execute(&op_data);
-               if(op_data.status == internal::SUCCEEDED) {
-                   return op_data.bypass_t;
-               }
-               return NULL;
-           }
+        task* try_put_task( const input_type& t) __TBB_override {
+            return try_put_task_impl(t, internal::has_policy<lightweight, Policy>());
         }
 
         //! Adds src to the list of cached predecessors.
@@ -141,7 +134,7 @@ namespace internal {
             return true;
         }
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
         //! Adds to list of predecessors added by make_edge
         void internal_add_built_predecessor( predecessor_type &src) __TBB_override {
             operation_type op_data(add_blt_pred);
@@ -171,7 +164,7 @@ namespace internal {
         built_predecessors_type &built_predecessors() __TBB_override {
             return my_predecessors.built_predecessors();
         }
-#endif  /* TBB_PREVIEW_FLOW_GRAPH_FEATURES */
+#endif  /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
 
     protected:
 
@@ -184,9 +177,10 @@ namespace internal {
             forwarder_busy = false;
         }
 
-        graph* my_graph_ptr;
+        graph& my_graph_ref;
         const size_t my_max_concurrency;
         size_t my_concurrency;
+        __TBB_FLOW_GRAPH_PRIORITY_EXPR( node_priority_t my_priority; )
         input_queue_type *my_queue;
         predecessor_cache<input_type, null_mutex > my_predecessors;
 
@@ -197,6 +191,16 @@ namespace internal {
             __TBB_ASSERT(!(f & rf_clear_edges) || my_predecessors.empty(), "function_input_base reset failed");
         }
 
+        graph& graph_reference() const __TBB_override {
+            return my_graph_ref;
+        }
+
+        task* try_get_postponed_task(const input_type& i) {
+            operation_type op_data(i, app_body_bypass);  // tries to pop an item or get_item
+            my_aggregator.execute(&op_data);
+            return op_data.bypass_t;
+        }
+
     private:
 
         friend class apply_body_task_bypass< class_type, input_type >;
@@ -208,10 +212,10 @@ namespace internal {
             union {
                 input_type *elem;
                 predecessor_type *r;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
                 size_t cnt_val;
                 predecessor_list_type *predv;
-#endif  /* TBB_PREVIEW_FLOW_GRAPH_FEATURES */
+#endif  /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
             };
             tbb::task *bypass_t;
             operation_type(const input_type& e, op_type t) :
@@ -224,7 +228,7 @@ namespace internal {
         friend class internal::aggregating_functor<class_type, operation_type>;
         aggregator< handler_type, operation_type > my_aggregator;
 
-        task* create_and_spawn_task(bool spawn) {
+        task* perform_queued_requests() {
             task* new_task = NULL;
             if(my_queue) {
                 if(!my_queue->empty()) {
@@ -241,13 +245,6 @@ namespace internal {
                     new_task = create_body_task(i);
                 }
             }
-            //! Spawns a task that applies a body
-            // task == NULL => g.reset(), which shouldn't occur in concurrent context
-            if(spawn && new_task) {
-                FLOW_SPAWN(*new_task);
-                new_task = SUCCESSFULLY_ENQUEUED;
-            }
-
             return new_task;
         }
         void handle_operations(operation_type *op_list) {
@@ -268,27 +265,27 @@ namespace internal {
                     my_predecessors.remove(*(tmp->r));
                     __TBB_store_with_release(tmp->status, SUCCEEDED);
                     break;
-                case app_body:
-                    __TBB_ASSERT(my_max_concurrency != 0, NULL);
-                    --my_concurrency;
-                    __TBB_store_with_release(tmp->status, SUCCEEDED);
-                    if (my_concurrency<my_max_concurrency) {
-                        create_and_spawn_task(/*spawn=*/true);
-                    }
-                    break;
                 case app_body_bypass: {
                         tmp->bypass_t = NULL;
                         __TBB_ASSERT(my_max_concurrency != 0, NULL);
                         --my_concurrency;
                         if(my_concurrency<my_max_concurrency)
-                            tmp->bypass_t = create_and_spawn_task(/*spawn=*/false);
+                            tmp->bypass_t = perform_queued_requests();
 
                         __TBB_store_with_release(tmp->status, SUCCEEDED);
                     }
                     break;
                 case tryput_bypass: internal_try_put_task(tmp);  break;
                 case try_fwd: internal_forward(tmp);  break;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+                case occupy_concurrency:
+                    if (my_concurrency < my_max_concurrency) {
+                        ++my_concurrency;
+                        __TBB_store_with_release(tmp->status, SUCCEEDED);
+                    } else {
+                        __TBB_store_with_release(tmp->status, FAILED);
+                    }
+                    break;
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
                 case add_blt_pred: {
                          my_predecessors.internal_add_built_predecessor(*(tmp->r));
                         __TBB_store_with_release(tmp->status, SUCCEEDED);
@@ -306,7 +303,7 @@ namespace internal {
                     my_predecessors.copy_predecessors( *(tmp->predv) );
                     __TBB_store_with_release(tmp->status, SUCCEEDED);
                     break;
-#endif  /* TBB_PREVIEW_FLOW_GRAPH_FEATURES */
+#endif  /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
                 }
             }
         }
@@ -328,11 +325,11 @@ namespace internal {
            }
         }
 
-        //! Tries to spawn bodies if available and if concurrency allows
+        //! Creates tasks for postponed messages if available and if concurrency allows
         void internal_forward(operation_type *op) {
             op->bypass_t = NULL;
             if (my_concurrency < my_max_concurrency || !my_max_concurrency)
-                op->bypass_t = create_and_spawn_task(/*spawn=*/false);
+                op->bypass_t = perform_queued_requests();
             if(op->bypass_t)
                 __TBB_store_with_release(op->status, SUCCEEDED);
             else {
@@ -341,81 +338,108 @@ namespace internal {
             }
         }
 
+        task* internal_try_put_bypass( const input_type& t ) {
+            operation_type op_data(t, tryput_bypass);
+            my_aggregator.execute(&op_data);
+            if( op_data.status == internal::SUCCEEDED ) {
+                return op_data.bypass_t;
+            }
+            return NULL;
+        }
+
+        task* try_put_task_impl( const input_type& t, /*lightweight=*/tbb::internal::true_type ) {
+            if( my_max_concurrency == 0 ) {
+                return apply_body_bypass(t);
+            } else {
+                operation_type check_op(t, occupy_concurrency);
+                my_aggregator.execute(&check_op);
+                if( check_op.status == internal::SUCCEEDED ) {
+                    return apply_body_bypass(t);
+                }
+                return internal_try_put_bypass(t);
+            }
+        }
+
+        task* try_put_task_impl( const input_type& t, /*lightweight=*/tbb::internal::false_type ) {
+            if( my_max_concurrency == 0 ) {
+                return create_body_task(t);
+            } else {
+                return internal_try_put_bypass(t);
+            }
+        }
+
         //! Applies the body to the provided input
         //  then decides if more work is available
-        task * apply_body_bypass( input_type &i ) {
-            task * new_task = static_cast<ImplType *>(this)->apply_body_impl_bypass(i);
-            if ( my_max_concurrency != 0 ) {
-                operation_type op_data(app_body_bypass);  // tries to pop an item or get_item, enqueues another apply_body
-                my_aggregator.execute(&op_data);
-                tbb::task *ttask = op_data.bypass_t;
-                new_task = combine_tasks(new_task, ttask);
-            }
-            return new_task;
+        task * apply_body_bypass( const input_type &i ) {
+            return static_cast<ImplType *>(this)->apply_body_impl_bypass(i);
         }
 
         //! allocates a task to apply a body
         inline task * create_body_task( const input_type &input ) {
-
-            return (my_graph_ptr->is_active()) ?
-                new(task::allocate_additional_child_of(*(my_graph_ptr->root_task())))
-                    apply_body_task_bypass < class_type, input_type >(*this, input) :
-                NULL;
+            return (internal::is_graph_active(my_graph_ref)) ?
+                new( task::allocate_additional_child_of(*(my_graph_ref.root_task())) )
+                apply_body_task_bypass < class_type, input_type >(
+                    *this, __TBB_FLOW_GRAPH_PRIORITY_ARG1(input, my_priority))
+                : NULL;
         }
 
        //! This is executed by an enqueued task, the "forwarder"
-       task *forward_task() {
+       task* forward_task() {
            operation_type op_data(try_fwd);
-           task *rval = NULL;
+           task* rval = NULL;
            do {
                op_data.status = WAIT;
                my_aggregator.execute(&op_data);
                if(op_data.status == SUCCEEDED) {
-                   tbb::task *ttask = op_data.bypass_t;
-                   rval = combine_tasks(rval, ttask);
+                   task* ttask = op_data.bypass_t;
+                   __TBB_ASSERT( ttask && ttask != SUCCESSFULLY_ENQUEUED, NULL );
+                   rval = combine_tasks(my_graph_ref, rval, ttask);
                }
            } while (op_data.status == SUCCEEDED);
            return rval;
        }
 
        inline task *create_forward_task() {
-           return (my_graph_ptr->is_active()) ?
-               new(task::allocate_additional_child_of(*(my_graph_ptr->root_task()))) forward_task_bypass< class_type >(*this) :
-               NULL;
+           return (internal::is_graph_active(my_graph_ref)) ?
+               new( task::allocate_additional_child_of(*(my_graph_ref.root_task())) )
+               forward_task_bypass< class_type >( __TBB_FLOW_GRAPH_PRIORITY_ARG1(*this, my_priority) )
+               : NULL;
        }
 
        //! Spawns a task that calls forward()
        inline void spawn_forward_task() {
            task* tp = create_forward_task();
            if(tp) {
-               FLOW_SPAWN(*tp);
+               internal::spawn_in_graph_arena(graph_reference(), *tp);
            }
        }
     };  // function_input_base
 
     //! Implements methods for a function node that takes a type Input as input and sends
     //  a type Output to its successors.
-    template< typename Input, typename Output, typename A>
-    class function_input : public function_input_base<Input, A, function_input<Input,Output,A> > {
+    template< typename Input, typename Output, typename Policy, typename A>
+    class function_input : public function_input_base<Input, Policy, A, function_input<Input,Output,Policy,A> > {
     public:
         typedef Input input_type;
         typedef Output output_type;
         typedef function_body<input_type, output_type> function_body_type;
-        typedef function_input<Input,Output,A> my_class;
-        typedef function_input_base<Input, A, my_class> base_type;
+        typedef function_input<Input, Output, Policy,A> my_class;
+        typedef function_input_base<Input, Policy, A, my_class> base_type;
         typedef function_input_queue<input_type, A> input_queue_type;
 
         // constructor
         template<typename Body>
-        function_input( graph &g, size_t max_concurrency, Body& body, input_queue_type *q = NULL ) :
-            base_type(g, max_concurrency, q),
-            my_body( new internal::function_body_leaf< input_type, output_type, Body>(body) ),
-            my_init_body( new internal::function_body_leaf< input_type, output_type, Body>(body) ) {
+        function_input(
+            graph &g, size_t max_concurrency,
+            __TBB_FLOW_GRAPH_PRIORITY_ARG1(Body& body, node_priority_t priority)
+        ) : base_type(g, __TBB_FLOW_GRAPH_PRIORITY_ARG1(max_concurrency, priority))
+          , my_body( new internal::function_body_leaf< input_type, output_type, Body>(body) )
+          , my_init_body( new internal::function_body_leaf< input_type, output_type, Body>(body) ) {
         }
 
         //! Copy constructor
-        function_input( const function_input& src, input_queue_type *q = NULL ) :
-                base_type(src, q),
+        function_input( const function_input& src ) :
+                base_type(src),
                 my_body( src.my_init_body->clone() ),
                 my_init_body(src.my_init_body->clone() ) {
         }
@@ -431,18 +455,52 @@ namespace internal {
             return dynamic_cast< internal::function_body_leaf<input_type, output_type, Body> & >(body_ref).get_body();
         }
 
-        task * apply_body_impl_bypass( const input_type &i) {
-#if TBB_PREVIEW_FLOW_GRAPH_TRACE
+        output_type apply_body_impl( const input_type& i) {
             // There is an extra copied needed to capture the
             // body execution without the try_put
             tbb::internal::fgt_begin_body( my_body );
             output_type v = (*my_body)(i);
             tbb::internal::fgt_end_body( my_body );
-            task * new_task = successors().try_put_task( v );
+            return v;
+        }
+
+        //TODO: consider moving into the base class
+        task * apply_body_impl_bypass( const input_type &i) {
+            output_type v = apply_body_impl(i);
+#if TBB_DEPRECATED_MESSAGE_FLOW_ORDER
+            task* successor_task = successors().try_put_task(v);
+#endif
+            task* postponed_task = NULL;
+            if( base_type::my_max_concurrency != 0 ) {
+                postponed_task = base_type::try_get_postponed_task(i);
+                __TBB_ASSERT( !postponed_task || postponed_task != SUCCESSFULLY_ENQUEUED, NULL );
+            }
+#if TBB_DEPRECATED_MESSAGE_FLOW_ORDER
+            graph& g = base_type::my_graph_ref;
+            return combine_tasks(g, successor_task, postponed_task);
 #else
-            task * new_task = successors().try_put_task( (*my_body)(i) );
+            if( postponed_task ) {
+                // make the task available for other workers since we do not know successors'
+                // execution policy
+                internal::spawn_in_graph_arena(base_type::graph_reference(), *postponed_task);
+            }
+            task* successor_task = successors().try_put_task(v);
+#if _MSC_VER && !__INTEL_COMPILER
+#pragma warning (push)
+#pragma warning (disable: 4127)  /* suppress conditional expression is constant */
 #endif
-            return new_task;
+            if(internal::has_policy<lightweight, Policy>::value) {
+#if _MSC_VER && !__INTEL_COMPILER
+#pragma warning (pop)
+#endif
+                if(!successor_task) {
+                    // Return confirmative status since current
+                    // node's body has been executed anyway
+                    successor_task = SUCCESSFULLY_ENQUEUED;
+                }
+            }
+            return successor_task;
+#endif /* TBB_DEPRECATED_MESSAGE_FLOW_ORDER */
         }
 
     protected:
@@ -485,7 +543,7 @@ namespace internal {
         }
     };
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
     // helper templates to extract the output ports of an multifunction_node from graph
     template<int N> struct extract_element {
         template<typename P> static void extract_this(P &p) {
@@ -501,36 +559,108 @@ namespace internal {
     };
 #endif
 
+    template <typename OutputTuple>
+    struct init_output_ports {
+#if __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT
+        template <typename... Args>
+        static OutputTuple call(graph& g, const tbb::flow::tuple<Args...>&) {
+            return OutputTuple(Args(g)...);
+        }
+#else // __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT
+        template <typename T1>
+        static OutputTuple call(graph& g, const tbb::flow::tuple<T1>&) {
+            return OutputTuple(T1(g));
+        }
+
+        template <typename T1, typename T2>
+        static OutputTuple call(graph& g, const tbb::flow::tuple<T1, T2>&) {
+            return OutputTuple(T1(g), T2(g));
+        }
+
+        template <typename T1, typename T2, typename T3>
+        static OutputTuple call(graph& g, const tbb::flow::tuple<T1, T2, T3>&) {
+            return OutputTuple(T1(g), T2(g), T3(g));
+        }
+
+        template <typename T1, typename T2, typename T3, typename T4>
+        static OutputTuple call(graph& g, const tbb::flow::tuple<T1, T2, T3, T4>&) {
+            return OutputTuple(T1(g), T2(g), T3(g), T4(g));
+        }
+
+        template <typename T1, typename T2, typename T3, typename T4, typename T5>
+        static OutputTuple call(graph& g, const tbb::flow::tuple<T1, T2, T3, T4, T5>&) {
+            return OutputTuple(T1(g), T2(g), T3(g), T4(g), T5(g));
+        }
+#if __TBB_VARIADIC_MAX >= 6
+        template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
+        static OutputTuple call(graph& g, const tbb::flow::tuple<T1, T2, T3, T4, T5, T6>&) {
+            return OutputTuple(T1(g), T2(g), T3(g), T4(g), T5(g), T6(g));
+        }
+#endif
+#if __TBB_VARIADIC_MAX >= 7
+        template <typename T1, typename T2, typename T3, typename T4,
+                  typename T5, typename T6, typename T7>
+        static OutputTuple call(graph& g,
+                                const tbb::flow::tuple<T1, T2, T3, T4, T5, T6, T7>&) {
+            return OutputTuple(T1(g), T2(g), T3(g), T4(g), T5(g), T6(g), T7(g));
+        }
+#endif
+#if __TBB_VARIADIC_MAX >= 8
+        template <typename T1, typename T2, typename T3, typename T4,
+                  typename T5, typename T6, typename T7, typename T8>
+        static OutputTuple call(graph& g,
+                                const tbb::flow::tuple<T1, T2, T3, T4, T5, T6, T7, T8>&) {
+            return OutputTuple(T1(g), T2(g), T3(g), T4(g), T5(g), T6(g), T7(g), T8(g));
+        }
+#endif
+#if __TBB_VARIADIC_MAX >= 9
+        template <typename T1, typename T2, typename T3, typename T4,
+                  typename T5, typename T6, typename T7, typename T8, typename T9>
+        static OutputTuple call(graph& g,
+                                const tbb::flow::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9>&) {
+            return OutputTuple(T1(g), T2(g), T3(g), T4(g), T5(g), T6(g), T7(g), T8(g), T9(g));
+        }
+#endif
+#if __TBB_VARIADIC_MAX >= 9
+        template <typename T1, typename T2, typename T3, typename T4, typename T5,
+                  typename T6, typename T7, typename T8, typename T9, typename T10>
+        static OutputTuple call(graph& g,
+                                const tbb::flow::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>&) {
+            return OutputTuple(T1(g), T2(g), T3(g), T4(g), T5(g), T6(g), T7(g), T8(g), T9(g), T10(g));
+        }
+#endif
+#endif // __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT
+    }; // struct init_output_ports
+
     //! Implements methods for a function node that takes a type Input as input
     //  and has a tuple of output ports specified.
-    template< typename Input, typename OutputPortSet, typename A>
-    class multifunction_input : public function_input_base<Input, A, multifunction_input<Input,OutputPortSet,A> > {
+    template< typename Input, typename OutputPortSet, typename Policy, typename A>
+    class multifunction_input : public function_input_base<Input, Policy, A, multifunction_input<Input,OutputPortSet,Policy,A> > {
     public:
         static const int N = tbb::flow::tuple_size<OutputPortSet>::value;
         typedef Input input_type;
         typedef OutputPortSet output_ports_type;
         typedef multifunction_body<input_type, output_ports_type> multifunction_body_type;
-        typedef multifunction_input<Input,OutputPortSet,A> my_class;
-        typedef function_input_base<Input, A, my_class> base_type;
+        typedef multifunction_input<Input, OutputPortSet, Policy, A> my_class;
+        typedef function_input_base<Input, Policy, A, my_class> base_type;
         typedef function_input_queue<input_type, A> input_queue_type;
 
         // constructor
         template<typename Body>
-        multifunction_input(
-                graph &g,
-                size_t max_concurrency,
-                Body& body,
-                input_queue_type *q = NULL ) :
-            base_type(g, max_concurrency, q),
-            my_body( new internal::multifunction_body_leaf<input_type, output_ports_type, Body>(body) ),
-            my_init_body( new internal::multifunction_body_leaf<input_type, output_ports_type, Body>(body) ) {
+        multifunction_input(graph &g, size_t max_concurrency,
+                            __TBB_FLOW_GRAPH_PRIORITY_ARG1(Body& body, node_priority_t priority)
+        ) : base_type(g, __TBB_FLOW_GRAPH_PRIORITY_ARG1(max_concurrency, priority))
+          , my_body( new internal::multifunction_body_leaf<input_type, output_ports_type, Body>(body) )
+          , my_init_body( new internal::multifunction_body_leaf<input_type, output_ports_type, Body>(body) )
+          , my_output_ports(init_output_ports<output_ports_type>::call(g, my_output_ports)){
         }
 
         //! Copy constructor
-        multifunction_input( const multifunction_input& src, input_queue_type *q = NULL ) :
-                base_type(src, q),
+        multifunction_input( const multifunction_input& src ) :
+                base_type(src),
                 my_body( src.my_init_body->clone() ),
-                my_init_body(src.my_init_body->clone() ) {
+                my_init_body(src.my_init_body->clone() ),
+                my_output_ports( init_output_ports<output_ports_type>::call(src.my_graph_ref, my_output_ports) ) {
         }
 
         ~multifunction_input() {
@@ -546,18 +676,22 @@ namespace internal {
 
         // for multifunction nodes we do not have a single successor as such.  So we just tell
         // the task we were successful.
+        //TODO: consider moving common parts with implementation in function_input into separate function
         task * apply_body_impl_bypass( const input_type &i) {
             tbb::internal::fgt_begin_body( my_body );
             (*my_body)(i, my_output_ports);
             tbb::internal::fgt_end_body( my_body );
-            task * new_task = SUCCESSFULLY_ENQUEUED;
-            return new_task;
+            task* ttask = NULL;
+            if(base_type::my_max_concurrency != 0) {
+                ttask = base_type::try_get_postponed_task(i);
+            }
+            return ttask ? ttask : SUCCESSFULLY_ENQUEUED;
         }
 
         output_ports_type &output_ports(){ return my_output_ports; }
 
     protected:
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
         void extract() {
             extract_element<N>::extract_this(my_output_ports);
         }
@@ -586,26 +720,36 @@ namespace internal {
         return tbb::flow::get<N>(op.output_ports());
     }
 
-// helper structs for split_node
+    inline void check_task_and_spawn(graph& g, task* t) {
+        if (t && t != SUCCESSFULLY_ENQUEUED) {
+            internal::spawn_in_graph_arena(g, *t);
+        }
+    }
+
+    // helper structs for split_node
     template<int N>
     struct emit_element {
         template<typename T, typename P>
-        static void emit_this(const T &t, P &p) {
-            (void)tbb::flow::get<N-1>(p).try_put(tbb::flow::get<N-1>(t));
-            emit_element<N-1>::emit_this(t,p);
+        static task* emit_this(graph& g, const T &t, P &p) {
+            // TODO: consider to collect all the tasks in task_list and spawn them all at once
+            task* last_task = tbb::flow::get<N-1>(p).try_put_task(tbb::flow::get<N-1>(t));
+            check_task_and_spawn(g, last_task);
+            return emit_element<N-1>::emit_this(g,t,p);
         }
     };
 
     template<>
     struct emit_element<1> {
         template<typename T, typename P>
-        static void emit_this(const T &t, P &p) {
-            (void)tbb::flow::get<0>(p).try_put(tbb::flow::get<0>(t));
+        static task* emit_this(graph& g, const T &t, P &p) {
+            task* last_task = tbb::flow::get<0>(p).try_put_task(tbb::flow::get<0>(t));
+            check_task_and_spawn(g, last_task);
+            return SUCCESSFULLY_ENQUEUED;
         }
     };
 
     //! Implements methods for an executable node that takes continue_msg as input
-    template< typename Output >
+    template< typename Output, typename Policy>
     class continue_input : public continue_receiver {
     public:
 
@@ -615,22 +759,27 @@ namespace internal {
         //! The output type of this receiver
         typedef Output output_type;
         typedef function_body<input_type, output_type> function_body_type;
+        typedef continue_input<output_type, Policy> class_type;
 
         template< typename Body >
-        continue_input( graph &g, Body& body )
-            : my_graph_ptr(&g),
-             my_body( new internal::function_body_leaf< input_type, output_type, Body>(body) ),
-             my_init_body( new internal::function_body_leaf< input_type, output_type, Body>(body) ) { }
+        continue_input( graph &g, __TBB_FLOW_GRAPH_PRIORITY_ARG1(Body& body, node_priority_t priority) )
+            : continue_receiver(__TBB_FLOW_GRAPH_PRIORITY_ARG1(/*number_of_predecessors=*/0, priority))
+            , my_graph_ref(g)
+            , my_body( new internal::function_body_leaf< input_type, output_type, Body>(body) )
+            , my_init_body( new internal::function_body_leaf< input_type, output_type, Body>(body) )
+            { }
 
         template< typename Body >
-        continue_input( graph &g, int number_of_predecessors, Body& body )
-            : continue_receiver( number_of_predecessors ), my_graph_ptr(&g),
-             my_body( new internal::function_body_leaf< input_type, output_type, Body>(body) ),
-             my_init_body( new internal::function_body_leaf< input_type, output_type, Body>(body) )
+        continue_input( graph &g, int number_of_predecessors,
+                        __TBB_FLOW_GRAPH_PRIORITY_ARG1(Body& body, node_priority_t priority)
+        ) : continue_receiver( __TBB_FLOW_GRAPH_PRIORITY_ARG1(number_of_predecessors, priority) )
+          , my_graph_ref(g)
+          , my_body( new internal::function_body_leaf< input_type, output_type, Body>(body) )
+          , my_init_body( new internal::function_body_leaf< input_type, output_type, Body>(body) )
         { }
 
         continue_input( const continue_input& src ) : continue_receiver(src),
-            my_graph_ptr(src.my_graph_ptr),
+            my_graph_ref(src.my_graph_ref),
             my_body( src.my_init_body->clone() ),
             my_init_body( src.my_init_body->clone() ) {}
 
@@ -656,36 +805,48 @@ namespace internal {
 
     protected:
 
-        graph* my_graph_ptr;
+        graph& my_graph_ref;
         function_body_type *my_body;
         function_body_type *my_init_body;
 
         virtual broadcast_cache<output_type > &successors() = 0;
 
-        friend class apply_body_task_bypass< continue_input< Output >, continue_msg >;
+        friend class apply_body_task_bypass< class_type, continue_msg >;
 
         //! Applies the body to the provided input
         task *apply_body_bypass( input_type ) {
-#if TBB_PREVIEW_FLOW_GRAPH_TRACE
             // There is an extra copied needed to capture the
             // body execution without the try_put
             tbb::internal::fgt_begin_body( my_body );
             output_type v = (*my_body)( continue_msg() );
             tbb::internal::fgt_end_body( my_body );
             return successors().try_put_task( v );
-#else
-            return successors().try_put_task( (*my_body)( continue_msg() ) );
-#endif
         }
 
-        //! Spawns a task that applies the body
-        task *execute( ) __TBB_override {
-            return (my_graph_ptr->is_active()) ?
-                new ( task::allocate_additional_child_of( *(my_graph_ptr->root_task()) ) )
-                    apply_body_task_bypass< continue_input< Output >, continue_msg >( *this, continue_msg() ) :
-                NULL;
+        task* execute() __TBB_override {
+            if(!internal::is_graph_active(my_graph_ref)) {
+                return NULL;
+            }
+#if _MSC_VER && !__INTEL_COMPILER
+#pragma warning (push)
+#pragma warning (disable: 4127)  /* suppress conditional expression is constant */
+#endif
+            if(internal::has_policy<lightweight, Policy>::value) {
+#if _MSC_VER && !__INTEL_COMPILER
+#pragma warning (pop)
+#endif
+                return apply_body_bypass( continue_msg() );
+            }
+            else {
+                return new ( task::allocate_additional_child_of( *(my_graph_ref.root_task()) ) )
+                       apply_body_task_bypass< class_type, continue_msg >(
+                           *this, __TBB_FLOW_GRAPH_PRIORITY_ARG1(continue_msg(), my_priority) );
+            }
         }
 
+        graph& graph_reference() const __TBB_override {
+            return my_graph_ref;
+        }
     };  // continue_input
 
     //! Implements methods for both executable and function nodes that puts Output to its successors
@@ -697,13 +858,13 @@ namespace internal {
         typedef Output output_type;
         typedef typename sender<output_type>::successor_type successor_type;
         typedef broadcast_cache<output_type> broadcast_cache_type;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
         typedef typename sender<output_type>::built_successors_type built_successors_type;
         typedef typename sender<output_type>::successor_list_type successor_list_type;
 #endif
 
-        function_output() { my_successors.set_owner(this); }
-        function_output(const function_output & /*other*/) : sender<output_type>() {
+        function_output( graph& g) : my_graph_ref(g) { my_successors.set_owner(this); }
+        function_output(const function_output & other) : sender<output_type>(), my_graph_ref(other.my_graph_ref) {
             my_successors.set_owner(this);
         }
 
@@ -719,7 +880,7 @@ namespace internal {
             return true;
         }
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
         built_successors_type &built_successors() __TBB_override { return successors().built_successors(); }
 
 
@@ -738,7 +899,7 @@ namespace internal {
         void  copy_successors( successor_list_type &v) __TBB_override {
             successors().copy_successors(v);
         }
-#endif  /* TBB_PREVIEW_FLOW_GRAPH_FEATURES */
+#endif  /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
 
         // for multifunction_node.  The function_body that implements
         // the node will have an input and an output tuple of ports.  To put
@@ -753,9 +914,11 @@ namespace internal {
         }
 
         broadcast_cache_type &successors() { return my_successors; }
+
+        graph& graph_reference() const { return my_graph_ref; }
     protected:
         broadcast_cache_type my_successors;
-
+        graph& my_graph_ref;
     };  // function_output
 
     template< typename Output >
@@ -765,19 +928,32 @@ namespace internal {
         typedef function_output<output_type> base_type;
         using base_type::my_successors;
 
-        multifunction_output() : base_type() {my_successors.set_owner(this);}
-        multifunction_output( const multifunction_output &/*other*/) : base_type() { my_successors.set_owner(this); }
+        multifunction_output(graph& g) : base_type(g) {my_successors.set_owner(this);}
+        multifunction_output( const multifunction_output& other) : base_type(other.my_graph_ref) { my_successors.set_owner(this); }
 
         bool try_put(const output_type &i) {
-            task *res = my_successors.try_put_task(i);
+            task *res = try_put_task(i);
             if(!res) return false;
-            if(res != SUCCESSFULLY_ENQUEUED) FLOW_SPAWN(*res);
+            if(res != SUCCESSFULLY_ENQUEUED) {
+                FLOW_SPAWN(*res); // TODO: Spawn task inside arena
+            }
             return true;
         }
+
+        using base_type::graph_reference;
+
+    protected:
+
+        task* try_put_task(const output_type &i) {
+            return my_successors.try_put_task(i);
+        }
+
+        template <int N> friend struct emit_element;
+
     };  // multifunction_output
 
 //composite_node
-#if TBB_PREVIEW_FLOW_GRAPH_TRACE && __TBB_FLOW_GRAPH_CPP11_FEATURES
+#if __TBB_FLOW_GRAPH_CPP11_FEATURES
     template<typename CompositeType>
     void add_nodes_impl(CompositeType*, bool) {}
 
@@ -785,10 +961,7 @@ namespace internal {
     void add_nodes_impl(CompositeType *c_node, bool visible, const NodeType1& n1, const NodeTypes&... n) {
         void *addr = const_cast<NodeType1 *>(&n1);
 
-        if(visible)
-            tbb::internal::itt_relation_add( tbb::internal::ITT_DOMAIN_FLOW, c_node, tbb::internal::FLOW_NODE, tbb::internal::__itt_relation_is_parent_of, addr, tbb::internal::FLOW_NODE );
-        else
-            tbb::internal::itt_relation_add( tbb::internal::ITT_DOMAIN_FLOW, addr, tbb::internal::FLOW_NODE, tbb::internal::__itt_relation_is_child_of, c_node, tbb::internal::FLOW_NODE );
+        fgt_alias_port(c_node, addr, visible);
         add_nodes_impl(c_node, visible, n...);
     }
 #endif
diff --git a/inst/include/tbb/internal/_flow_graph_node_set_impl.h b/inst/include/tbb/internal/_flow_graph_node_set_impl.h
new file mode 100644
index 00000000..f5ec6d0e
--- /dev/null
+++ b/inst/include/tbb/internal/_flow_graph_node_set_impl.h
@@ -0,0 +1,269 @@
+/*
+    Copyright (c) 2019-2020 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.
+*/
+
+#ifndef __TBB_flow_graph_node_set_impl_H
+#define __TBB_flow_graph_node_set_impl_H
+
+#ifndef __TBB_flow_graph_H
+#error Do not #include this internal file directly; use public TBB headers instead.
+#endif
+
+// Included in namespace tbb::flow::interfaceX (in flow_graph.h)
+
+namespace internal {
+
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+// Visual Studio 2019 reports an error while calling predecessor_selector::get and successor_selector::get
+// Seems like the well-formed expression in trailing decltype is treated as ill-formed
+// TODO: investigate problems with decltype in trailing return types or find the cross-platform solution
+#define __TBB_MSVC_DISABLE_TRAILING_DECLTYPE (_MSC_VER >= 1900)
+
+namespace order {
+struct undefined {};
+struct following {};
+struct preceding {};
+}
+
+class get_graph_helper {
+public:
+    // TODO: consider making graph_reference() public and consistent interface to get a reference to the graph
+    // and remove get_graph_helper
+    template <typename T>
+    static graph& get(const T& object) {
+        return get_impl(object, std::is_base_of<graph_node, T>());
+    }
+
+private:
+    // Get graph from the object of type derived from graph_node
+    template <typename T>
+    static graph& get_impl(const T& object, std::true_type) {
+        return static_cast<const graph_node*>(&object)->my_graph;
+    }
+
+    template <typename T>
+    static graph& get_impl(const T& object, std::false_type) {
+        return object.graph_reference();
+    }
+};
+
+template<typename Order, typename... Nodes>
+struct node_set {
+    typedef Order order_type;
+
+    tbb::flow::tuple<Nodes&...> nodes;
+    node_set(Nodes&... ns) : nodes(ns...) {}
+
+    template <typename... Nodes2>
+    node_set(const node_set<order::undefined, Nodes2...>& set) : nodes(set.nodes) {}
+
+    graph& graph_reference() const {
+        return get_graph_helper::get(std::get<0>(nodes));
+    }
+};
+
+namespace alias_helpers {
+template <typename T> using output_type = typename T::output_type;
+template <typename T> using output_ports_type = typename T::output_ports_type;
+template <typename T> using input_type = typename T::input_type;
+template <typename T> using input_ports_type = typename T::input_ports_type;
+} // namespace alias_helpers
+
+template <typename T>
+using has_output_type = tbb::internal::supports<T, alias_helpers::output_type>;
+
+template <typename T>
+using has_input_type = tbb::internal::supports<T, alias_helpers::input_type>;
+
+template <typename T>
+using has_input_ports_type = tbb::internal::supports<T, alias_helpers::input_ports_type>;
+
+template <typename T>
+using has_output_ports_type = tbb::internal::supports<T, alias_helpers::output_ports_type>;
+
+template<typename T>
+struct is_sender : std::is_base_of<sender<typename T::output_type>, T> {};
+
+template<typename T>
+struct is_receiver : std::is_base_of<receiver<typename T::input_type>, T> {};
+
+template <typename Node>
+struct is_async_node : std::false_type {};
+
+template <typename... Args>
+struct is_async_node<tbb::flow::interface11::async_node<Args...>> : std::true_type {};
+
+template<typename FirstPredecessor, typename... Predecessors>
+node_set<order::following, FirstPredecessor, Predecessors...>
+follows(FirstPredecessor& first_predecessor, Predecessors&... predecessors) {
+    __TBB_STATIC_ASSERT((tbb::internal::conjunction<has_output_type<FirstPredecessor>,
+                                                   has_output_type<Predecessors>...>::value),
+                        "Not all node's predecessors has output_type typedef");
+    __TBB_STATIC_ASSERT((tbb::internal::conjunction<is_sender<FirstPredecessor>, is_sender<Predecessors>...>::value),
+                        "Not all node's predecessors are senders");
+    return node_set<order::following, FirstPredecessor, Predecessors...>(first_predecessor, predecessors...);
+}
+
+template<typename... Predecessors>
+node_set<order::following, Predecessors...>
+follows(node_set<order::undefined, Predecessors...>& predecessors_set) {
+    __TBB_STATIC_ASSERT((tbb::internal::conjunction<has_output_type<Predecessors>...>::value),
+                        "Not all nodes in the set has output_type typedef");
+    __TBB_STATIC_ASSERT((tbb::internal::conjunction<is_sender<Predecessors>...>::value),
+                        "Not all nodes in the set are senders");
+    return node_set<order::following, Predecessors...>(predecessors_set);
+}
+
+template<typename FirstSuccessor, typename... Successors>
+node_set<order::preceding, FirstSuccessor, Successors...>
+precedes(FirstSuccessor& first_successor, Successors&... successors) {
+    __TBB_STATIC_ASSERT((tbb::internal::conjunction<has_input_type<FirstSuccessor>,
+                                                    has_input_type<Successors>...>::value),
+                        "Not all node's successors has input_type typedef");
+    __TBB_STATIC_ASSERT((tbb::internal::conjunction<is_receiver<FirstSuccessor>, is_receiver<Successors>...>::value),
+                        "Not all node's successors are receivers");
+    return node_set<order::preceding, FirstSuccessor, Successors...>(first_successor, successors...);
+}
+
+template<typename... Successors>
+node_set<order::preceding, Successors...>
+precedes(node_set<order::undefined, Successors...>& successors_set) {
+    __TBB_STATIC_ASSERT((tbb::internal::conjunction<has_input_type<Successors>...>::value),
+                        "Not all nodes in the set has input_type typedef");
+    __TBB_STATIC_ASSERT((tbb::internal::conjunction<is_receiver<Successors>...>::value),
+                        "Not all nodes in the set are receivers");
+    return node_set<order::preceding, Successors...>(successors_set);
+}
+
+template <typename Node, typename... Nodes>
+node_set<order::undefined, Node, Nodes...>
+make_node_set(Node& first_node, Nodes&... nodes) {
+    return node_set<order::undefined, Node, Nodes...>(first_node, nodes...);
+}
+
+template<size_t I>
+class successor_selector {
+    template <typename NodeType>
+    static auto get_impl(NodeType& node, std::true_type) -> decltype(input_port<I>(node)) {
+        return input_port<I>(node);
+    }
+
+    template <typename NodeType>
+    static NodeType& get_impl(NodeType& node, std::false_type) { return node; }
+
+public:
+    template <typename NodeType>
+#if __TBB_MSVC_DISABLE_TRAILING_DECLTYPE
+    static auto& get(NodeType& node)
+#else
+    static auto get(NodeType& node) -> decltype(get_impl(node, has_input_ports_type<NodeType>()))
+#endif
+	{
+        return get_impl(node, has_input_ports_type<NodeType>());
+    }
+};
+
+template<size_t I>
+class predecessor_selector {
+    template <typename NodeType>
+    static auto internal_get(NodeType& node, std::true_type) -> decltype(output_port<I>(node)) {
+        return output_port<I>(node);
+    }
+
+    template <typename NodeType>
+    static NodeType& internal_get(NodeType& node, std::false_type) { return node;}
+
+    template <typename NodeType>
+#if __TBB_MSVC_DISABLE_TRAILING_DECLTYPE
+    static auto& get_impl(NodeType& node, std::false_type)
+#else
+    static auto get_impl(NodeType& node, std::false_type) -> decltype(internal_get(node, has_output_ports_type<NodeType>()))
+#endif
+	{
+        return internal_get(node, has_output_ports_type<NodeType>());
+    }
+
+    template <typename AsyncNode>
+    static AsyncNode& get_impl(AsyncNode& node, std::true_type) { return node; }
+
+public:
+    template <typename NodeType>
+#if __TBB_MSVC_DISABLE_TRAILING_DECLTYPE
+    static auto& get(NodeType& node)
+#else
+    static auto get(NodeType& node) -> decltype(get_impl(node, is_async_node<NodeType>()))
+#endif
+	{
+        return get_impl(node, is_async_node<NodeType>());
+    }
+};
+
+template<size_t I>
+class make_edges_helper {
+public:
+    template<typename PredecessorsTuple, typename NodeType>
+    static void connect_predecessors(PredecessorsTuple& predecessors, NodeType& node) {
+        make_edge(std::get<I>(predecessors), successor_selector<I>::get(node));
+        make_edges_helper<I - 1>::connect_predecessors(predecessors, node);
+    }
+
+    template<typename SuccessorsTuple, typename NodeType>
+    static void connect_successors(NodeType& node, SuccessorsTuple& successors) {
+        make_edge(predecessor_selector<I>::get(node), std::get<I>(successors));
+        make_edges_helper<I - 1>::connect_successors(node, successors);
+    }
+};
+
+template<>
+struct make_edges_helper<0> {
+    template<typename PredecessorsTuple, typename NodeType>
+    static void connect_predecessors(PredecessorsTuple& predecessors, NodeType& node) {
+        make_edge(std::get<0>(predecessors), successor_selector<0>::get(node));
+    }
+
+    template<typename SuccessorsTuple, typename NodeType>
+    static void connect_successors(NodeType& node, SuccessorsTuple& successors) {
+        make_edge(predecessor_selector<0>::get(node), std::get<0>(successors));
+    }
+};
+
+// TODO: consider adding an overload for making edges between node sets
+template<typename NodeType, typename OrderFlagType, typename... Args>
+void make_edges(const node_set<OrderFlagType, Args...>& s, NodeType& node) {
+    const std::size_t SetSize = tbb::flow::tuple_size<decltype(s.nodes)>::value;
+    make_edges_helper<SetSize - 1>::connect_predecessors(s.nodes, node);
+}
+
+template <typename NodeType, typename OrderFlagType, typename... Args>
+void make_edges(NodeType& node, const node_set<OrderFlagType, Args...>& s) {
+    const std::size_t SetSize = tbb::flow::tuple_size<decltype(s.nodes)>::value;
+    make_edges_helper<SetSize - 1>::connect_successors(node, s.nodes);
+}
+
+template <typename NodeType, typename... Nodes>
+void make_edges_in_order(const node_set<order::following, Nodes...>& ns, NodeType& node) {
+    make_edges(ns, node);
+}
+
+template <typename NodeType, typename... Nodes>
+void make_edges_in_order(const node_set<order::preceding, Nodes...>& ns, NodeType& node) {
+    make_edges(node, ns);
+}
+
+#endif // __TBB_CPP11_PRESENT
+
+} // namespace internal
+
+#endif // __TBB_flow_graph_node_set_impl_H
diff --git a/inst/include/tbb/internal/_flow_graph_nodes_deduction.h b/inst/include/tbb/internal/_flow_graph_nodes_deduction.h
new file mode 100644
index 00000000..caf2f689
--- /dev/null
+++ b/inst/include/tbb/internal/_flow_graph_nodes_deduction.h
@@ -0,0 +1,298 @@
+/*
+    Copyright (c) 2005-2020 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.
+*/
+
+#ifndef __TBB_flow_graph_nodes_deduction_H
+#define __TBB_flow_graph_nodes_deduction_H
+
+#if __TBB_CPP17_DEDUCTION_GUIDES_PRESENT
+
+namespace tbb {
+namespace flow {
+namespace interface11 {
+
+template <typename Input, typename Output>
+struct declare_body_types {
+    using input_type = Input;
+    using output_type = Output;
+};
+
+struct NoInputBody {};
+
+template <typename Output>
+struct declare_body_types<NoInputBody, Output> {
+    using output_type = Output;
+};
+
+template <typename T> struct body_types;
+
+template <typename T, typename Input, typename Output>
+struct body_types<Output (T::*)(const Input&) const> : declare_body_types<Input, Output> {};
+
+template <typename T, typename Input, typename Output>
+struct body_types<Output (T::*)(const Input&)> : declare_body_types<Input, Output> {};
+
+template <typename T, typename Input, typename Output>
+struct body_types<Output (T::*)(Input&) const> : declare_body_types<Input, Output> {};
+
+template <typename T, typename Input, typename Output>
+struct body_types<Output (T::*)(Input&)> : declare_body_types<Input, Output> {};
+
+template <typename Input, typename Output>
+struct body_types<Output (*)(Input&)> : declare_body_types<Input, Output> {};
+
+template <typename Input, typename Output>
+struct body_types<Output (*)(const Input&)> : declare_body_types<Input, Output> {};
+
+template <typename T, typename Output>
+struct body_types<Output (T::*)(flow_control&) const> : declare_body_types<NoInputBody, Output> {};
+
+template <typename T, typename Output>
+struct body_types<Output (T::*)(flow_control&)> : declare_body_types<NoInputBody, Output> {};
+
+template <typename Output>
+struct body_types<Output (*)(flow_control&)> : declare_body_types<NoInputBody, Output> {};
+
+template <typename Body>
+using input_t = typename body_types<Body>::input_type;
+
+template <typename Body>
+using output_t = typename body_types<Body>::output_type;
+
+template <typename T, typename Input, typename Output>
+auto decide_on_operator_overload(Output (T::*name)(const Input&) const)->decltype(name);
+
+template <typename T, typename Input, typename Output>
+auto decide_on_operator_overload(Output (T::*name)(const Input&))->decltype(name);
+
+template <typename T, typename Input, typename Output>
+auto decide_on_operator_overload(Output (T::*name)(Input&) const)->decltype(name);
+
+template <typename T, typename Input, typename Output>
+auto decide_on_operator_overload(Output (T::*name)(Input&))->decltype(name);
+
+template <typename Input, typename Output>
+auto decide_on_operator_overload(Output (*name)(const Input&))->decltype(name);
+
+template <typename Input, typename Output>
+auto decide_on_operator_overload(Output (*name)(Input&))->decltype(name);
+
+template <typename Body>
+decltype(decide_on_operator_overload(&Body::operator())) decide_on_callable_type(int);
+
+template <typename Body>
+decltype(decide_on_operator_overload(std::declval<Body>())) decide_on_callable_type(...);
+
+// Deduction guides for Flow Graph nodes
+#if TBB_USE_SOURCE_NODE_AS_ALIAS
+#if TBB_DEPRECATED_INPUT_NODE_BODY
+template <typename GraphOrSet, typename Body>
+source_node(GraphOrSet&&, Body)
+->source_node<input_t<decltype(decide_on_callable_type<Body>(0))>>;
+#else
+template <typename GraphOrSet, typename Body>
+source_node(GraphOrSet&&, Body)
+->source_node<output_t<decltype(decide_on_callable_type<Body>(0))>>;
+#endif // TBB_DEPRECATED_INPUT_NODE_BODY
+#else
+template <typename GraphOrSet, typename Body>
+source_node(GraphOrSet&&, Body, bool = true)
+->source_node<input_t<decltype(decide_on_callable_type<Body>(0))>>;
+#endif
+
+#if TBB_DEPRECATED_INPUT_NODE_BODY
+template <typename GraphOrSet, typename Body>
+input_node(GraphOrSet&&, Body, bool = true)
+->input_node<input_t<decltype(decide_on_callable_type<Body>(0))>>;
+#else
+template <typename GraphOrSet, typename Body>
+input_node(GraphOrSet&&, Body)
+->input_node<output_t<decltype(decide_on_callable_type<Body>(0))>>;
+#endif
+
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+
+template <typename NodeSet>
+struct decide_on_set;
+
+template <typename Node, typename... Nodes>
+struct decide_on_set<node_set<internal::order::following, Node, Nodes...>> {
+    using type = typename Node::output_type;
+};
+
+template <typename Node, typename... Nodes>
+struct decide_on_set<node_set<internal::order::preceding, Node, Nodes...>> {
+    using type = typename Node::input_type;
+};
+
+template <typename NodeSet>
+using decide_on_set_t = typename decide_on_set<std::decay_t<NodeSet>>::type;
+
+template <typename NodeSet>
+broadcast_node(const NodeSet&)
+->broadcast_node<decide_on_set_t<NodeSet>>;
+
+template <typename NodeSet>
+buffer_node(const NodeSet&)
+->buffer_node<decide_on_set_t<NodeSet>>;
+
+template <typename NodeSet>
+queue_node(const NodeSet&)
+->queue_node<decide_on_set_t<NodeSet>>;
+#endif // __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+
+template <typename GraphOrProxy, typename Sequencer>
+sequencer_node(GraphOrProxy&&, Sequencer)
+->sequencer_node<input_t<decltype(decide_on_callable_type<Sequencer>(0))>>;
+
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+template <typename NodeSet, typename Compare>
+priority_queue_node(const NodeSet&, const Compare&)
+->priority_queue_node<decide_on_set_t<NodeSet>, Compare>;
+
+template <typename NodeSet>
+priority_queue_node(const NodeSet&)
+->priority_queue_node<decide_on_set_t<NodeSet>, std::less<decide_on_set_t<NodeSet>>>;
+#endif // __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+
+template <typename Key>
+struct join_key {
+    using type = Key;
+};
+
+template <typename T>
+struct join_key<const T&> {
+    using type = T&;
+};
+
+template <typename Key>
+using join_key_t = typename join_key<Key>::type;
+
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+template <typename Policy, typename... Predecessors>
+join_node(const node_set<internal::order::following, Predecessors...>&, Policy)
+->join_node<std::tuple<typename Predecessors::output_type...>,
+            Policy>;
+
+template <typename Policy, typename Successor, typename... Successors>
+join_node(const node_set<internal::order::preceding, Successor, Successors...>&, Policy)
+->join_node<typename Successor::input_type, Policy>;
+
+template <typename... Predecessors>
+join_node(const node_set<internal::order::following, Predecessors...>)
+->join_node<std::tuple<typename Predecessors::output_type...>,
+            queueing>;
+
+template <typename Successor, typename... Successors>
+join_node(const node_set<internal::order::preceding, Successor, Successors...>)
+->join_node<typename Successor::input_type, queueing>;
+#endif
+
+template <typename GraphOrProxy, typename Body, typename... Bodies>
+join_node(GraphOrProxy&&, Body, Bodies...)
+->join_node<std::tuple<input_t<decltype(decide_on_callable_type<Body>(0))>,
+                       input_t<decltype(decide_on_callable_type<Bodies>(0))>...>,
+            key_matching<join_key_t<output_t<decltype(decide_on_callable_type<Body>(0))>>>>;
+
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+template <typename... Predecessors>
+indexer_node(const node_set<internal::order::following, Predecessors...>&)
+->indexer_node<typename Predecessors::output_type...>;
+#endif
+
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+template <typename NodeSet>
+limiter_node(const NodeSet&, size_t)
+->limiter_node<decide_on_set_t<NodeSet>>;
+
+template <typename Predecessor, typename... Predecessors>
+split_node(const node_set<internal::order::following, Predecessor, Predecessors...>&)
+->split_node<typename Predecessor::output_type>;
+
+template <typename... Successors>
+split_node(const node_set<internal::order::preceding, Successors...>&)
+->split_node<std::tuple<typename Successors::input_type...>>;
+
+#endif
+
+template <typename GraphOrSet, typename Body, typename Policy>
+function_node(GraphOrSet&&,
+              size_t, Body,
+            __TBB_FLOW_GRAPH_PRIORITY_ARG1(Policy, node_priority_t = tbb::flow::internal::no_priority))
+->function_node<input_t<decltype(decide_on_callable_type<Body>(0))>,
+                output_t<decltype(decide_on_callable_type<Body>(0))>,
+                Policy>;
+
+template <typename GraphOrSet, typename Body>
+function_node(GraphOrSet&&, size_t,
+              __TBB_FLOW_GRAPH_PRIORITY_ARG1(Body, node_priority_t = tbb::flow::internal::no_priority))
+->function_node<input_t<decltype(decide_on_callable_type<Body>(0))>,
+                output_t<decltype(decide_on_callable_type<Body>(0))>,
+                queueing>;
+
+template <typename Output>
+struct continue_output {
+    using type = Output;
+};
+
+template <>
+struct continue_output<void> {
+    using type = continue_msg;
+};
+
+template <typename T>
+using continue_output_t = typename continue_output<T>::type;
+
+template <typename GraphOrSet, typename Body, typename Policy>
+continue_node(GraphOrSet&&, Body,
+              __TBB_FLOW_GRAPH_PRIORITY_ARG1(Policy, node_priority_t = tbb::flow::internal::no_priority))
+->continue_node<continue_output_t<std::invoke_result_t<Body, continue_msg>>,
+                Policy>;
+
+template <typename GraphOrSet, typename Body, typename Policy>
+continue_node(GraphOrSet&&,
+              int, Body,
+              __TBB_FLOW_GRAPH_PRIORITY_ARG1(Policy, node_priority_t = tbb::flow::internal::no_priority))
+->continue_node<continue_output_t<std::invoke_result_t<Body, continue_msg>>,
+                Policy>;
+
+template <typename GraphOrSet, typename Body>
+continue_node(GraphOrSet&&,
+              __TBB_FLOW_GRAPH_PRIORITY_ARG1(Body, node_priority_t = tbb::flow::internal::no_priority))
+->continue_node<continue_output_t<std::invoke_result_t<Body, continue_msg>>,
+                internal::Policy<void>>;
+
+template <typename GraphOrSet, typename Body>
+continue_node(GraphOrSet&&, int,
+              __TBB_FLOW_GRAPH_PRIORITY_ARG1(Body, node_priority_t = tbb::flow::internal::no_priority))
+->continue_node<continue_output_t<std::invoke_result_t<Body, continue_msg>>,
+                internal::Policy<void>>;
+
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+
+template <typename NodeSet>
+overwrite_node(const NodeSet&)
+->overwrite_node<decide_on_set_t<NodeSet>>;
+
+template <typename NodeSet>
+write_once_node(const NodeSet&)
+->write_once_node<decide_on_set_t<NodeSet>>;
+#endif // __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+} // namespace interfaceX
+} // namespace flow
+} // namespace tbb
+
+#endif // __TBB_CPP17_DEDUCTION_GUIDES_PRESENT
+#endif // __TBB_flow_graph_nodes_deduction_H
diff --git a/inst/include/tbb/internal/_flow_graph_streaming_node.h b/inst/include/tbb/internal/_flow_graph_streaming_node.h
index 493f76e8..4ef990bf 100644
--- a/inst/include/tbb/internal/_flow_graph_streaming_node.h
+++ b/inst/include/tbb/internal/_flow_graph_streaming_node.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_flow_graph_streaming_H
@@ -42,7 +38,7 @@ struct port_ref_impl {
 // The purpose of the port_ref_impl is the pretty syntax: the deduction of a compile-time constant is processed from the return type.
 // So it is possible to use this helper without parentheses, e.g. "port_ref<0>".
 template <int N1, int N2 = N1>
-internal::port_ref_impl<N1,N2> port_ref() {
+__TBB_DEPRECATED internal::port_ref_impl<N1,N2> port_ref() {
     return internal::port_ref_impl<N1,N2>();
 };
 
@@ -303,10 +299,11 @@ O---O              |   |                      O---O           |   |
 \--------------------------------------------------------------------------------------------/
 */
 template<typename... Args>
-class streaming_node;
+class __TBB_DEPRECATED streaming_node;
 
 template<typename... Ports, typename JP, typename StreamFactory>
-class streaming_node< tuple<Ports...>, JP, StreamFactory >
+class __TBB_DEPRECATED
+streaming_node< tuple<Ports...>, JP, StreamFactory >
     : public composite_node < typename internal::streaming_node_traits<JP, StreamFactory, Ports...>::input_tuple,
                               typename internal::streaming_node_traits<JP, StreamFactory, Ports...>::output_tuple >
     , public internal::kernel_executor_helper< StreamFactory, typename internal::streaming_node_traits<JP, StreamFactory, Ports...>::kernel_input_tuple >
@@ -466,6 +463,7 @@ class streaming_node< tuple<Ports...>, JP, StreamFactory >
         device_selector_base *my_device_selector;
     };
 
+    // TODO: investigate why copy-construction is disallowed
     class args_storage_base : tbb::internal::no_copy {
     public:
         typedef typename kernel_multifunction_node::output_ports_type output_ports_type;
@@ -481,7 +479,7 @@ class streaming_node< tuple<Ports...>, JP, StreamFactory >
         {}
 
         args_storage_base( const args_storage_base &k )
-            : my_kernel( k.my_kernel ), my_factory( k.my_factory )
+            : tbb::internal::no_copy(), my_kernel( k.my_kernel ), my_factory( k.my_factory )
         {}
 
         const kernel_type my_kernel;
diff --git a/inst/include/tbb/internal/_flow_graph_tagged_buffer_impl.h b/inst/include/tbb/internal/_flow_graph_tagged_buffer_impl.h
index 46755fe0..92291129 100644
--- a/inst/include/tbb/internal/_flow_graph_tagged_buffer_impl.h
+++ b/inst/include/tbb/internal/_flow_graph_tagged_buffer_impl.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 // a hash table buffer that can expand, and can support as many deletions as
diff --git a/inst/include/tbb/internal/_flow_graph_trace_impl.h b/inst/include/tbb/internal/_flow_graph_trace_impl.h
index b798888d..65809c39 100644
--- a/inst/include/tbb/internal/_flow_graph_trace_impl.h
+++ b/inst/include/tbb/internal/_flow_graph_trace_impl.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,34 +12,119 @@
     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.
-
-
-
-
 */
 
 #ifndef _FGT_GRAPH_TRACE_IMPL_H
 #define _FGT_GRAPH_TRACE_IMPL_H
 
 #include "../tbb_profiling.h"
+#if (_MSC_VER >= 1900)
+    #include <intrin.h>
+#endif
 
 namespace tbb {
     namespace internal {
 
+#if TBB_USE_THREADING_TOOLS
+    #if TBB_PREVIEW_FLOW_GRAPH_TRACE
+        #if (_MSC_VER >= 1900)
+            #define CODEPTR() (_ReturnAddress())
+        #elif __TBB_GCC_VERSION >= 40800
+            #define CODEPTR() ( __builtin_return_address(0))
+        #else
+            #define CODEPTR() NULL
+        #endif
+    #else
+        #define CODEPTR() NULL
+    #endif /* TBB_PREVIEW_FLOW_GRAPH_TRACE */
+
+static inline void fgt_alias_port(void *node, void *p, bool visible) {
+    if(visible)
+        itt_relation_add( ITT_DOMAIN_FLOW, node, FLOW_NODE, __itt_relation_is_parent_of, p, FLOW_NODE );
+    else
+        itt_relation_add( ITT_DOMAIN_FLOW, p, FLOW_NODE, __itt_relation_is_child_of, node, FLOW_NODE );
+}
+
+static inline void fgt_composite ( void* codeptr, void *node, void *graph ) {
+    itt_make_task_group( ITT_DOMAIN_FLOW, node, FLOW_NODE, graph, FLOW_GRAPH, FLOW_COMPOSITE_NODE );
+    suppress_unused_warning( codeptr );
 #if TBB_PREVIEW_FLOW_GRAPH_TRACE
+    if (codeptr != NULL) {
+        register_node_addr(ITT_DOMAIN_FLOW, node, FLOW_NODE, CODE_ADDRESS, &codeptr);
+    }
+#endif
+}
 
-static inline void fgt_internal_create_input_port( void *node, void *p, string_index name_index ) {
+static inline void fgt_internal_alias_input_port( void *node, void *p, string_index name_index ) {
     itt_make_task_group( ITT_DOMAIN_FLOW, p, FLOW_INPUT_PORT, node, FLOW_NODE, name_index );
+    itt_relation_add( ITT_DOMAIN_FLOW, node, FLOW_NODE, __itt_relation_is_parent_of, p, FLOW_INPUT_PORT );
 }
 
-static inline void fgt_internal_create_output_port( void *node, void *p, string_index name_index ) {
+static inline void fgt_internal_alias_output_port( void *node, void *p, string_index name_index ) {
     itt_make_task_group( ITT_DOMAIN_FLOW, p, FLOW_OUTPUT_PORT, node, FLOW_NODE, name_index );
+    itt_relation_add( ITT_DOMAIN_FLOW, node, FLOW_NODE, __itt_relation_is_parent_of, p, FLOW_OUTPUT_PORT );
+}
+
+template<typename InputType>
+void alias_input_port(void *node, tbb::flow::receiver<InputType>* port, string_index name_index) {
+    // TODO: Make fgt_internal_alias_input_port a function template?
+    fgt_internal_alias_input_port( node, port, name_index);
+}
+
+template < typename PortsTuple, int N >
+struct fgt_internal_input_alias_helper {
+    static void alias_port( void *node, PortsTuple &ports ) {
+        alias_input_port( node, &(tbb::flow::get<N-1>(ports)), static_cast<tbb::internal::string_index>(FLOW_INPUT_PORT_0 + N - 1) );
+        fgt_internal_input_alias_helper<PortsTuple, N-1>::alias_port( node, ports );
+    }
+};
+
+template < typename PortsTuple >
+struct fgt_internal_input_alias_helper<PortsTuple, 0> {
+    static void alias_port( void * /* node */, PortsTuple & /* ports */ ) { }
+};
+
+template<typename OutputType>
+void alias_output_port(void *node, tbb::flow::sender<OutputType>* port, string_index name_index) {
+    // TODO: Make fgt_internal_alias_output_port a function template?
+    fgt_internal_alias_output_port( node, static_cast<void *>(port), name_index);
+}
+
+template < typename PortsTuple, int N >
+struct fgt_internal_output_alias_helper {
+    static void alias_port( void *node, PortsTuple &ports ) {
+        alias_output_port( node, &(tbb::flow::get<N-1>(ports)), static_cast<tbb::internal::string_index>(FLOW_OUTPUT_PORT_0 + N - 1) );
+        fgt_internal_output_alias_helper<PortsTuple, N-1>::alias_port( node, ports );
+    }
+};
+
+template < typename PortsTuple >
+struct fgt_internal_output_alias_helper<PortsTuple, 0> {
+    static void alias_port( void * /*node*/, PortsTuple &/*ports*/ ) {
+    }
+};
+
+static inline void fgt_internal_create_input_port( void *node, void *p, string_index name_index ) {
+    itt_make_task_group( ITT_DOMAIN_FLOW, p, FLOW_INPUT_PORT, node, FLOW_NODE, name_index );
+}
+
+static inline void fgt_internal_create_output_port( void* codeptr, void *node, void *p, string_index name_index ) {
+    itt_make_task_group(ITT_DOMAIN_FLOW, p, FLOW_OUTPUT_PORT, node, FLOW_NODE, name_index);
+    suppress_unused_warning( codeptr );
+#if TBB_PREVIEW_FLOW_GRAPH_TRACE
+    if (codeptr != NULL) {
+        register_node_addr(ITT_DOMAIN_FLOW, node, FLOW_NODE, CODE_ADDRESS, &codeptr);
+    }
+#endif
 }
 
 template<typename InputType>
 void register_input_port(void *node, tbb::flow::receiver<InputType>* port, string_index name_index) {
-    //TODO: Make fgt_internal_create_input_port a function template?
-    fgt_internal_create_input_port( node, port, name_index);
+    // TODO: Make fgt_internal_create_input_port a function template?
+    // In C++03 dependent name lookup from the template definition context
+    // works only for function declarations with external linkage:
+    // http://www.open-std.org/JTC1/SC22/WG21/docs/cwg_defects.html#561
+    fgt_internal_create_input_port(node, static_cast<void*>(port), name_index);
 }
 
 template < typename PortsTuple, int N >
@@ -58,23 +143,23 @@ struct fgt_internal_input_helper<PortsTuple, 1> {
 };
 
 template<typename OutputType>
-void register_output_port(void *node, tbb::flow::sender<OutputType>* port, string_index name_index) {
-    //TODO: Make fgt_internal_create_output_port a function template?
-    fgt_internal_create_output_port( node, static_cast<void *>(port), name_index);
+void register_output_port(void* codeptr, void *node, tbb::flow::sender<OutputType>* port, string_index name_index) {
+    // TODO: Make fgt_internal_create_output_port a function template?
+    fgt_internal_create_output_port( codeptr, node, static_cast<void *>(port), name_index);
 }
 
 template < typename PortsTuple, int N >
 struct fgt_internal_output_helper {
-    static void register_port( void *node, PortsTuple &ports ) {
-        register_output_port( node, &(tbb::flow::get<N-1>(ports)), static_cast<tbb::internal::string_index>(FLOW_OUTPUT_PORT_0 + N - 1) );
-        fgt_internal_output_helper<PortsTuple, N-1>::register_port( node, ports );
+    static void register_port( void* codeptr, void *node, PortsTuple &ports ) {
+        register_output_port( codeptr, node, &(tbb::flow::get<N-1>(ports)), static_cast<tbb::internal::string_index>(FLOW_OUTPUT_PORT_0 + N - 1) );
+        fgt_internal_output_helper<PortsTuple, N-1>::register_port( codeptr, node, ports );
     }
 };
 
 template < typename PortsTuple >
 struct fgt_internal_output_helper<PortsTuple,1> {
-    static void register_port( void *node, PortsTuple &ports ) {
-        register_output_port( node, &(tbb::flow::get<0>(ports)), FLOW_OUTPUT_PORT_0 );
+    static void register_port( void* codeptr, void *node, PortsTuple &ports ) {
+        register_output_port( codeptr, node, &(tbb::flow::get<0>(ports)), FLOW_OUTPUT_PORT_0 );
     }
 };
 
@@ -105,52 +190,61 @@ static inline void fgt_body( void *node, void *body ) {
 }
 
 template< int N, typename PortsTuple >
-static inline void fgt_multioutput_node( string_index t, void *g, void *input_port, PortsTuple &ports ) {
+static inline void fgt_multioutput_node(void* codeptr, string_index t, void *g, void *input_port, PortsTuple &ports ) {
     itt_make_task_group( ITT_DOMAIN_FLOW, input_port, FLOW_NODE, g, FLOW_GRAPH, t );
     fgt_internal_create_input_port( input_port, input_port, FLOW_INPUT_PORT_0 );
-    fgt_internal_output_helper<PortsTuple, N>::register_port( input_port, ports );
+    fgt_internal_output_helper<PortsTuple, N>::register_port(codeptr, input_port, ports );
 }
 
 template< int N, typename PortsTuple >
-static inline void fgt_multioutput_node_with_body( string_index t, void *g, void *input_port, PortsTuple &ports, void *body ) {
+static inline void fgt_multioutput_node_with_body( void* codeptr, string_index t, void *g, void *input_port, PortsTuple &ports, void *body ) {
     itt_make_task_group( ITT_DOMAIN_FLOW, input_port, FLOW_NODE, g, FLOW_GRAPH, t );
     fgt_internal_create_input_port( input_port, input_port, FLOW_INPUT_PORT_0 );
-    fgt_internal_output_helper<PortsTuple, N>::register_port( input_port, ports );
+    fgt_internal_output_helper<PortsTuple, N>::register_port( codeptr, input_port, ports );
     fgt_body( input_port, body );
 }
 
 template< int N, typename PortsTuple >
-static inline void fgt_multiinput_node( string_index t, void *g, PortsTuple &ports, void *output_port) {
+static inline void fgt_multiinput_node( void* codeptr, string_index t, void *g, PortsTuple &ports, void *output_port) {
     itt_make_task_group( ITT_DOMAIN_FLOW, output_port, FLOW_NODE, g, FLOW_GRAPH, t );
-    fgt_internal_create_output_port( output_port, output_port, FLOW_OUTPUT_PORT_0 );
+    fgt_internal_create_output_port( codeptr, output_port, output_port, FLOW_OUTPUT_PORT_0 );
     fgt_internal_input_helper<PortsTuple, N>::register_port( output_port, ports );
 }
 
-static inline void fgt_node( string_index t, void *g, void *output_port ) {
+static inline void fgt_multiinput_multioutput_node( void* codeptr, string_index t, void *n, void *g ) {
+    itt_make_task_group( ITT_DOMAIN_FLOW, n, FLOW_NODE, g, FLOW_GRAPH, t );
+    suppress_unused_warning( codeptr );
+#if TBB_PREVIEW_FLOW_GRAPH_TRACE
+    if (codeptr != NULL) {
+        register_node_addr(ITT_DOMAIN_FLOW, n, FLOW_NODE, CODE_ADDRESS, &codeptr);
+    }
+#endif
+}
+
+static inline void fgt_node( void* codeptr, string_index t, void *g, void *output_port ) {
     itt_make_task_group( ITT_DOMAIN_FLOW, output_port, FLOW_NODE, g, FLOW_GRAPH, t );
-    fgt_internal_create_output_port( output_port, output_port, FLOW_OUTPUT_PORT_0 );
+    fgt_internal_create_output_port( codeptr, output_port, output_port, FLOW_OUTPUT_PORT_0 );
 }
 
-static inline void fgt_node_with_body( string_index t, void *g, void *output_port, void *body ) {
+static void fgt_node_with_body( void* codeptr, string_index t, void *g, void *output_port, void *body ) {
     itt_make_task_group( ITT_DOMAIN_FLOW, output_port, FLOW_NODE, g, FLOW_GRAPH, t );
-    fgt_internal_create_output_port( output_port, output_port, FLOW_OUTPUT_PORT_0 );
+    fgt_internal_create_output_port(codeptr, output_port, output_port, FLOW_OUTPUT_PORT_0 );
     fgt_body( output_port, body );
 }
 
-
-static inline void fgt_node( string_index t, void *g, void *input_port, void *output_port ) {
-    fgt_node( t, g, output_port );
+static inline void fgt_node( void* codeptr, string_index t, void *g, void *input_port, void *output_port ) {
+    fgt_node( codeptr, t, g, output_port );
     fgt_internal_create_input_port( output_port, input_port, FLOW_INPUT_PORT_0 );
 }
 
-static inline void fgt_node_with_body( string_index t, void *g, void *input_port, void *output_port, void *body ) {
-    fgt_node_with_body( t, g, output_port, body );
+static inline void  fgt_node_with_body( void* codeptr, string_index t, void *g, void *input_port, void *output_port, void *body ) {
+    fgt_node_with_body( codeptr, t, g, output_port, body );
     fgt_internal_create_input_port( output_port, input_port, FLOW_INPUT_PORT_0 );
 }
 
 
-static inline void  fgt_node( string_index t, void *g, void *input_port, void *decrement_port, void *output_port ) {
-    fgt_node( t, g, input_port, output_port );
+static inline void  fgt_node( void* codeptr, string_index t, void *g, void *input_port, void *decrement_port, void *output_port ) {
+    fgt_node( codeptr, t, g, input_port, output_port );
     fgt_internal_create_input_port( output_port, decrement_port, FLOW_INPUT_PORT_1 );
 }
 
@@ -186,11 +280,25 @@ static inline void fgt_async_reserve( void *node, void *graph ) {
     itt_region_begin( ITT_DOMAIN_FLOW, node, FLOW_NODE, graph, FLOW_GRAPH, FLOW_NULL );
 }
 
-static inline void fgt_async_commit( void *node, void *graph ) {
+static inline void fgt_async_commit( void *node, void * /*graph*/) {
     itt_region_end( ITT_DOMAIN_FLOW, node, FLOW_NODE );
 }
 
-#else // TBB_PREVIEW_FLOW_GRAPH_TRACE
+static inline void fgt_reserve_wait( void *graph ) {
+    itt_region_begin( ITT_DOMAIN_FLOW, graph, FLOW_GRAPH, NULL, FLOW_NULL, FLOW_NULL );
+}
+
+static inline void fgt_release_wait( void *graph ) {
+    itt_region_end( ITT_DOMAIN_FLOW, graph, FLOW_GRAPH );
+}
+
+#else // TBB_USE_THREADING_TOOLS
+
+#define CODEPTR() NULL
+
+static inline void fgt_alias_port(void * /*node*/, void * /*p*/, bool /*visible*/ ) { }
+
+static inline void fgt_composite ( void* /*codeptr*/, void * /*node*/, void * /*graph*/ ) { }
 
 static inline void fgt_graph( void * /*g*/ ) { }
 
@@ -205,32 +313,50 @@ static inline void fgt_graph_desc( void * /*g*/, const char * /*desc*/ ) { }
 static inline void fgt_body( void * /*node*/, void * /*body*/ ) { }
 
 template< int N, typename PortsTuple >
-static inline void fgt_multioutput_node( string_index /*t*/, void * /*g*/, void * /*input_port*/, PortsTuple & /*ports*/ ) { }
+static inline void fgt_multioutput_node( void* /*codeptr*/, string_index /*t*/, void * /*g*/, void * /*input_port*/, PortsTuple & /*ports*/ ) { }
 
 template< int N, typename PortsTuple >
-static inline void fgt_multioutput_node_with_body( string_index /*t*/, void * /*g*/, void * /*input_port*/, PortsTuple & /*ports*/, void * /*body*/ ) { }
+static inline void fgt_multioutput_node_with_body( void* /*codeptr*/, string_index /*t*/, void * /*g*/, void * /*input_port*/, PortsTuple & /*ports*/, void * /*body*/ ) { }
 
 template< int N, typename PortsTuple >
-static inline void fgt_multiinput_node( string_index /*t*/, void * /*g*/, PortsTuple & /*ports*/, void * /*output_port*/ ) { }
+static inline void fgt_multiinput_node( void* /*codeptr*/, string_index /*t*/, void * /*g*/, PortsTuple & /*ports*/, void * /*output_port*/ ) { }
 
-static inline void fgt_node( string_index /*t*/, void * /*g*/, void * /*output_port*/ ) { }
-static inline void fgt_node( string_index /*t*/, void * /*g*/, void * /*input_port*/, void * /*output_port*/ ) { }
-static inline void  fgt_node( string_index /*t*/, void * /*g*/, void * /*input_port*/, void * /*decrement_port*/, void * /*output_port*/ ) { }
+static inline void fgt_multiinput_multioutput_node( void* /*codeptr*/, string_index /*t*/, void * /*node*/, void * /*graph*/ ) { }
 
-static inline void fgt_node_with_body( string_index /*t*/, void * /*g*/, void * /*output_port*/, void * /*body*/ ) { }
-static inline void fgt_node_with_body( string_index /*t*/, void * /*g*/, void * /*input_port*/, void * /*output_port*/, void * /*body*/ ) { }
+static inline void fgt_node( void* /*codeptr*/, string_index /*t*/, void * /*g*/, void * /*output_port*/ ) { }
+static inline void fgt_node( void* /*codeptr*/, string_index /*t*/, void * /*g*/, void * /*input_port*/, void * /*output_port*/ ) { }
+static inline void  fgt_node( void* /*codeptr*/, string_index /*t*/, void * /*g*/, void * /*input_port*/, void * /*decrement_port*/, void * /*output_port*/ ) { }
+
+static inline void fgt_node_with_body( void* /*codeptr*/, string_index /*t*/, void * /*g*/, void * /*output_port*/, void * /*body*/ ) { }
+static inline void fgt_node_with_body( void* /*codeptr*/, string_index /*t*/, void * /*g*/, void * /*input_port*/, void * /*output_port*/, void * /*body*/ ) { }
 
 static inline void fgt_make_edge( void * /*output_port*/, void * /*input_port*/ ) { }
 static inline void fgt_remove_edge( void * /*output_port*/, void * /*input_port*/ ) { }
 
 static inline void fgt_begin_body( void * /*body*/ ) { }
 static inline void fgt_end_body( void *  /*body*/) { }
+
 static inline void fgt_async_try_put_begin( void * /*node*/, void * /*port*/ ) { }
 static inline void fgt_async_try_put_end( void * /*node*/ , void * /*port*/ ) { }
 static inline void fgt_async_reserve( void * /*node*/, void * /*graph*/ ) { }
 static inline void fgt_async_commit( void * /*node*/, void * /*graph*/ ) { }
+static inline void fgt_reserve_wait( void * /*graph*/ ) { }
+static inline void fgt_release_wait( void * /*graph*/ ) { }
+
+template< typename NodeType >
+void fgt_multiinput_multioutput_node_desc( const NodeType * /*node*/, const char * /*desc*/ ) { }
+
+template < typename PortsTuple, int N >
+struct fgt_internal_input_alias_helper {
+    static void alias_port( void * /*node*/, PortsTuple & /*ports*/ ) { }
+};
+
+template < typename PortsTuple, int N >
+struct fgt_internal_output_alias_helper {
+    static void alias_port( void * /*node*/, PortsTuple & /*ports*/ ) { }
+};
 
-#endif // TBB_PREVIEW_FLOW_GRAPH_TRACE
+#endif // TBB_USE_THREADING_TOOLS
 
     } // namespace internal
 } // namespace tbb
diff --git a/inst/include/tbb/internal/_flow_graph_types_impl.h b/inst/include/tbb/internal/_flow_graph_types_impl.h
index 73b5f547..f374831b 100644
--- a/inst/include/tbb/internal/_flow_graph_types_impl.h
+++ b/inst/include/tbb/internal/_flow_graph_types_impl.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB__flow_graph_types_impl_H
@@ -48,7 +44,7 @@ namespace internal {
         typedef KHashp KHash;
     };
 
-// wrap each element of a tuple in a template, and make a tuple of the result.
+    // wrap each element of a tuple in a template, and make a tuple of the result.
     template<int N, template<class> class PT, typename TypeTuple>
     struct wrap_tuple_elements;
 
@@ -57,6 +53,19 @@ namespace internal {
     template<int N, template<class> class PT, typename KeyTraits, typename TypeTuple>
     struct wrap_key_tuple_elements;
 
+#if __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT && __TBB_CPP11_VARIADIC_TUPLE_PRESENT
+    template<int N, template<class> class PT,  typename... Args>
+    struct wrap_tuple_elements<N, PT, tbb::flow::tuple<Args...> >{
+        typedef typename tbb::flow::tuple<PT<Args>... > type;
+    };
+
+    template<int N, template<class> class PT, typename KeyTraits, typename... Args>
+    struct wrap_key_tuple_elements<N, PT, KeyTraits, tbb::flow::tuple<Args...> > {
+        typedef typename KeyTraits::key_type K;
+        typedef typename KeyTraits::hash_compare_type KHash;
+        typedef typename tbb::flow::tuple<PT<KeyTrait<K, KHash, Args> >... > type;
+    };
+#else
     template<template<class> class PT, typename TypeTuple>
     struct wrap_tuple_elements<1, PT, TypeTuple> {
         typedef typename tbb::flow::tuple<
@@ -314,6 +323,7 @@ namespace internal {
                 PT<KeyTrait9> > type;
     };
 #endif
+#endif /* __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT && __TBB_CPP11_VARIADIC_TUPLE_PRESENT */
 
 #if __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT
     template< int... S > class sequence {};
diff --git a/inst/include/tbb/internal/_mutex_padding.h b/inst/include/tbb/internal/_mutex_padding.h
index 6c1d9b59..d26f5f48 100644
--- a/inst/include/tbb/internal/_mutex_padding.h
+++ b/inst/include/tbb/internal/_mutex_padding.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_mutex_padding_H
diff --git a/inst/include/tbb/internal/_node_handle_impl.h b/inst/include/tbb/internal/_node_handle_impl.h
new file mode 100644
index 00000000..2088aa8b
--- /dev/null
+++ b/inst/include/tbb/internal/_node_handle_impl.h
@@ -0,0 +1,168 @@
+/*
+    Copyright (c) 2019-2020 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.
+*/
+
+#ifndef __TBB_node_handle_H
+#define __TBB_node_handle_H
+
+#include "_allocator_traits.h"
+#include "../tbb_config.h"
+
+
+namespace tbb {
+
+// This classes must be declared here for correct friendly relationship
+// TODO: Consider creation some internal class to access node_handle private fields without any friendly classes
+namespace interface5 {
+namespace internal {
+    template <typename T, typename Allocator>
+    class split_ordered_list;
+    template <typename Traits>
+    class concurrent_unordered_base;
+}
+}
+
+namespace interface10{
+namespace internal {
+    template<typename Traits>
+    class concurrent_skip_list;
+}
+}
+
+namespace internal {
+
+template<typename Value, typename Node, typename Allocator>
+class node_handle_base {
+public:
+    typedef Allocator allocator_type;
+protected:
+    typedef Node node;
+    typedef tbb::internal::allocator_traits<allocator_type> traits_type;
+public:
+
+    node_handle_base() : my_node(NULL), my_allocator() {}
+    node_handle_base(node_handle_base&& nh) : my_node(nh.my_node),
+                                              my_allocator(std::move(nh.my_allocator)) {
+        nh.my_node = NULL;
+    }
+
+    bool empty() const { return my_node == NULL; }
+    explicit operator bool() const { return my_node != NULL; }
+
+    ~node_handle_base() { internal_destroy(); }
+
+    node_handle_base& operator=(node_handle_base&& nh) {
+        internal_destroy();
+        my_node = nh.my_node;
+        typedef typename traits_type::propagate_on_container_move_assignment pocma_type;
+        tbb::internal::allocator_move_assignment(my_allocator, nh.my_allocator, pocma_type());
+        nh.deactivate();
+        return *this;
+    }
+
+    void swap(node_handle_base& nh) {
+        std::swap(my_node, nh.my_node);
+        typedef typename traits_type::propagate_on_container_swap pocs_type;
+        tbb::internal::allocator_swap(my_allocator, nh.my_allocator, pocs_type());
+    }
+
+    allocator_type get_allocator() const {
+        return my_allocator;
+    }
+
+protected:
+    node_handle_base(node* n) : my_node(n) {}
+
+    void internal_destroy() {
+        if(my_node) {
+            traits_type::destroy(my_allocator, my_node->storage());
+            typename tbb::internal::allocator_rebind<allocator_type, node>::type node_allocator;
+            node_allocator.deallocate(my_node, 1);
+        }
+    }
+
+    void deactivate() { my_node = NULL; }
+
+    node* my_node;
+    allocator_type my_allocator;
+};
+
+// node handle for maps
+template<typename Key, typename Value, typename Node, typename Allocator>
+class node_handle : public node_handle_base<Value, Node, Allocator> {
+    typedef node_handle_base<Value, Node, Allocator> base_type;
+public:
+    typedef Key key_type;
+    typedef typename Value::second_type mapped_type;
+    typedef typename base_type::allocator_type allocator_type;
+
+    node_handle() : base_type() {}
+
+    key_type& key() const {
+        __TBB_ASSERT(!this->empty(), "Cannot get key from the empty node_type object");
+        return *const_cast<key_type*>(&(this->my_node->value().first));
+    }
+
+    mapped_type& mapped() const {
+        __TBB_ASSERT(!this->empty(), "Cannot get mapped value from the empty node_type object");
+        return this->my_node->value().second;
+    }
+
+private:
+    template<typename T, typename A>
+    friend class tbb::interface5::internal::split_ordered_list;
+
+    template<typename Traits>
+    friend class tbb::interface5::internal::concurrent_unordered_base;
+
+    template<typename Traits>
+    friend class tbb::interface10::internal::concurrent_skip_list;
+
+    node_handle(typename base_type::node* n) : base_type(n) {}
+};
+
+// node handle for sets
+template<typename Key, typename Node, typename Allocator>
+class node_handle<Key, Key, Node, Allocator> : public node_handle_base<Key, Node, Allocator> {
+    typedef node_handle_base<Key, Node, Allocator> base_type;
+public:
+    typedef Key value_type;
+    typedef typename base_type::allocator_type allocator_type;
+
+    node_handle() : base_type() {}
+
+    value_type& value() const {
+        __TBB_ASSERT(!this->empty(), "Cannot get value from the empty node_type object");
+        return *const_cast<value_type*>(&(this->my_node->value()));
+    }
+
+private:
+    template<typename T, typename A>
+    friend class tbb::interface5::internal::split_ordered_list;
+
+    template<typename Traits>
+    friend class tbb::interface5::internal::concurrent_unordered_base;
+
+    template<typename Traits>
+    friend class tbb::interface10::internal::concurrent_skip_list;
+
+    node_handle(typename base_type::node* n) : base_type(n) {}
+};
+
+
+}// namespace internal
+}// namespace tbb
+
+#endif /*__TBB_node_handle_H*/
diff --git a/inst/include/tbb/internal/_range_iterator.h b/inst/include/tbb/internal/_range_iterator.h
index 5ebc42e8..df00e88d 100644
--- a/inst/include/tbb/internal/_range_iterator.h
+++ b/inst/include/tbb/internal/_range_iterator.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_range_iterator_H
diff --git a/inst/include/tbb/internal/_tbb_hash_compare_impl.h b/inst/include/tbb/internal/_tbb_hash_compare_impl.h
index 6381e2dc..82f0df13 100644
--- a/inst/include/tbb/internal/_tbb_hash_compare_impl.h
+++ b/inst/include/tbb/internal/_tbb_hash_compare_impl.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 // must be included outside namespaces.
@@ -62,23 +58,23 @@ static const size_t hash_multiplier = tbb::internal::select_size_t_constant<2654
 
 //! Hasher functions
 template<typename T>
-inline size_t tbb_hasher( const T& t ) {
+__TBB_DEPRECATED_MSG("tbb::tbb_hasher is deprecated, use std::hash") inline size_t tbb_hasher( const T& t ) {
     return static_cast<size_t>( t ) * internal::hash_multiplier;
 }
 template<typename P>
-inline size_t tbb_hasher( P* ptr ) {
+__TBB_DEPRECATED_MSG("tbb::tbb_hasher is deprecated, use std::hash") inline size_t tbb_hasher( P* ptr ) {
     size_t const h = reinterpret_cast<size_t>( ptr );
     return (h >> 3) ^ h;
 }
 template<typename E, typename S, typename A>
-inline size_t tbb_hasher( const std::basic_string<E,S,A>& s ) {
+__TBB_DEPRECATED_MSG("tbb::tbb_hasher is deprecated, use std::hash") inline size_t tbb_hasher( const std::basic_string<E,S,A>& s ) {
     size_t h = 0;
     for( const E* c = s.c_str(); *c; ++c )
         h = static_cast<size_t>(*c) ^ (h * internal::hash_multiplier);
     return h;
 }
 template<typename F, typename S>
-inline size_t tbb_hasher( const std::pair<F,S>& p ) {
+__TBB_DEPRECATED_MSG("tbb::tbb_hasher is deprecated, use std::hash") inline size_t tbb_hasher( const std::pair<F,S>& p ) {
     return tbb_hasher(p.first) ^ tbb_hasher(p.second);
 }
 
@@ -87,7 +83,7 @@ using interface5::tbb_hasher;
 
 // Template class for hash compare
 template<typename Key>
-class tbb_hash
+class __TBB_DEPRECATED_MSG("tbb::tbb_hash is deprecated, use std::hash") tbb_hash
 {
 public:
     tbb_hash() {}
diff --git a/inst/include/tbb/internal/_tbb_strings.h b/inst/include/tbb/internal/_tbb_strings.h
index 1aa532f3..df443f3f 100644
--- a/inst/include/tbb/internal/_tbb_strings.h
+++ b/inst/include/tbb/internal/_tbb_strings.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 TBB_STRING_RESOURCE(FLOW_BROADCAST_NODE, "broadcast_node")
@@ -65,3 +61,19 @@ TBB_STRING_RESOURCE(FLOW_NULL, "null")
 TBB_STRING_RESOURCE(FLOW_INDEXER_NODE, "indexer_node")
 TBB_STRING_RESOURCE(FLOW_COMPOSITE_NODE, "composite_node")
 TBB_STRING_RESOURCE(FLOW_ASYNC_NODE, "async_node")
+TBB_STRING_RESOURCE(FLOW_OPENCL_NODE, "opencl_node")
+TBB_STRING_RESOURCE(ALGORITHM, "tbb_algorithm")
+TBB_STRING_RESOURCE(PARALLEL_FOR, "tbb_parallel_for")
+TBB_STRING_RESOURCE(PARALLEL_DO, "tbb_parallel_do")
+TBB_STRING_RESOURCE(PARALLEL_INVOKE, "tbb_parallel_invoke")
+TBB_STRING_RESOURCE(PARALLEL_REDUCE, "tbb_parallel_reduce")
+TBB_STRING_RESOURCE(PARALLEL_SCAN, "tbb_parallel_scan")
+TBB_STRING_RESOURCE(PARALLEL_SORT, "tbb_parallel_sort")
+TBB_STRING_RESOURCE(CUSTOM_CTX, "tbb_custom")
+TBB_STRING_RESOURCE(FLOW_TASKS, "tbb_flow_graph")
+TBB_STRING_RESOURCE(PARALLEL_FOR_TASK, "tbb_parallel_for_task")
+// TODO: Drop following string prefix "fgt_" here and in FGA's collector
+TBB_STRING_RESOURCE(USER_EVENT, "fgt_user_event")
+#if __TBB_CPF_BUILD || (TBB_PREVIEW_FLOW_GRAPH_TRACE && TBB_USE_THREADING_TOOLS)
+TBB_STRING_RESOURCE(CODE_ADDRESS, "code_address")
+#endif
diff --git a/inst/include/tbb/internal/_tbb_trace_impl.h b/inst/include/tbb/internal/_tbb_trace_impl.h
index e7eb5784..38dc68cf 100644
--- a/inst/include/tbb/internal/_tbb_trace_impl.h
+++ b/inst/include/tbb/internal/_tbb_trace_impl.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef _FGT_TBB_TRACE_IMPL_H
@@ -27,18 +23,17 @@ namespace tbb {
     namespace internal {
 
 #if TBB_PREVIEW_ALGORITHM_TRACE
-
         static inline void fgt_algorithm( string_index t, void *algorithm, void *parent ) {
-            itt_make_task_group( ITT_DOMAIN_FLOW, algorithm, FGT_ALGORITHM, parent, FGT_ALGORITHM, t );
+            itt_make_task_group( ITT_DOMAIN_FLOW, algorithm, ALGORITHM, parent, ALGORITHM, t );
         }
         static inline void fgt_begin_algorithm( string_index t, void *algorithm ) {
-            itt_task_begin( ITT_DOMAIN_FLOW, algorithm, FGT_ALGORITHM, NULL, FLOW_NULL, t );
+            itt_task_begin( ITT_DOMAIN_FLOW, algorithm, ALGORITHM, NULL, FLOW_NULL, t );
         }
         static inline void fgt_end_algorithm( void * ) {
             itt_task_end( ITT_DOMAIN_FLOW );
         }
         static inline void fgt_alg_begin_body( string_index t, void *body, void *algorithm ) {
-            itt_task_begin( ITT_DOMAIN_FLOW, body, FLOW_BODY, algorithm, FGT_ALGORITHM, t );
+            itt_task_begin( ITT_DOMAIN_FLOW, body, FLOW_BODY, algorithm, ALGORITHM, t );
         }
         static inline void fgt_alg_end_body( void * ) {
             itt_task_end( ITT_DOMAIN_FLOW );
diff --git a/inst/include/tbb/internal/_tbb_windef.h b/inst/include/tbb/internal/_tbb_windef.h
index e798dee4..b2eb9d5d 100644
--- a/inst/include/tbb/internal/_tbb_windef.h
+++ b/inst/include/tbb/internal/_tbb_windef.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,17 +12,13 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_tbb_windef_H
 #error Do not #include this internal file directly; use public TBB headers instead.
 #endif /* __TBB_tbb_windef_H */
 
-// Check that the target Windows version has all API calls requried for TBB.
+// Check that the target Windows version has all API calls required for TBB.
 // Do not increase the version in condition beyond 0x0500 without prior discussion!
 #if defined(_WIN32_WINNT) && _WIN32_WINNT<0x0501
 #error TBB is unable to run on old Windows versions; _WIN32_WINNT must be 0x0501 or greater.
@@ -54,7 +50,7 @@ namespace std {
 #    endif
 #endif
 
-#if (__TBB_BUILD || __TBBMALLOC_BUILD) && !defined(__TBB_NO_IMPLICIT_LINKAGE)
+#if (__TBB_BUILD || __TBBMALLOC_BUILD || __TBBBIND_BUILD) && !defined(__TBB_NO_IMPLICIT_LINKAGE)
 #define __TBB_NO_IMPLICIT_LINKAGE 1
 #endif
 
diff --git a/inst/include/tbb/internal/_template_helpers.h b/inst/include/tbb/internal/_template_helpers.h
index 1e0abbe8..08470430 100644
--- a/inst/include/tbb/internal/_template_helpers.h
+++ b/inst/include/tbb/internal/_template_helpers.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_template_helpers_H
@@ -23,6 +19,14 @@
 
 #include <utility>
 #include <cstddef>
+#include "../tbb_config.h"
+#if __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT && __TBB_CPP11_TEMPLATE_ALIASES_PRESENT
+#include <type_traits>
+#endif
+#if __TBB_CPP11_PRESENT
+#include <iterator>
+#include <memory> // allocator_traits
+#endif
 
 namespace tbb { namespace internal {
 
@@ -60,11 +64,41 @@ template<class W>          struct is_same_type<W,W> { static const bool value =
 template<typename T> struct is_ref { static const bool value = false; };
 template<typename U> struct is_ref<U&> { static const bool value = true; };
 
+//! Partial support for std::is_integral
+template<typename T> struct is_integral_impl             { static const bool value = false; };
+template<>           struct is_integral_impl<bool>       { static const bool value = true;  };
+template<>           struct is_integral_impl<char>       { static const bool value = true;  };
+#if __TBB_CPP11_PRESENT
+template<>           struct is_integral_impl<char16_t>   { static const bool value = true;  };
+template<>           struct is_integral_impl<char32_t>   { static const bool value = true;  };
+#endif
+template<>           struct is_integral_impl<wchar_t>    { static const bool value = true;  };
+template<>           struct is_integral_impl<short>      { static const bool value = true;  };
+template<>           struct is_integral_impl<int>        { static const bool value = true;  };
+template<>           struct is_integral_impl<long>       { static const bool value = true;  };
+template<>           struct is_integral_impl<long long>  { static const bool value = true;  };
+
+template<typename T>
+struct is_integral : is_integral_impl<typename strip<T>::type> {};
+
 #if __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT
 //! std::void_t internal implementation (to avoid GCC < 4.7 "template aliases" absence)
 template<typename...> struct void_t { typedef void type; };
 #endif
 
+#if __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT && __TBB_CPP11_TEMPLATE_ALIASES_PRESENT
+
+// Generic SFINAE helper for expression checks, based on the idea demonstrated in ISO C++ paper n4502
+template<typename T, typename, template<typename> class... Checks>
+struct supports_impl { typedef std::false_type type; };
+template<typename T, template<typename> class... Checks>
+struct supports_impl<T, typename void_t<Checks<T>...>::type, Checks...> { typedef std::true_type type; };
+
+template<typename T, template<typename> class... Checks>
+using supports = typename supports_impl<T, void, Checks...>::type;
+
+#endif /* __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT && __TBB_CPP11_TEMPLATE_ALIASES_PRESENT */
+
 #if __TBB_CPP11_RVALUE_REF_PRESENT && __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT
 
 //! Allows to store a function parameter pack as a variable and later pass it to another function
@@ -153,6 +187,125 @@ stored_pack<Types...> save_pack( Types&&... types ) {
 }
 
 #endif /* __TBB_CPP11_RVALUE_REF_PRESENT && __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT */
+
+#if __TBB_CPP14_INTEGER_SEQUENCE_PRESENT
+
+using std::index_sequence;
+using std::make_index_sequence;
+
+#elif __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT && __TBB_CPP11_TEMPLATE_ALIASES_PRESENT
+
+template<std::size_t... S> class index_sequence {};
+
+template<std::size_t N, std::size_t... S>
+struct make_index_sequence_impl : make_index_sequence_impl < N - 1, N - 1, S... > {};
+
+template<std::size_t... S>
+struct make_index_sequence_impl <0, S...> {
+    using type = index_sequence<S...>;
+};
+
+template<std::size_t N>
+using make_index_sequence = typename tbb::internal::make_index_sequence_impl<N>::type;
+
+#endif /* __TBB_CPP14_INTEGER_SEQUENCE_PRESENT */
+
+#if __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT
+template<typename... Args>
+struct conjunction;
+
+template<typename First, typename... Args>
+struct conjunction<First, Args...>
+    : std::conditional<bool(First::value), conjunction<Args...>, First>::type {};
+
+template<typename T>
+struct conjunction<T> : T {};
+
+template<>
+struct conjunction<> : std::true_type {};
+
+#endif
+
+#if __TBB_CPP11_PRESENT
+
+template< typename Iter >
+using iterator_value_t = typename std::iterator_traits<Iter>::value_type;
+
+template< typename Iter >
+using iterator_key_t = typename std::remove_const<typename iterator_value_t<Iter>::first_type>::type;
+
+template< typename Iter >
+using iterator_mapped_t = typename iterator_value_t<Iter>::second_type;
+
+template< typename A > using value_type = typename A::value_type;
+template< typename A > using alloc_ptr_t = typename std::allocator_traits<A>::pointer;
+template< typename A > using has_allocate = decltype(std::declval<alloc_ptr_t<A>&>() = std::declval<A>().allocate(0));
+template< typename A > using has_deallocate = decltype(std::declval<A>().deallocate(std::declval<alloc_ptr_t<A>>(), 0));
+
+// value_type should be checked first because it can be used in other checks (via allocator_traits)
+template< typename T >
+using is_allocator = supports<T, value_type, has_allocate, has_deallocate>;
+
+#if __TBB_CPP14_VARIABLE_TEMPLATES_PRESENT
+
+template< typename T >
+static constexpr bool is_allocator_v = is_allocator<T>::value;
+
+#endif /*__TBB_CPP14_VARIABLE_TEMPLATES */
+
+template< std::size_t N, typename... Args >
+struct pack_element {
+    using type = void;
+};
+
+template< std::size_t N, typename T, typename... Args >
+struct pack_element<N, T, Args...> {
+    using type = typename pack_element<N - 1, Args...>::type;
+};
+
+template< typename T, typename... Args >
+struct pack_element<0, T, Args...> {
+    using type = T;
+};
+
+template< std::size_t N, typename... Args >
+using pack_element_t = typename pack_element<N, Args...>::type;
+
+// Helper alias for heterogeneous lookup functions in containers
+// template parameter K and std::conditional are needed to provide immediate context
+// and postpone getting is_trasparent from the compare functor until method instantiation.
+template <typename Comp, typename K>
+using is_transparent = typename std::conditional<true, Comp, K>::type::is_transparent;
+
+#endif /* __TBB_CPP11_PRESENT */
+
+template <typename F>
+struct body_arg_detector;
+
+template <typename Callable, typename ReturnType, typename T>
+struct body_arg_detector<ReturnType(Callable::*)(T)> {
+    typedef T arg_type;
+};
+
+template <typename Callable, typename ReturnType, typename T>
+struct body_arg_detector<ReturnType(Callable::*)(T) const> {
+    typedef T arg_type;
+};
+
+#if __TBB_CPP11_PRESENT
+using std::conditional;
+#else
+template <bool C, typename T, typename U>
+struct conditional {
+    typedef U type;
+};
+
+template <typename T, typename U>
+struct conditional<true, T, U> {
+    typedef T type;
+};
+#endif
+
 } } // namespace internal, namespace tbb
 
 #endif /* __TBB_template_helpers_H */
diff --git a/inst/include/tbb/internal/_warning_suppress_disable_notice.h b/inst/include/tbb/internal/_warning_suppress_disable_notice.h
new file mode 100644
index 00000000..1b536463
--- /dev/null
+++ b/inst/include/tbb/internal/_warning_suppress_disable_notice.h
@@ -0,0 +1,27 @@
+/*
+    Copyright (c) 2005-2020 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 __TBB_SUPPRESS_INTERNAL_DEPRECATED_MESSAGES
+
+#if __INTEL_COMPILER || _MSC_VER
+#pragma warning( pop )
+#elif __GNUC__
+#pragma GCC diagnostic pop
+#elif __clang__
+#pragma clang diagnostic pop
+#endif
+
+#endif  // __TBB_SUPPRESS_INTERNAL_DEPRECATED_MESSAGES
diff --git a/inst/include/tbb/internal/_warning_suppress_enable_notice.h b/inst/include/tbb/internal/_warning_suppress_enable_notice.h
new file mode 100644
index 00000000..3b927231
--- /dev/null
+++ b/inst/include/tbb/internal/_warning_suppress_enable_notice.h
@@ -0,0 +1,32 @@
+/*
+    Copyright (c) 2005-2020 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 "../tbb_config.h"
+
+#if __TBB_SUPPRESS_INTERNAL_DEPRECATED_MESSAGES
+
+#if _MSC_VER || __INTEL_COMPILER
+#pragma warning( push )
+#pragma warning( disable: 4996 )
+#elif __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#elif __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+#endif
+
+#endif  // __TBB_SUPPRESS_INTERNAL_DEPRECATED_MESSAGES
diff --git a/inst/include/tbb/internal/_x86_eliding_mutex_impl.h b/inst/include/tbb/internal/_x86_eliding_mutex_impl.h
index ef5f9223..11be329d 100644
--- a/inst/include/tbb/internal/_x86_eliding_mutex_impl.h
+++ b/inst/include/tbb/internal/_x86_eliding_mutex_impl.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB__x86_eliding_mutex_impl_H
diff --git a/inst/include/tbb/internal/_x86_rtm_rw_mutex_impl.h b/inst/include/tbb/internal/_x86_rtm_rw_mutex_impl.h
index b08c2331..9373aaa0 100644
--- a/inst/include/tbb/internal/_x86_rtm_rw_mutex_impl.h
+++ b/inst/include/tbb/internal/_x86_rtm_rw_mutex_impl.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB__x86_rtm_rw_mutex_impl_H
@@ -88,11 +84,11 @@ class x86_rtm_rw_mutex: private spin_rw_mutex {
 
     static x86_rtm_rw_mutex* internal_get_mutex( const spin_rw_mutex::scoped_lock& lock )
     {
-        return static_cast<x86_rtm_rw_mutex*>( lock.internal_get_mutex() );
+        return static_cast<x86_rtm_rw_mutex*>( lock.mutex );
     }
     static void internal_set_mutex( spin_rw_mutex::scoped_lock& lock, spin_rw_mutex* mtx )
     {
-        lock.internal_set_mutex( mtx );
+        lock.mutex = mtx;
     }
     //! @endcond
 public:
@@ -171,7 +167,8 @@ class x86_rtm_rw_mutex: private spin_rw_mutex {
         bool upgrade_to_writer() {
             x86_rtm_rw_mutex* mutex = x86_rtm_rw_mutex::internal_get_mutex(my_scoped_lock);
             __TBB_ASSERT( mutex, "lock is not acquired" );
-            __TBB_ASSERT( transaction_state==RTM_transacting_reader || transaction_state==RTM_real_reader, "Invalid state for upgrade" );
+            if (transaction_state == RTM_transacting_writer || transaction_state == RTM_real_writer)
+                return true; // Already a writer
             return mutex->internal_upgrade(*this);
         }
 
@@ -180,7 +177,8 @@ class x86_rtm_rw_mutex: private spin_rw_mutex {
         bool downgrade_to_reader() {
             x86_rtm_rw_mutex* mutex = x86_rtm_rw_mutex::internal_get_mutex(my_scoped_lock);
             __TBB_ASSERT( mutex, "lock is not acquired" );
-            __TBB_ASSERT( transaction_state==RTM_transacting_writer || transaction_state==RTM_real_writer, "Invalid state for downgrade" );
+            if (transaction_state == RTM_transacting_reader || transaction_state == RTM_real_reader)
+                return true; // Already a reader
             return mutex->internal_downgrade(*this);
         }
 
diff --git a/inst/include/tbb/iterators.h b/inst/include/tbb/iterators.h
new file mode 100644
index 00000000..2d4da9c9
--- /dev/null
+++ b/inst/include/tbb/iterators.h
@@ -0,0 +1,326 @@
+/*
+    Copyright (c) 2017-2020 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.
+*/
+
+#ifndef __TBB_iterators_H
+#define __TBB_iterators_H
+
+#include <iterator>
+#include <limits>
+
+#include "tbb_config.h"
+#include "tbb_stddef.h"
+
+#if __TBB_CPP11_PRESENT
+
+#include <type_traits>
+
+namespace tbb {
+
+template <typename IntType>
+class counting_iterator {
+    __TBB_STATIC_ASSERT(std::numeric_limits<IntType>::is_integer, "Cannot instantiate counting_iterator with a non-integer type");
+public:
+    typedef typename std::make_signed<IntType>::type difference_type;
+    typedef IntType value_type;
+    typedef const IntType* pointer;
+    typedef const IntType& reference;
+    typedef std::random_access_iterator_tag iterator_category;
+
+    counting_iterator() : my_counter() {}
+    explicit counting_iterator(IntType init) : my_counter(init) {}
+
+    reference operator*() const { return my_counter; }
+    value_type operator[](difference_type i) const { return *(*this + i); }
+
+    difference_type operator-(const counting_iterator& it) const { return my_counter - it.my_counter; }
+
+    counting_iterator& operator+=(difference_type forward) { my_counter += forward; return *this; }
+    counting_iterator& operator-=(difference_type backward) { return *this += -backward; }
+    counting_iterator& operator++() { return *this += 1; }
+    counting_iterator& operator--() { return *this -= 1; }
+
+    counting_iterator operator++(int) {
+        counting_iterator it(*this);
+        ++(*this);
+        return it;
+    }
+    counting_iterator operator--(int) {
+        counting_iterator it(*this);
+        --(*this);
+        return it;
+    }
+
+    counting_iterator operator-(difference_type backward) const { return counting_iterator(my_counter - backward); }
+    counting_iterator operator+(difference_type forward) const { return counting_iterator(my_counter + forward); }
+    friend counting_iterator operator+(difference_type forward, const counting_iterator it) { return it + forward; }
+
+    bool operator==(const counting_iterator& it) const { return *this - it == 0; }
+    bool operator!=(const counting_iterator& it) const { return !(*this == it); }
+    bool operator<(const counting_iterator& it) const {return *this - it < 0; }
+    bool operator>(const counting_iterator& it) const { return it < *this; }
+    bool operator<=(const counting_iterator& it) const { return !(*this > it); }
+    bool operator>=(const counting_iterator& it) const { return !(*this < it); }
+
+private:
+    IntType my_counter;
+};
+} //namespace tbb
+
+
+#include <tuple>
+
+#include "internal/_template_helpers.h" // index_sequence, make_index_sequence
+
+namespace tbb {
+namespace internal {
+
+template<size_t N>
+struct tuple_util {
+    template<typename TupleType, typename DifferenceType>
+    static void increment(TupleType& it, DifferenceType forward) {
+        std::get<N-1>(it) += forward;
+        tuple_util<N-1>::increment(it, forward);
+    }
+    template<typename TupleType, typename DifferenceType>
+    static bool check_sync(const TupleType& it1, const TupleType& it2, DifferenceType val) {
+        if(std::get<N-1>(it1) - std::get<N-1>(it2) != val)
+            return false;
+        return tuple_util<N-1>::check_sync(it1, it2, val);
+    }
+};
+
+template<>
+struct tuple_util<0> {
+    template<typename TupleType, typename DifferenceType>
+    static void increment(TupleType&, DifferenceType) {}
+    template<typename TupleType, typename DifferenceType>
+    static bool check_sync(const TupleType&, const TupleType&, DifferenceType) { return true;}
+};
+
+template <typename TupleReturnType>
+struct make_references {
+    template <typename TupleType, std::size_t... Is>
+    TupleReturnType operator()(const TupleType& t, tbb::internal::index_sequence<Is...>) {
+        return std::tie( *std::get<Is>(t)... );
+    }
+};
+
+// A simple wrapper over a tuple of references.
+// The class is designed to hold a temporary tuple of reference
+// after dereferencing a zip_iterator; in particular, it is needed
+// to swap these rvalue tuples. Any other usage is not supported.
+template<typename... T>
+struct tuplewrapper : public std::tuple<typename std::enable_if<std::is_reference<T>::value, T&&>::type...> {
+    // In the context of this class, T is a reference, so T&& is a "forwarding reference"
+    typedef std::tuple<T&&...> base_type;
+    // Construct from the result of std::tie
+    tuplewrapper(const base_type& in) : base_type(in) {}
+#if __INTEL_COMPILER
+    // ICC cannot generate copy ctor & assignment
+    tuplewrapper(const tuplewrapper& rhs) : base_type(rhs) {}
+    tuplewrapper& operator=(const tuplewrapper& rhs) {
+        *this = base_type(rhs);
+        return *this;
+    }
+#endif
+    // Assign any tuple convertible to std::tuple<T&&...>: *it = a_tuple;
+    template<typename... U>
+    tuplewrapper& operator=(const std::tuple<U...>& other) {
+        base_type::operator=(other);
+        return *this;
+    }
+#if _LIBCPP_VERSION
+    // (Necessary for libc++ tuples) Convert to a tuple of values: v = *it;
+    operator std::tuple<typename std::remove_reference<T>::type...>() { return base_type(*this); }
+#endif
+    // Swap rvalue tuples: swap(*it1,*it2);
+    friend void swap(tuplewrapper&& a, tuplewrapper&& b) {
+        std::swap<T&&...>(a,b);
+    }
+};
+
+} //namespace internal
+
+template <typename... Types>
+class zip_iterator {
+    __TBB_STATIC_ASSERT(sizeof...(Types)>0, "Cannot instantiate zip_iterator with empty template parameter pack");
+    static const std::size_t num_types = sizeof...(Types);
+    typedef std::tuple<Types...> it_types;
+public:
+    typedef typename std::make_signed<std::size_t>::type difference_type;
+    typedef std::tuple<typename std::iterator_traits<Types>::value_type...> value_type;
+#if __INTEL_COMPILER && __INTEL_COMPILER < 1800 && _MSC_VER
+    typedef std::tuple<typename std::iterator_traits<Types>::reference...> reference;
+#else
+    typedef tbb::internal::tuplewrapper<typename std::iterator_traits<Types>::reference...> reference;
+#endif
+    typedef std::tuple<typename std::iterator_traits<Types>::pointer...> pointer;
+    typedef std::random_access_iterator_tag iterator_category;
+
+    zip_iterator() : my_it() {}
+    explicit zip_iterator(Types... args) : my_it(std::make_tuple(args...)) {}
+    zip_iterator(const zip_iterator& input) : my_it(input.my_it) {}
+    zip_iterator& operator=(const zip_iterator& input) {
+        my_it = input.my_it;
+        return *this;
+    }
+
+    reference operator*() const {
+        return tbb::internal::make_references<reference>()(my_it, tbb::internal::make_index_sequence<num_types>());
+    }
+    reference operator[](difference_type i) const { return *(*this + i); }
+
+    difference_type operator-(const zip_iterator& it) const {
+        __TBB_ASSERT(internal::tuple_util<num_types>::check_sync(my_it, it.my_it, std::get<0>(my_it) - std::get<0>(it.my_it)),
+                     "Components of zip_iterator are not synchronous");
+        return std::get<0>(my_it) - std::get<0>(it.my_it);
+    }
+
+    zip_iterator& operator+=(difference_type forward) {
+        internal::tuple_util<num_types>::increment(my_it, forward);
+        return *this;
+    }
+    zip_iterator& operator-=(difference_type backward) { return *this += -backward; }
+    zip_iterator& operator++() { return *this += 1; }
+    zip_iterator& operator--() { return *this -= 1; }
+
+    zip_iterator operator++(int) {
+        zip_iterator it(*this);
+        ++(*this);
+        return it;
+    }
+    zip_iterator operator--(int) {
+        zip_iterator it(*this);
+        --(*this);
+        return it;
+    }
+
+    zip_iterator operator-(difference_type backward) const {
+        zip_iterator it(*this);
+        return it -= backward;
+    }
+    zip_iterator operator+(difference_type forward) const {
+        zip_iterator it(*this);
+        return it += forward;
+    }
+    friend zip_iterator operator+(difference_type forward, const zip_iterator& it) { return it + forward; }
+
+    bool operator==(const zip_iterator& it) const {
+        return *this - it == 0;
+    }
+    it_types base() const { return my_it; }
+
+    bool operator!=(const zip_iterator& it) const { return !(*this == it); }
+    bool operator<(const zip_iterator& it) const { return *this - it < 0; }
+    bool operator>(const zip_iterator& it) const { return it < *this; }
+    bool operator<=(const zip_iterator& it) const { return !(*this > it); }
+    bool operator>=(const zip_iterator& it) const { return !(*this < it); }
+private:
+    it_types my_it;
+};
+
+template<typename... T>
+zip_iterator<T...> make_zip_iterator(T... args) { return zip_iterator<T...>(args...); }
+
+template <typename UnaryFunc, typename Iter>
+class transform_iterator {
+public:
+    typedef typename std::iterator_traits<Iter>::value_type value_type;
+    typedef typename std::iterator_traits<Iter>::difference_type difference_type;
+#if __TBB_CPP17_INVOKE_RESULT_PRESENT
+    typedef typename std::invoke_result<UnaryFunc, typename std::iterator_traits<Iter>::reference>::type reference;
+#else
+    typedef typename std::result_of<UnaryFunc(typename std::iterator_traits<Iter>::reference)>::type reference;
+#endif
+    typedef typename std::iterator_traits<Iter>::pointer pointer;
+    typedef typename std::random_access_iterator_tag iterator_category;
+
+    transform_iterator(Iter it, UnaryFunc unary_func) : my_it(it), my_unary_func(unary_func) {
+        __TBB_STATIC_ASSERT((std::is_same<typename std::iterator_traits<Iter>::iterator_category,
+                             std::random_access_iterator_tag>::value), "Random access iterator required.");
+    }
+    transform_iterator(const transform_iterator& input) : my_it(input.my_it), my_unary_func(input.my_unary_func) { }
+    transform_iterator& operator=(const transform_iterator& input) {
+        my_it = input.my_it;
+        return *this;
+    }
+    reference operator*() const {
+        return my_unary_func(*my_it);
+    }
+    reference operator[](difference_type i) const {
+        return *(*this + i);
+    }
+    transform_iterator& operator++() {
+        ++my_it;
+        return *this;
+    }
+    transform_iterator& operator--() {
+        --my_it;
+        return *this;
+    }
+    transform_iterator operator++(int) {
+        transform_iterator it(*this);
+        ++(*this);
+        return it;
+    }
+    transform_iterator operator--(int) {
+        transform_iterator it(*this);
+        --(*this);
+        return it;
+    }
+    transform_iterator operator+(difference_type forward) const {
+        return { my_it + forward, my_unary_func };
+    }
+    transform_iterator operator-(difference_type backward) const {
+        return { my_it - backward, my_unary_func };
+    }
+    transform_iterator& operator+=(difference_type forward) {
+        my_it += forward;
+        return *this;
+    }
+    transform_iterator& operator-=(difference_type backward) {
+        my_it -= backward;
+        return *this;
+    }
+    friend transform_iterator operator+(difference_type forward, const transform_iterator& it) {
+        return it + forward;
+    }
+    difference_type operator-(const transform_iterator& it) const {
+        return my_it - it.my_it;
+    }
+    bool operator==(const transform_iterator& it) const { return *this - it == 0; }
+    bool operator!=(const transform_iterator& it) const { return !(*this == it); }
+    bool operator<(const transform_iterator& it) const { return *this - it < 0; }
+    bool operator>(const transform_iterator& it) const { return it < *this; }
+    bool operator<=(const transform_iterator& it) const { return !(*this > it); }
+    bool operator>=(const transform_iterator& it) const { return !(*this < it); }
+
+    Iter base() const { return my_it; }
+private:
+    Iter my_it;
+    const UnaryFunc my_unary_func;
+};
+
+template<typename UnaryFunc, typename Iter>
+transform_iterator<UnaryFunc, Iter> make_transform_iterator(Iter it, UnaryFunc unary_func) {
+    return transform_iterator<UnaryFunc, Iter>(it, unary_func);
+}
+
+} //namespace tbb
+
+#endif //__TBB_CPP11_PRESENT
+
+#endif /* __TBB_iterators_H */
diff --git a/inst/include/tbb/machine/gcc_armv7.h b/inst/include/tbb/machine/gcc_arm.h
similarity index 94%
rename from inst/include/tbb/machine/gcc_armv7.h
rename to inst/include/tbb/machine/gcc_arm.h
index 642c14fe..284a3f9e 100644
--- a/inst/include/tbb/machine/gcc_armv7.h
+++ b/inst/include/tbb/machine/gcc_arm.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 /*
@@ -26,10 +22,7 @@
 #error Do not include this file directly; include tbb_machine.h instead
 #endif
 
-//TODO: is ARMv7 is the only version ever to support?
-#if !(__ARM_ARCH_7A__)
-#error compilation requires an ARMv7-a architecture.
-#endif
+#if __ARM_ARCH_7A__
 
 #include <sys/param.h>
 #include <unistd.h>
@@ -171,15 +164,6 @@ static inline int64_t __TBB_machine_fetchadd8(volatile void *ptr, int64_t addend
     return result;
 }
 
-inline void __TBB_machine_pause (int32_t delay )
-{
-    while(delay>0)
-    {
-	__TBB_compiler_fence();
-        delay--;
-    }
-}
-
 namespace tbb {
 namespace internal {
     template <typename T, size_t S>
@@ -205,7 +189,6 @@ namespace internal {
 
 #define __TBB_CompareAndSwap4(P,V,C) __TBB_machine_cmpswp4(P,V,C)
 #define __TBB_CompareAndSwap8(P,V,C) __TBB_machine_cmpswp8(P,V,C)
-#define __TBB_Pause(V) __TBB_machine_pause(V)
 
 // Use generics for some things
 #define __TBB_USE_GENERIC_PART_WORD_CAS                         1
@@ -215,3 +198,19 @@ namespace internal {
 #define __TBB_USE_GENERIC_HALF_FENCED_LOAD_STORE                1
 #define __TBB_USE_GENERIC_DWORD_LOAD_STORE                      1
 #define __TBB_USE_GENERIC_SEQUENTIAL_CONSISTENCY_LOAD_STORE     1
+#elif defined __aarch64__
+// Generic gcc implementations are fine for ARMv8-a except __TBB_PAUSE.
+#include "gcc_generic.h"
+#else
+#error compilation requires an ARMv7-a or ARMv8-a architecture.
+#endif // __ARM_ARCH_7A__
+
+inline void __TBB_machine_pause (int32_t delay)
+{
+    while(delay>0)
+    {
+        __asm__ __volatile__("yield" ::: "memory");
+        delay--;
+    }
+}
+#define __TBB_Pause(V) __TBB_machine_pause(V)
diff --git a/inst/include/tbb/machine/gcc_generic.h b/inst/include/tbb/machine/gcc_generic.h
index 5fc2a901..9b157721 100644
--- a/inst/include/tbb/machine/gcc_generic.h
+++ b/inst/include/tbb/machine/gcc_generic.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 !defined(__TBB_machine_H) || defined(__TBB_machine_gcc_generic_H)
@@ -106,23 +102,17 @@ __TBB_MACHINE_DEFINE_ATOMICS(8,int64_t)
 
 #undef __TBB_MACHINE_DEFINE_ATOMICS
 
-namespace tbb{ namespace internal { namespace gcc_builtins {
-    inline int clz(unsigned int x){ return __builtin_clz(x);};
-    inline int clz(unsigned long int x){ return __builtin_clzl(x);};
-    inline int clz(unsigned long long int x){ return __builtin_clzll(x);};
-}}}
-//gcc __builtin_clz builtin count _number_ of leading zeroes
-static inline intptr_t __TBB_machine_lg( uintptr_t x ) {
-    return sizeof(x)*8 - tbb::internal::gcc_builtins::clz(x) -1 ;
-}
-
-
 typedef unsigned char __TBB_Flag;
 typedef __TBB_atomic __TBB_Flag __TBB_atomic_flag;
 
 #if __TBB_GCC_VERSION < 40700
 // Use __sync_* builtins
 
+// Use generic machine_load_store functions if there are no builtin atomics
+#define __TBB_USE_GENERIC_HALF_FENCED_LOAD_STORE            1
+#define __TBB_USE_GENERIC_RELAXED_LOAD_STORE                1
+#define __TBB_USE_GENERIC_SEQUENTIAL_CONSISTENCY_LOAD_STORE 1
+
 static inline void __TBB_machine_or( volatile void *ptr, uintptr_t addend ) {
     __sync_fetch_and_or(reinterpret_cast<volatile uintptr_t *>(ptr),addend);
 }
@@ -158,6 +148,59 @@ inline void __TBB_machine_unlock_byte( __TBB_atomic_flag &flag ) {
     __atomic_clear(&flag,__ATOMIC_RELEASE);
 }
 
+namespace tbb { namespace internal {
+
+/** GCC atomic operation intrinsics might miss compiler fence.
+    Adding it after load-with-acquire, before store-with-release, and
+    on both sides of sequentially consistent operations is sufficient for correctness. **/
+
+template <typename T, int MemOrder>
+inline T __TBB_machine_atomic_load( const volatile T& location) {
+    if (MemOrder == __ATOMIC_SEQ_CST) __TBB_compiler_fence();
+    T value = __atomic_load_n(&location, MemOrder);
+    if (MemOrder != __ATOMIC_RELAXED) __TBB_compiler_fence();
+    return value;
+}
+
+template <typename T, int MemOrder>
+inline void __TBB_machine_atomic_store( volatile T& location, T value) {
+    if (MemOrder != __ATOMIC_RELAXED) __TBB_compiler_fence();
+    __atomic_store_n(&location, value, MemOrder);
+    if (MemOrder == __ATOMIC_SEQ_CST) __TBB_compiler_fence();
+}
+
+template <typename T, size_t S>
+struct machine_load_store {
+    static T load_with_acquire ( const volatile T& location ) {
+        return __TBB_machine_atomic_load<T, __ATOMIC_ACQUIRE>(location);
+    }
+    static void store_with_release ( volatile T &location, T value ) {
+        __TBB_machine_atomic_store<T, __ATOMIC_RELEASE>(location, value);
+    }
+};
+
+template <typename T, size_t S>
+struct machine_load_store_relaxed {
+    static inline T load ( const volatile T& location ) {
+        return __TBB_machine_atomic_load<T, __ATOMIC_RELAXED>(location);
+    }
+    static inline void store ( volatile T& location, T value ) {
+        __TBB_machine_atomic_store<T, __ATOMIC_RELAXED>(location, value);
+    }
+};
+
+template <typename T, size_t S>
+struct machine_load_store_seq_cst {
+    static T load ( const volatile T& location ) {
+        return __TBB_machine_atomic_load<T, __ATOMIC_SEQ_CST>(location);
+    }
+    static void store ( volatile T &location, T value ) {
+        __TBB_machine_atomic_store<T, __ATOMIC_SEQ_CST>(location, value);
+    }
+};
+
+}} // namespace tbb::internal
+
 #endif // __TBB_GCC_VERSION < 40700
 
 // Machine specific atomic operations
@@ -167,18 +210,24 @@ inline void __TBB_machine_unlock_byte( __TBB_atomic_flag &flag ) {
 #define __TBB_TryLockByte   __TBB_machine_try_lock_byte
 #define __TBB_UnlockByte    __TBB_machine_unlock_byte
 
-// Definition of other functions
-#define __TBB_Log2(V)           __TBB_machine_lg(V)
+// __builtin_clz counts the number of leading zeroes
+namespace tbb{ namespace internal { namespace gcc_builtins {
+    inline int clz(unsigned int x){ return __builtin_clz(x); }
+    inline int clz(unsigned long int x){ return __builtin_clzl(x); }
+    inline int clz(unsigned long long int x){ return __builtin_clzll(x); }
+}}}
+// logarithm is the index of the most significant non-zero bit
+static inline intptr_t __TBB_machine_lg( uintptr_t x ) {
+    // If P is a power of 2 and x<P, then (P-1)-x == (P-1) XOR x
+    return (sizeof(x)*8 - 1) ^ tbb::internal::gcc_builtins::clz(x);
+}
 
-// TODO: implement with __atomic_* builtins where available
-#define __TBB_USE_GENERIC_HALF_FENCED_LOAD_STORE            1
-#define __TBB_USE_GENERIC_RELAXED_LOAD_STORE                1
-#define __TBB_USE_GENERIC_SEQUENTIAL_CONSISTENCY_LOAD_STORE 1
+#define __TBB_Log2(V)  __TBB_machine_lg(V)
 
 #if __TBB_WORDSIZE==4
     #define __TBB_USE_GENERIC_DWORD_LOAD_STORE              1
 #endif
 
 #if __TBB_x86_32 || __TBB_x86_64
-#include "gcc_itsx.h"
+#include "gcc_ia32_common.h"
 #endif
diff --git a/inst/include/tbb/machine/gcc_ia32_common.h b/inst/include/tbb/machine/gcc_ia32_common.h
index f5efc375..975d389e 100644
--- a/inst/include/tbb/machine/gcc_ia32_common.h
+++ b/inst/include/tbb/machine/gcc_ia32_common.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,19 +12,15 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_machine_gcc_ia32_common_H
 #define __TBB_machine_gcc_ia32_common_H
 
+#ifndef __TBB_Log2
 //TODO: Add a higher-level function, e.g. tbb::internal::log2(), into tbb_stddef.h, which
 //uses __TBB_Log2 and contains the assert and remove the assert from here and all other
 //platform-specific headers.
-//TODO: Check if use of gcc intrinsic gives a better chance for cross call optimizations
 template <typename T>
 static inline intptr_t __TBB_machine_lg( T x ) {
     __TBB_ASSERT(x>0, "The logarithm of a non-positive value is undefined.");
@@ -33,6 +29,7 @@ static inline intptr_t __TBB_machine_lg( T x ) {
     return j;
 }
 #define __TBB_Log2(V)  __TBB_machine_lg(V)
+#endif /* !__TBB_Log2 */
 
 #ifndef __TBB_Pause
 //TODO: check if raising a ratio of pause instructions to loop control instructions
diff --git a/inst/include/tbb/machine/gcc_itsx.h b/inst/include/tbb/machine/gcc_itsx.h
index caa35441..5e93a202 100644
--- a/inst/include/tbb/machine/gcc_itsx.h
+++ b/inst/include/tbb/machine/gcc_itsx.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 !defined(__TBB_machine_H) || defined(__TBB_machine_gcc_itsx_H)
diff --git a/inst/include/tbb/machine/ibm_aix51.h b/inst/include/tbb/machine/ibm_aix51.h
index a905b4e1..c8246848 100644
--- a/inst/include/tbb/machine/ibm_aix51.h
+++ b/inst/include/tbb/machine/ibm_aix51.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 // TODO: revise by comparing with mac_ppc.h
diff --git a/inst/include/tbb/machine/icc_generic.h b/inst/include/tbb/machine/icc_generic.h
index 04863000..c4675b8e 100644
--- a/inst/include/tbb/machine/icc_generic.h
+++ b/inst/include/tbb/machine/icc_generic.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 !defined(__TBB_machine_H) || defined(__TBB_machine_icc_generic_H)
@@ -23,7 +19,7 @@
 #endif
 
 #if ! __TBB_ICC_BUILTIN_ATOMICS_PRESENT
-    #error "Intel C++ Compiler of at least 12.0 version is needed to use ICC intrinsics port"
+    #error "Intel(R) C++ Compiler of at least 12.0 version is needed to use ICC intrinsics port"
 #endif
 
 #define __TBB_machine_icc_generic_H
diff --git a/inst/include/tbb/machine/linux_common.h b/inst/include/tbb/machine/linux_common.h
index 4d2d355b..9dc6c813 100644
--- a/inst/include/tbb/machine/linux_common.h
+++ b/inst/include/tbb/machine/linux_common.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_machine_H
@@ -30,19 +26,44 @@
 #include <sys/syscall.h>
 
 #if defined(SYS_futex)
+/* This header file is included for Linux and some other systems that may support futexes.*/
 
 #define __TBB_USE_FUTEX 1
+
+#if defined(__has_include)
+#define __TBB_has_include __has_include
+#else
+#define __TBB_has_include(x) 0
+#endif
+
+/*
+If available, use typical headers where futex API is defined. While Linux and OpenBSD
+are known to provide such headers, other systems might have them as well.
+*/
+#if defined(__linux__) || __TBB_has_include(<linux/futex.h>)
+#include <linux/futex.h>
+#elif defined(__OpenBSD__) || __TBB_has_include(<sys/futex.h>)
+#include <sys/futex.h>
+#endif
+
 #include <limits.h>
 #include <errno.h>
-// Unfortunately, some versions of Linux do not have a header that defines FUTEX_WAIT and FUTEX_WAKE.
 
-#ifdef FUTEX_WAIT
+/*
+Some systems might not define the macros or use different names. In such case we expect
+the actual parameter values to match Linux: 0 for wait, 1 for wake.
+*/
+#if defined(FUTEX_WAIT_PRIVATE)
+#define __TBB_FUTEX_WAIT FUTEX_WAIT_PRIVATE
+#elif defined(FUTEX_WAIT)
 #define __TBB_FUTEX_WAIT FUTEX_WAIT
 #else
 #define __TBB_FUTEX_WAIT 0
 #endif
 
-#ifdef FUTEX_WAKE
+#if defined(FUTEX_WAKE_PRIVATE)
+#define __TBB_FUTEX_WAKE FUTEX_WAKE_PRIVATE
+#elif defined(FUTEX_WAKE)
 #define __TBB_FUTEX_WAKE FUTEX_WAKE
 #else
 #define __TBB_FUTEX_WAKE 1
diff --git a/inst/include/tbb/machine/linux_ia32.h b/inst/include/tbb/machine/linux_ia32.h
index 932d343d..3942d8bf 100644
--- a/inst/include/tbb/machine/linux_ia32.h
+++ b/inst/include/tbb/machine/linux_ia32.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 !defined(__TBB_machine_H) || defined(__TBB_machine_linux_ia32_H)
diff --git a/inst/include/tbb/machine/linux_ia64.h b/inst/include/tbb/machine/linux_ia64.h
index f4772288..28b2bc41 100644
--- a/inst/include/tbb/machine/linux_ia64.h
+++ b/inst/include/tbb/machine/linux_ia64.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 !defined(__TBB_machine_H) || defined(__TBB_machine_linux_ia64_H)
diff --git a/inst/include/tbb/machine/linux_intel64.h b/inst/include/tbb/machine/linux_intel64.h
index 02153c2a..907ead52 100644
--- a/inst/include/tbb/machine/linux_intel64.h
+++ b/inst/include/tbb/machine/linux_intel64.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 !defined(__TBB_machine_H) || defined(__TBB_machine_linux_intel64_H)
diff --git a/inst/include/tbb/machine/mac_ppc.h b/inst/include/tbb/machine/mac_ppc.h
index 13f387b4..2eb5ad3a 100644
--- a/inst/include/tbb/machine/mac_ppc.h
+++ b/inst/include/tbb/machine/mac_ppc.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 !defined(__TBB_machine_H) || defined(__TBB_machine_gcc_power_H)
diff --git a/inst/include/tbb/machine/macos_common.h b/inst/include/tbb/machine/macos_common.h
index 119ad979..87bb5e3e 100644
--- a/inst/include/tbb/machine/macos_common.h
+++ b/inst/include/tbb/machine/macos_common.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 !defined(__TBB_machine_H) || defined(__TBB_machine_macos_common_H)
diff --git a/inst/include/tbb/machine/mic_common.h b/inst/include/tbb/machine/mic_common.h
index 8765d39f..8c844f1d 100644
--- a/inst/include/tbb/machine/mic_common.h
+++ b/inst/include/tbb/machine/mic_common.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_mic_common_H
diff --git a/inst/include/tbb/machine/msvc_armv7.h b/inst/include/tbb/machine/msvc_armv7.h
index 40d22020..e83c077e 100644
--- a/inst/include/tbb/machine/msvc_armv7.h
+++ b/inst/include/tbb/machine/msvc_armv7.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 !defined(__TBB_machine_H) || defined(__TBB_msvc_armv7_H)
diff --git a/inst/include/tbb/machine/msvc_ia32_common.h b/inst/include/tbb/machine/msvc_ia32_common.h
index 8b4814bc..2e17836d 100644
--- a/inst/include/tbb/machine/msvc_ia32_common.h
+++ b/inst/include/tbb/machine/msvc_ia32_common.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 !defined(__TBB_machine_H) || defined(__TBB_machine_msvc_ia32_common_H)
@@ -49,7 +45,7 @@
     }}}
 #endif
 
-#if _MSC_VER>=1600 && (!__INTEL_COMPILER || __INTEL_COMPILER>=1310)
+#if __TBB_MSVC_PART_WORD_INTERLOCKED_INTRINSICS_PRESENT
     // S is the operand size in bytes, B is the suffix for intrinsics for that size
     #define __TBB_MACHINE_DEFINE_ATOMICS(S,B,T,U)                                           \
     __pragma(intrinsic( _InterlockedCompareExchange##B ))                                   \
@@ -75,8 +71,7 @@
     #endif
 
     #undef __TBB_MACHINE_DEFINE_ATOMICS
-    #define __TBB_ATOMIC_PRIMITIVES_DEFINED
-#endif /*_MSC_VER>=1600*/
+#endif /* __TBB_MSVC_PART_WORD_INTERLOCKED_INTRINSICS_PRESENT */
 
 #if _MSC_VER>=1300 || __INTEL_COMPILER>=1100
     #pragma intrinsic(_ReadWriteBarrier)
diff --git a/inst/include/tbb/machine/sunos_sparc.h b/inst/include/tbb/machine/sunos_sparc.h
index 9119f402..b5864ba7 100644
--- a/inst/include/tbb/machine/sunos_sparc.h
+++ b/inst/include/tbb/machine/sunos_sparc.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 
diff --git a/inst/include/tbb/machine/windows_api.h b/inst/include/tbb/machine/windows_api.h
index d362abc5..54987915 100644
--- a/inst/include/tbb/machine/windows_api.h
+++ b/inst/include/tbb/machine/windows_api.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_machine_windows_api_H
diff --git a/inst/include/tbb/machine/windows_ia32.h b/inst/include/tbb/machine/windows_ia32.h
index 8db0d2b8..62968226 100644
--- a/inst/include/tbb/machine/windows_ia32.h
+++ b/inst/include/tbb/machine/windows_ia32.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 !defined(__TBB_machine_H) || defined(__TBB_machine_windows_ia32_H)
@@ -43,7 +39,7 @@ extern "C" {
     __int64 __TBB_EXPORTED_FUNC __TBB_machine_load8 (const volatile void *ptr);
 }
 
-#ifndef __TBB_ATOMIC_PRIMITIVES_DEFINED
+#if !__TBB_MSVC_PART_WORD_INTERLOCKED_INTRINSICS_PRESENT
 
 #define __TBB_MACHINE_DEFINE_ATOMICS(S,T,U,A,C) \
 static inline T __TBB_machine_cmpswp##S ( volatile void * ptr, U value, U comparand ) { \
@@ -93,7 +89,7 @@ __TBB_MACHINE_DEFINE_ATOMICS(4, ptrdiff_t, ptrdiff_t, eax, ecx)
 
 #undef __TBB_MACHINE_DEFINE_ATOMICS
 
-#endif /*__TBB_ATOMIC_PRIMITIVES_DEFINED*/
+#endif /* __TBB_MSVC_PART_WORD_INTERLOCKED_INTRINSICS_PRESENT */
 
 //TODO: Check if it possible and profitable for IA-32 architecture on (Linux and Windows)
 //to use of 64-bit load/store via floating point registers together with full fence
diff --git a/inst/include/tbb/machine/windows_intel64.h b/inst/include/tbb/machine/windows_intel64.h
index 86abd6ad..6e2a2cc7 100644
--- a/inst/include/tbb/machine/windows_intel64.h
+++ b/inst/include/tbb/machine/windows_intel64.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 !defined(__TBB_machine_H) || defined(__TBB_machine_windows_intel64_H)
@@ -29,7 +25,7 @@
 
 #include "msvc_ia32_common.h"
 
-#ifndef __TBB_ATOMIC_PRIMITIVES_DEFINED
+#if !__TBB_MSVC_PART_WORD_INTERLOCKED_INTRINSICS_PRESENT
 
 #include <intrin.h>
 #pragma intrinsic(_InterlockedCompareExchange,_InterlockedExchangeAdd,_InterlockedExchange)
@@ -66,7 +62,7 @@ inline __int64 __TBB_machine_fetchstore8 (volatile void *ptr, __int64 value ) {
     return _InterlockedExchange64( (__int64*)ptr, value );
 }
 
-#endif /*__TBB_ATOMIC_PRIMITIVES_DEFINED*/
+#endif /* __TBB_MSVC_PART_WORD_INTERLOCKED_INTRINSICS_PRESENT */
 
 #define __TBB_USE_FETCHSTORE_AS_FULL_FENCED_STORE           1
 #define __TBB_USE_GENERIC_HALF_FENCED_LOAD_STORE            1
diff --git a/inst/include/tbb/machine/xbox360_ppc.h b/inst/include/tbb/machine/xbox360_ppc.h
deleted file mode 100644
index 148e5b1d..00000000
--- a/inst/include/tbb/machine/xbox360_ppc.h
+++ /dev/null
@@ -1,119 +0,0 @@
-/*
-    Copyright 2005-2014 Intel Corporation.  All Rights Reserved.
-
-    This file is part of Threading Building Blocks. Threading Building Blocks is free software;
-    you can redistribute it and/or modify it under the terms of the GNU General Public License
-    version 2  as  published  by  the  Free Software Foundation.  Threading Building Blocks is
-    distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the
-    implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-    See  the GNU General Public License for more details.   You should have received a copy of
-    the  GNU General Public License along with Threading Building Blocks; if not, write to the
-    Free Software Foundation, Inc.,  51 Franklin St,  Fifth Floor,  Boston,  MA 02110-1301 USA
-
-    As a special exception,  you may use this file  as part of a free software library without
-    restriction.  Specifically,  if other files instantiate templates  or use macros or inline
-    functions from this file, or you compile this file and link it with other files to produce
-    an executable,  this file does not by itself cause the resulting executable to be covered
-    by the GNU General Public License. This exception does not however invalidate any other
-    reasons why the executable file might be covered by the GNU General Public License.
-*/
-
-// TODO: revise by comparing with mac_ppc.h
-
-#if !defined(__TBB_machine_H) || defined(__TBB_machine_xbox360_ppc_H)
-#error Do not #include this internal file directly; use public TBB headers instead.
-#endif
-
-#define __TBB_machine_xbox360_ppc_H
-
-#define NONET
-#define NOD3D
-#include "xtl.h"    
-#include "ppcintrinsics.h"
-
-#if _MSC_VER >= 1300
-extern "C" void _MemoryBarrier();
-#pragma intrinsic(_MemoryBarrier)
-#define __TBB_control_consistency_helper() __isync()
-#define __TBB_acquire_consistency_helper() _MemoryBarrier()
-#define __TBB_release_consistency_helper() _MemoryBarrier()
-#endif
-
-#define __TBB_full_memory_fence() __sync()
-
-#define __TBB_WORDSIZE 4
-#define __TBB_ENDIANNESS __TBB_ENDIAN_BIG
-
-//todo: define __TBB_USE_FENCED_ATOMICS and define acquire/release primitives to maximize performance
-
-inline __int32 __TBB_machine_cmpswp4(volatile void *ptr, __int32 value, __int32 comparand ) {                               
- __sync();
- __int32 result = InterlockedCompareExchange((volatile LONG*)ptr, value, comparand);
- __isync();
- return result;
-}
-
-inline __int64 __TBB_machine_cmpswp8(volatile void *ptr, __int64 value, __int64 comparand )
-{
- __sync();
- __int64 result = InterlockedCompareExchange64((volatile LONG64*)ptr, value, comparand);
- __isync();
- return result;
-}
-
-#define __TBB_USE_GENERIC_PART_WORD_CAS                     1
-#define __TBB_USE_GENERIC_FETCH_ADD                         1
-#define __TBB_USE_GENERIC_FETCH_STORE                       1
-#define __TBB_USE_GENERIC_HALF_FENCED_LOAD_STORE            1
-#define __TBB_USE_GENERIC_RELAXED_LOAD_STORE                1
-#define __TBB_USE_GENERIC_DWORD_LOAD_STORE                  1
-#define __TBB_USE_GENERIC_SEQUENTIAL_CONSISTENCY_LOAD_STORE 1
-
-#pragma optimize( "", off )
-inline void __TBB_machine_pause (__int32 delay ) 
-{
- for (__int32 i=0; i<delay; i++) {;};
-}
-#pragma optimize( "", on ) 
-
-#define __TBB_Yield()  Sleep(0)
-#define __TBB_Pause(V) __TBB_machine_pause(V)
-
-// This port uses only 2 hardware threads for TBB on XBOX 360. 
-// Others are left to sound etc.
-// Change the following mask to allow TBB use more HW threads.
-static const int __TBB_XBOX360_HARDWARE_THREAD_MASK = 0x0C;
-
-static inline int __TBB_XBOX360_DetectNumberOfWorkers() 
-{
-     char a[__TBB_XBOX360_HARDWARE_THREAD_MASK];  //compile time assert - at least one bit should be set always
-     a[0]=0;
-
-     return ((__TBB_XBOX360_HARDWARE_THREAD_MASK >> 0) & 1) +
-            ((__TBB_XBOX360_HARDWARE_THREAD_MASK >> 1) & 1) +
-            ((__TBB_XBOX360_HARDWARE_THREAD_MASK >> 2) & 1) +
-            ((__TBB_XBOX360_HARDWARE_THREAD_MASK >> 3) & 1) +
-            ((__TBB_XBOX360_HARDWARE_THREAD_MASK >> 4) & 1) +
-            ((__TBB_XBOX360_HARDWARE_THREAD_MASK >> 5) & 1) + 1;  // +1 accomodates for the master thread
-}
-
-static inline int __TBB_XBOX360_GetHardwareThreadIndex(int workerThreadIndex)
-{
-    workerThreadIndex %= __TBB_XBOX360_DetectNumberOfWorkers()-1;
-    int m = __TBB_XBOX360_HARDWARE_THREAD_MASK;
-    int index = 0;
-    int skipcount = workerThreadIndex;
-    while (true)
-    {
-        if ((m & 1)!=0) 
-        {
-            if (skipcount==0) break;
-            skipcount--;
-        }
-        m >>= 1;
-       index++;
-    }
-    return index; 
-}
-
-#define __TBB_HardwareConcurrency() __TBB_XBOX360_DetectNumberOfWorkers()
diff --git a/inst/include/tbb/memory_pool.h b/inst/include/tbb/memory_pool.h
index b3bba397..99a31d6a 100644
--- a/inst/include/tbb/memory_pool.h
+++ b/inst/include/tbb/memory_pool.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_memory_pool_H
diff --git a/inst/include/tbb/mutex.h b/inst/include/tbb/mutex.h
index e40b4cd0..94269f3d 100644
--- a/inst/include/tbb/mutex.h
+++ b/inst/include/tbb/mutex.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,15 +12,25 @@
     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 "internal/_deprecated_header_message_guard.h"
 
+#if !defined(__TBB_show_deprecation_message_mutex_H) && defined(__TBB_show_deprecated_header_message)
+#define  __TBB_show_deprecation_message_mutex_H
+#pragma message("TBB Warning: tbb/mutex.h is deprecated. For details, please see Deprecated Features appendix in the TBB reference manual.")
+#endif
 
-
-*/
+#if defined(__TBB_show_deprecated_header_message)
+#undef __TBB_show_deprecated_header_message
+#endif
 
 #ifndef __TBB_mutex_H
 #define __TBB_mutex_H
 
+#define __TBB_mutex_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #if _WIN32||_WIN64
 #include "machine/windows_api.h"
 #else
@@ -36,7 +46,7 @@ namespace tbb {
 
 //! Wrapper around the platform's native lock.
 /** @ingroup synchronization */
-class mutex : internal::mutex_copy_deprecated_and_disabled {
+class __TBB_DEPRECATED_IN_VERBOSE_MODE_MSG("tbb::critical_section is deprecated, use std::mutex") mutex : internal::mutex_copy_deprecated_and_disabled {
 public:
     //! Construct unacquired mutex.
     mutex() {
@@ -230,4 +240,7 @@ __TBB_DEFINE_PROFILING_SET_NAME(mutex)
 
 } // namespace tbb
 
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_mutex_H_include_area
+
 #endif /* __TBB_mutex_H */
diff --git a/inst/include/tbb/null_mutex.h b/inst/include/tbb/null_mutex.h
index 85c660e3..3c7bad1a 100644
--- a/inst/include/tbb/null_mutex.h
+++ b/inst/include/tbb/null_mutex.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_null_mutex_H
diff --git a/inst/include/tbb/null_rw_mutex.h b/inst/include/tbb/null_rw_mutex.h
index fa0c8035..f1ea4df6 100644
--- a/inst/include/tbb/null_rw_mutex.h
+++ b/inst/include/tbb/null_rw_mutex.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_null_rw_mutex_H
diff --git a/inst/include/tbb/parallel_do.h b/inst/include/tbb/parallel_do.h
index 15275682..1b63e279 100644
--- a/inst/include/tbb/parallel_do.h
+++ b/inst/include/tbb/parallel_do.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,15 +12,14 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_parallel_do_H
 #define __TBB_parallel_do_H
 
+#define __TBB_parallel_do_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #include "internal/_range_iterator.h"
 #include "internal/_template_helpers.h"
 #include "task.h"
@@ -500,7 +499,7 @@ void parallel_do( Iterator first, Iterator last, const Body& body )
     if ( first == last )
         return;
 #if __TBB_TASK_GROUP_CONTEXT
-    task_group_context context;
+    task_group_context context(internal::PARALLEL_DO);
 #endif
     interface9::internal::select_parallel_do( first, last, body, &Body::operator()
 #if __TBB_TASK_GROUP_CONTEXT
@@ -548,4 +547,7 @@ using interface9::parallel_do_feeder;
 
 } // namespace
 
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_parallel_do_H_include_area
+
 #endif /* __TBB_parallel_do_H */
diff --git a/inst/include/tbb/parallel_for.h b/inst/include/tbb/parallel_for.h
index 2cab6586..0b4861f4 100644
--- a/inst/include/tbb/parallel_for.h
+++ b/inst/include/tbb/parallel_for.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,20 +12,20 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_parallel_for_H
 #define __TBB_parallel_for_H
 
+#define __TBB_parallel_for_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #include <new>
 #include "task.h"
 #include "partitioner.h"
 #include "blocked_range.h"
 #include "tbb_exception.h"
+#include "internal/_tbb_trace_impl.h"
 
 namespace tbb {
 
@@ -57,6 +57,7 @@ namespace internal {
             my_body(body),
             my_partition(partitioner)
         {
+            tbb::internal::fgt_algorithm(tbb::internal::PARALLEL_FOR_TASK, this, NULL);
         }
         //! Splitting constructor used to generate children.
         /** parent_ becomes left child.  Newly constructed object is right child. */
@@ -66,6 +67,7 @@ namespace internal {
             my_partition(parent_.my_partition, split_obj)
         {
             my_partition.set_affinity(*this);
+            tbb::internal::fgt_algorithm(tbb::internal::PARALLEL_FOR_TASK, this, (void *)&parent_);
         }
         //! Construct right child from the given range as response to the demand.
         /** parent_ remains left child.  Newly constructed object is right child. */
@@ -76,6 +78,7 @@ namespace internal {
         {
             my_partition.set_affinity(*this);
             my_partition.align_depth( d );
+            tbb::internal::fgt_algorithm(tbb::internal::PARALLEL_FOR_TASK, this, (void *)&parent_);
         }
         static void run(  const Range& range, const Body& body, Partitioner& partitioner ) {
             if( !range.empty() ) {
@@ -84,22 +87,34 @@ namespace internal {
 #else
                 // Bound context prevents exceptions from body to affect nesting or sibling algorithms,
                 // and allows users to handle exceptions safely by wrapping parallel_for in the try-block.
-                task_group_context context;
+                task_group_context context(PARALLEL_FOR);
                 start_for& a = *new(task::allocate_root(context)) start_for(range,body,partitioner);
 #endif /* __TBB_TASK_GROUP_CONTEXT && !TBB_JOIN_OUTER_TASK_GROUP */
+		// REGION BEGIN
+                fgt_begin_algorithm( tbb::internal::PARALLEL_FOR_TASK, (void*)&context );
                 task::spawn_root_and_wait(a);
+                fgt_end_algorithm( (void*)&context );
+		// REGION END
             }
         }
 #if __TBB_TASK_GROUP_CONTEXT
         static void run(  const Range& range, const Body& body, Partitioner& partitioner, task_group_context& context ) {
             if( !range.empty() ) {
                 start_for& a = *new(task::allocate_root(context)) start_for(range,body,partitioner);
+		// REGION BEGIN
+                fgt_begin_algorithm( tbb::internal::PARALLEL_FOR_TASK, (void*)&context );
                 task::spawn_root_and_wait(a);
+                fgt_end_algorithm( (void*)&context );
+		// END REGION
             }
         }
 #endif /* __TBB_TASK_GROUP_CONTEXT */
         //! Run body for range, serves as callback for partitioner
-        void run_body( Range &r ) { my_body( r ); }
+        void run_body( Range &r ) {
+            fgt_alg_begin_body( tbb::internal::PARALLEL_FOR_TASK, (void *)const_cast<Body*>(&(this->my_body)), (void*)this );
+            my_body( r );
+            fgt_alg_end_body( (void *)const_cast<Body*>(&(this->my_body)) );
+        }
 
         //! spawn right task, serves as callback for partitioner
         void offer_work(typename Partitioner::split_type& split_obj) {
@@ -404,4 +419,7 @@ using strict_ppl::parallel_for;
 #undef __TBB_NORMAL_EXECUTION
 #endif
 
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_parallel_for_H_include_area
+
 #endif /* __TBB_parallel_for_H */
diff --git a/inst/include/tbb/parallel_for_each.h b/inst/include/tbb/parallel_for_each.h
index 6c2ec9f0..e1da1bbd 100644
--- a/inst/include/tbb/parallel_for_each.h
+++ b/inst/include/tbb/parallel_for_each.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_parallel_for_each_H
diff --git a/inst/include/tbb/parallel_invoke.h b/inst/include/tbb/parallel_invoke.h
index 0dd7590e..4be4bdb7 100644
--- a/inst/include/tbb/parallel_invoke.h
+++ b/inst/include/tbb/parallel_invoke.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,16 +12,16 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_parallel_invoke_H
 #define __TBB_parallel_invoke_H
 
+#define __TBB_parallel_invoke_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #include "task.h"
+#include "tbb_profiling.h"
 
 #if __TBB_VARIADIC_PARALLEL_INVOKE
     #include <utility> // std::forward
@@ -31,7 +31,9 @@ namespace tbb {
 
 #if !__TBB_TASK_GROUP_CONTEXT
     /** Dummy to avoid cluttering the bulk of the header with enormous amount of ifdefs. **/
-    struct task_group_context {};
+    struct task_group_context {
+        task_group_context(tbb::internal::string_index){}
+    };
 #endif /* __TBB_TASK_GROUP_CONTEXT */
 
 //! @cond INTERNAL
@@ -223,7 +225,7 @@ namespace internal {
     // task_group_context is not in the pack, needs to be added
     template<typename F0, typename F1, typename... F>
     void parallel_invoke_impl(false_type, F0&& f0, F1&& f1, F&&... f) {
-        tbb::task_group_context context;
+        tbb::task_group_context context(PARALLEL_INVOKE);
         // Add context to the arguments, and redirect to the other overload
         parallel_invoke_impl(true_type(), std::forward<F0>(f0), std::forward<F1>(f1), std::forward<F>(f)..., context);
     }
@@ -385,31 +387,31 @@ void parallel_invoke(const F0& f0, const F1& f1, const F2& f2, const F3& f3, con
 // two arguments
 template<typename F0, typename F1>
 void parallel_invoke(const F0& f0, const F1& f1) {
-    task_group_context context;
+    task_group_context context(internal::PARALLEL_INVOKE);
     parallel_invoke<F0, F1>(f0, f1, context);
 }
 // three arguments
 template<typename F0, typename F1, typename F2>
 void parallel_invoke(const F0& f0, const F1& f1, const F2& f2) {
-    task_group_context context;
+    task_group_context context(internal::PARALLEL_INVOKE);
     parallel_invoke<F0, F1, F2>(f0, f1, f2, context);
 }
 // four arguments
 template<typename F0, typename F1, typename F2, typename F3 >
 void parallel_invoke(const F0& f0, const F1& f1, const F2& f2, const F3& f3) {
-    task_group_context context;
+    task_group_context context(internal::PARALLEL_INVOKE);
     parallel_invoke<F0, F1, F2, F3>(f0, f1, f2, f3, context);
 }
 // five arguments
 template<typename F0, typename F1, typename F2, typename F3, typename F4>
 void parallel_invoke(const F0& f0, const F1& f1, const F2& f2, const F3& f3, const F4& f4) {
-    task_group_context context;
+    task_group_context context(internal::PARALLEL_INVOKE);
     parallel_invoke<F0, F1, F2, F3, F4>(f0, f1, f2, f3, f4, context);
 }
 // six arguments
 template<typename F0, typename F1, typename F2, typename F3, typename F4, typename F5>
 void parallel_invoke(const F0& f0, const F1& f1, const F2& f2, const F3& f3, const F4& f4, const F5& f5) {
-    task_group_context context;
+    task_group_context context(internal::PARALLEL_INVOKE);
     parallel_invoke<F0, F1, F2, F3, F4, F5>(f0, f1, f2, f3, f4, f5, context);
 }
 // seven arguments
@@ -417,7 +419,7 @@ template<typename F0, typename F1, typename F2, typename F3, typename F4, typena
 void parallel_invoke(const F0& f0, const F1& f1, const F2& f2, const F3& f3, const F4& f4,
                      const F5& f5, const F6& f6)
 {
-    task_group_context context;
+    task_group_context context(internal::PARALLEL_INVOKE);
     parallel_invoke<F0, F1, F2, F3, F4, F5, F6>(f0, f1, f2, f3, f4, f5, f6, context);
 }
 // eight arguments
@@ -426,7 +428,7 @@ template<typename F0, typename F1, typename F2, typename F3, typename F4,
 void parallel_invoke(const F0& f0, const F1& f1, const F2& f2, const F3& f3, const F4& f4,
                      const F5& f5, const F6& f6, const F7& f7)
 {
-    task_group_context context;
+    task_group_context context(internal::PARALLEL_INVOKE);
     parallel_invoke<F0, F1, F2, F3, F4, F5, F6, F7>(f0, f1, f2, f3, f4, f5, f6, f7, context);
 }
 // nine arguments
@@ -435,7 +437,7 @@ template<typename F0, typename F1, typename F2, typename F3, typename F4,
 void parallel_invoke(const F0& f0, const F1& f1, const F2& f2, const F3& f3, const F4& f4,
                      const F5& f5, const F6& f6, const F7& f7, const F8& f8)
 {
-    task_group_context context;
+    task_group_context context(internal::PARALLEL_INVOKE);
     parallel_invoke<F0, F1, F2, F3, F4, F5, F6, F7, F8>(f0, f1, f2, f3, f4, f5, f6, f7, f8, context);
 }
 // ten arguments
@@ -444,7 +446,7 @@ template<typename F0, typename F1, typename F2, typename F3, typename F4,
 void parallel_invoke(const F0& f0, const F1& f1, const F2& f2, const F3& f3, const F4& f4,
                      const F5& f5, const F6& f6, const F7& f7, const F8& f8, const F9& f9)
 {
-    task_group_context context;
+    task_group_context context(internal::PARALLEL_INVOKE);
     parallel_invoke<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9>(f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, context);
 }
 #endif // __TBB_VARIADIC_PARALLEL_INVOKE
@@ -452,4 +454,7 @@ void parallel_invoke(const F0& f0, const F1& f1, const F2& f2, const F3& f3, con
 
 } // namespace
 
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_parallel_invoke_H_include_area
+
 #endif /* __TBB_parallel_invoke_H */
diff --git a/inst/include/tbb/parallel_reduce.h b/inst/include/tbb/parallel_reduce.h
index 0596ae03..da2e2f8d 100644
--- a/inst/include/tbb/parallel_reduce.h
+++ b/inst/include/tbb/parallel_reduce.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,15 +12,14 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_parallel_reduce_H
 #define __TBB_parallel_reduce_H
 
+#define __TBB_parallel_reduce_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #include <new>
 #include "task.h"
 #include "aligned_space.h"
@@ -136,7 +135,7 @@ namespace internal {
 #else
                 // Bound context prevents exceptions from body to affect nesting or sibling algorithms,
                 // and allows users to handle exceptions safely by wrapping parallel_for in the try-block.
-                task_group_context context;
+                task_group_context context(PARALLEL_REDUCE);
                 task::spawn_root_and_wait( *new(task::allocate_root(context)) start_reduce(range,&body,partitioner) );
 #endif /* __TBB_TASK_GROUP_CONTEXT && !TBB_JOIN_OUTER_TASK_GROUP */
             }
@@ -213,67 +212,71 @@ namespace internal {
             my_left_body.join( my_right_body );
             return NULL;
         }
-        template<typename Range,typename Body_>
+        template<typename Range,typename Body_, typename Partitioner>
         friend class start_deterministic_reduce;
     };
 
     //! Task type used to split the work of parallel_deterministic_reduce.
     /** @ingroup algorithms */
-    template<typename Range, typename Body>
+    template<typename Range, typename Body, typename Partitioner>
     class start_deterministic_reduce: public task {
         typedef finish_deterministic_reduce<Body> finish_type;
         Body &my_body;
         Range my_range;
+        typename Partitioner::task_partition_type my_partition;
         task* execute() __TBB_override;
 
         //! Constructor used for root task
-        start_deterministic_reduce( const Range& range, Body& body ) :
+        start_deterministic_reduce( const Range& range, Body& body, Partitioner& partitioner ) :
             my_body( body ),
-            my_range( range )
+            my_range( range ),
+            my_partition( partitioner )
         {
         }
         //! Splitting constructor used to generate children.
         /** parent_ becomes left child.  Newly constructed object is right child. */
-        start_deterministic_reduce( start_deterministic_reduce& parent_, finish_type& c ) :
+        start_deterministic_reduce( start_deterministic_reduce& parent_, finish_type& c, typename Partitioner::split_type& split_obj ) :
             my_body( c.my_right_body ),
-            my_range( parent_.my_range, split() )
+            my_range( parent_.my_range, split_obj ),
+            my_partition( parent_.my_partition, split_obj )
         {
         }
 
 public:
-        static void run( const Range& range, Body& body ) {
+        static void run( const Range& range, Body& body, Partitioner& partitioner ) {
             if( !range.empty() ) {
 #if !__TBB_TASK_GROUP_CONTEXT || TBB_JOIN_OUTER_TASK_GROUP
-                task::spawn_root_and_wait( *new(task::allocate_root()) start_deterministic_reduce(range,&body) );
+                task::spawn_root_and_wait( *new(task::allocate_root()) start_deterministic_reduce(range,&body,partitioner) );
 #else
                 // Bound context prevents exceptions from body to affect nesting or sibling algorithms,
                 // and allows users to handle exceptions safely by wrapping parallel_for in the try-block.
-                task_group_context context;
-                task::spawn_root_and_wait( *new(task::allocate_root(context)) start_deterministic_reduce(range,body) );
+                task_group_context context(PARALLEL_REDUCE);
+                task::spawn_root_and_wait( *new(task::allocate_root(context)) start_deterministic_reduce(range,body,partitioner) );
 #endif /* __TBB_TASK_GROUP_CONTEXT && !TBB_JOIN_OUTER_TASK_GROUP */
             }
         }
 #if __TBB_TASK_GROUP_CONTEXT
-        static void run( const Range& range, Body& body, task_group_context& context ) {
+        static void run( const Range& range, Body& body, Partitioner& partitioner, task_group_context& context ) {
             if( !range.empty() )
-                task::spawn_root_and_wait( *new(task::allocate_root(context)) start_deterministic_reduce(range,body) );
+                task::spawn_root_and_wait( *new(task::allocate_root(context)) start_deterministic_reduce(range,body,partitioner) );
         }
 #endif /* __TBB_TASK_GROUP_CONTEXT */
-    };
 
-    template<typename Range, typename Body>
-    task* start_deterministic_reduce<Range,Body>::execute() {
-        if( !my_range.is_divisible() ) {
-            my_body( my_range );
-            return NULL;
-        } else {
-            finish_type& c = *new( allocate_continuation() ) finish_type( my_body );
-            recycle_as_child_of(c);
-            c.set_ref_count(2);
-            start_deterministic_reduce& b = *new( c.allocate_child() ) start_deterministic_reduce( *this, c );
-            task::spawn(b);
-            return this;
+        void offer_work( typename Partitioner::split_type& split_obj) {
+            task* tasks[2];
+            allocate_sibling(static_cast<task*>(this), tasks, sizeof(start_deterministic_reduce), sizeof(finish_type));
+            new((void*)tasks[0]) finish_type(my_body);
+            new((void*)tasks[1]) start_deterministic_reduce(*this, *static_cast<finish_type*>(tasks[0]), split_obj);
+            spawn(*tasks[1]);
         }
+
+        void run_body( Range &r ) { my_body(r); }
+    };
+
+    template<typename Range, typename Body, typename Partitioner>
+    task* start_deterministic_reduce<Range,Body, Partitioner>::execute() {
+        my_partition.execute(*this, my_range);
+        return NULL;
     }
 } // namespace internal
 //! @endcond
@@ -389,6 +392,13 @@ void parallel_reduce( const Range& range, Body& body, affinity_partitioner& part
 }
 
 #if __TBB_TASK_GROUP_CONTEXT
+//! Parallel iteration with reduction, default partitioner and user-supplied context.
+/** @ingroup algorithms **/
+template<typename Range, typename Body>
+void parallel_reduce( const Range& range, Body& body, task_group_context& context ) {
+    internal::start_reduce<Range,Body,const __TBB_DEFAULT_PARTITIONER>::run( range, body, __TBB_DEFAULT_PARTITIONER(), context );
+}
+
 //! Parallel iteration with reduction, simple partitioner and user-supplied context.
 /** @ingroup algorithms **/
 template<typename Range, typename Body>
@@ -476,6 +486,17 @@ Value parallel_reduce( const Range& range, const Value& identity, const RealBody
 }
 
 #if __TBB_TASK_GROUP_CONTEXT
+//! Parallel iteration with reduction, default partitioner and user-supplied context.
+/** @ingroup algorithms **/
+template<typename Range, typename Value, typename RealBody, typename Reduction>
+Value parallel_reduce( const Range& range, const Value& identity, const RealBody& real_body, const Reduction& reduction,
+                       task_group_context& context ) {
+    internal::lambda_reduce_body<Range,Value,RealBody,Reduction> body(identity, real_body, reduction);
+    internal::start_reduce<Range,internal::lambda_reduce_body<Range,Value,RealBody,Reduction>,const __TBB_DEFAULT_PARTITIONER>
+                          ::run( range, body, __TBB_DEFAULT_PARTITIONER(), context );
+    return body.result();
+}
+
 //! Parallel iteration with reduction, simple partitioner and user-supplied context.
 /** @ingroup algorithms **/
 template<typename Range, typename Value, typename RealBody, typename Reduction>
@@ -521,44 +542,108 @@ Value parallel_reduce( const Range& range, const Value& identity, const RealBody
 }
 #endif /* __TBB_TASK_GROUP_CONTEXT */
 
-//! Parallel iteration with deterministic reduction and default partitioner.
+//! Parallel iteration with deterministic reduction and default simple partitioner.
 /** @ingroup algorithms **/
 template<typename Range, typename Body>
 void parallel_deterministic_reduce( const Range& range, Body& body ) {
-    internal::start_deterministic_reduce<Range,Body>::run( range, body );
+    internal::start_deterministic_reduce<Range, Body, const simple_partitioner>::run(range, body, simple_partitioner());
+}
+
+//! Parallel iteration with deterministic reduction and simple partitioner.
+/** @ingroup algorithms **/
+template<typename Range, typename Body>
+void parallel_deterministic_reduce( const Range& range, Body& body, const simple_partitioner& partitioner ) {
+    internal::start_deterministic_reduce<Range, Body, const simple_partitioner>::run(range, body, partitioner);
+}
+
+//! Parallel iteration with deterministic reduction and static partitioner.
+/** @ingroup algorithms **/
+template<typename Range, typename Body>
+void parallel_deterministic_reduce( const Range& range, Body& body, const static_partitioner& partitioner ) {
+    internal::start_deterministic_reduce<Range, Body, const static_partitioner>::run(range, body, partitioner);
 }
 
 #if __TBB_TASK_GROUP_CONTEXT
-//! Parallel iteration with deterministic reduction, simple partitioner and user-supplied context.
+//! Parallel iteration with deterministic reduction, default simple partitioner and user-supplied context.
 /** @ingroup algorithms **/
 template<typename Range, typename Body>
 void parallel_deterministic_reduce( const Range& range, Body& body, task_group_context& context ) {
-    internal::start_deterministic_reduce<Range,Body>::run( range, body, context );
+    internal::start_deterministic_reduce<Range,Body, const simple_partitioner>::run( range, body, simple_partitioner(), context );
+}
+
+//! Parallel iteration with deterministic reduction, simple partitioner and user-supplied context.
+/** @ingroup algorithms **/
+template<typename Range, typename Body>
+void parallel_deterministic_reduce( const Range& range, Body& body, const simple_partitioner& partitioner, task_group_context& context ) {
+    internal::start_deterministic_reduce<Range, Body, const simple_partitioner>::run(range, body, partitioner, context);
+}
+
+//! Parallel iteration with deterministic reduction, static partitioner and user-supplied context.
+/** @ingroup algorithms **/
+template<typename Range, typename Body>
+void parallel_deterministic_reduce( const Range& range, Body& body, const static_partitioner& partitioner, task_group_context& context ) {
+    internal::start_deterministic_reduce<Range, Body, const static_partitioner>::run(range, body, partitioner, context);
 }
 #endif /* __TBB_TASK_GROUP_CONTEXT */
 
 /** parallel_reduce overloads that work with anonymous function objects
     (see also \ref parallel_reduce_lambda_req "requirements on parallel_reduce anonymous function objects"). **/
 
-//! Parallel iteration with deterministic reduction and default partitioner.
+//! Parallel iteration with deterministic reduction and default simple partitioner.
+// TODO: consider making static_partitioner the default
 /** @ingroup algorithms **/
 template<typename Range, typename Value, typename RealBody, typename Reduction>
 Value parallel_deterministic_reduce( const Range& range, const Value& identity, const RealBody& real_body, const Reduction& reduction ) {
+    return parallel_deterministic_reduce(range, identity, real_body, reduction, simple_partitioner());
+}
+
+//! Parallel iteration with deterministic reduction and simple partitioner.
+/** @ingroup algorithms **/
+template<typename Range, typename Value, typename RealBody, typename Reduction>
+Value parallel_deterministic_reduce( const Range& range, const Value& identity, const RealBody& real_body, const Reduction& reduction, const simple_partitioner& partitioner ) {
     internal::lambda_reduce_body<Range,Value,RealBody,Reduction> body(identity, real_body, reduction);
-    internal::start_deterministic_reduce<Range,internal::lambda_reduce_body<Range,Value,RealBody,Reduction> >
-                          ::run(range, body);
+    internal::start_deterministic_reduce<Range,internal::lambda_reduce_body<Range,Value,RealBody,Reduction>, const simple_partitioner>
+                          ::run(range, body, partitioner);
     return body.result();
 }
 
+//! Parallel iteration with deterministic reduction and static partitioner.
+/** @ingroup algorithms **/
+template<typename Range, typename Value, typename RealBody, typename Reduction>
+Value parallel_deterministic_reduce( const Range& range, const Value& identity, const RealBody& real_body, const Reduction& reduction, const static_partitioner& partitioner ) {
+    internal::lambda_reduce_body<Range, Value, RealBody, Reduction> body(identity, real_body, reduction);
+    internal::start_deterministic_reduce<Range, internal::lambda_reduce_body<Range, Value, RealBody, Reduction>, const static_partitioner>
+        ::run(range, body, partitioner);
+    return body.result();
+}
 #if __TBB_TASK_GROUP_CONTEXT
+//! Parallel iteration with deterministic reduction, default simple partitioner and user-supplied context.
+/** @ingroup algorithms **/
+template<typename Range, typename Value, typename RealBody, typename Reduction>
+Value parallel_deterministic_reduce( const Range& range, const Value& identity, const RealBody& real_body, const Reduction& reduction,
+    task_group_context& context ) {
+    return parallel_deterministic_reduce(range, identity, real_body, reduction, simple_partitioner(), context);
+}
+
 //! Parallel iteration with deterministic reduction, simple partitioner and user-supplied context.
 /** @ingroup algorithms **/
 template<typename Range, typename Value, typename RealBody, typename Reduction>
 Value parallel_deterministic_reduce( const Range& range, const Value& identity, const RealBody& real_body, const Reduction& reduction,
-                       task_group_context& context ) {
-    internal::lambda_reduce_body<Range,Value,RealBody,Reduction> body(identity, real_body, reduction);
-    internal::start_deterministic_reduce<Range,internal::lambda_reduce_body<Range,Value,RealBody,Reduction> >
-                          ::run( range, body, context );
+    const simple_partitioner& partitioner, task_group_context& context ) {
+    internal::lambda_reduce_body<Range, Value, RealBody, Reduction> body(identity, real_body, reduction);
+    internal::start_deterministic_reduce<Range, internal::lambda_reduce_body<Range, Value, RealBody, Reduction>, const simple_partitioner>
+        ::run(range, body, partitioner, context);
+    return body.result();
+}
+
+//! Parallel iteration with deterministic reduction, static partitioner and user-supplied context.
+/** @ingroup algorithms **/
+template<typename Range, typename Value, typename RealBody, typename Reduction>
+Value parallel_deterministic_reduce( const Range& range, const Value& identity, const RealBody& real_body, const Reduction& reduction,
+    const static_partitioner& partitioner, task_group_context& context ) {
+    internal::lambda_reduce_body<Range, Value, RealBody, Reduction> body(identity, real_body, reduction);
+    internal::start_deterministic_reduce<Range, internal::lambda_reduce_body<Range, Value, RealBody, Reduction>, const static_partitioner>
+        ::run(range, body, partitioner, context);
     return body.result();
 }
 #endif /* __TBB_TASK_GROUP_CONTEXT */
@@ -566,4 +651,7 @@ Value parallel_deterministic_reduce( const Range& range, const Value& identity,
 
 } // namespace tbb
 
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_parallel_reduce_H_include_area
+
 #endif /* __TBB_parallel_reduce_H */
diff --git a/inst/include/tbb/parallel_scan.h b/inst/include/tbb/parallel_scan.h
index faf6b316..7930b5c4 100644
--- a/inst/include/tbb/parallel_scan.h
+++ b/inst/include/tbb/parallel_scan.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,15 +12,14 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_parallel_scan_H
 #define __TBB_parallel_scan_H
 
+#define __TBB_parallel_scan_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #include "task.h"
 #include "aligned_space.h"
 #include <new>
@@ -32,12 +31,14 @@ namespace tbb {
 /** @ingroup algorithms */
 struct pre_scan_tag {
     static bool is_final_scan() {return false;}
+    operator bool() {return is_final_scan();}
 };
 
 //! Used to indicate that the final scan is being performed.
 /** @ingroup algorithms */
 struct final_scan_tag {
     static bool is_final_scan() {return true;}
+    operator bool() {return is_final_scan();}
 };
 
 //! @cond INTERNAL
@@ -227,7 +228,6 @@ namespace internal {
             if( !range_.empty() ) {
                 typedef internal::start_scan<Range,Body,Partitioner> start_pass1_type;
                 internal::sum_node<Range,Body>* root = NULL;
-                typedef internal::final_sum<Range,Body> final_sum_type;
                 final_sum_type* temp_body = new(task::allocate_root()) final_sum_type( body_ );
                 start_pass1_type& pass1 = *new(task::allocate_root()) start_pass1_type(
                     /*my_return_slot=*/root,
@@ -297,6 +297,43 @@ namespace internal {
         }
         return next_task;
     }
+
+    template<typename Range, typename Value, typename Scan, typename ReverseJoin>
+    class lambda_scan_body : no_assign {
+        Value               my_sum;
+        const Value&        identity_element;
+        const Scan&         my_scan;
+        const ReverseJoin&  my_reverse_join;
+    public:
+        lambda_scan_body( const Value& identity, const Scan& scan, const ReverseJoin& rev_join)
+            : my_sum(identity)
+            , identity_element(identity)
+            , my_scan(scan)
+            , my_reverse_join(rev_join) {}
+
+        lambda_scan_body( lambda_scan_body& b, split )
+            : my_sum(b.identity_element)
+            , identity_element(b.identity_element)
+            , my_scan(b.my_scan)
+            , my_reverse_join(b.my_reverse_join) {}
+
+        template<typename Tag>
+        void operator()( const Range& r, Tag tag ) {
+            my_sum = my_scan(r, my_sum, tag);
+        }
+
+        void reverse_join( lambda_scan_body& a ) {
+            my_sum = my_reverse_join(a.my_sum, my_sum);
+        }
+
+        void assign( lambda_scan_body& b ) {
+            my_sum = b.my_sum;
+        }
+
+        Value result() const {
+            return my_sum;
+        }
+    };
 } // namespace internal
 //! @endcond
 
@@ -340,9 +377,40 @@ template<typename Range, typename Body>
 void parallel_scan( const Range& range, Body& body, const auto_partitioner& partitioner ) {
     internal::start_scan<Range,Body,auto_partitioner>::run(range,body,partitioner);
 }
+
+//! Parallel prefix with default partitioner
+/** @ingroup algorithms **/
+template<typename Range, typename Value, typename Scan, typename ReverseJoin>
+Value parallel_scan( const Range& range, const Value& identity, const Scan& scan, const ReverseJoin& reverse_join ) {
+    internal::lambda_scan_body<Range, Value, Scan, ReverseJoin> body(identity, scan, reverse_join);
+    tbb::parallel_scan(range,body,__TBB_DEFAULT_PARTITIONER());
+    return body.result();
+}
+
+//! Parallel prefix with simple_partitioner
+/** @ingroup algorithms **/
+template<typename Range, typename Value, typename Scan, typename ReverseJoin>
+Value parallel_scan( const Range& range, const Value& identity, const Scan& scan, const ReverseJoin& reverse_join, const simple_partitioner& partitioner ) {
+    internal::lambda_scan_body<Range, Value, Scan, ReverseJoin> body(identity, scan, reverse_join);
+    tbb::parallel_scan(range,body,partitioner);
+    return body.result();
+}
+
+//! Parallel prefix with auto_partitioner
+/** @ingroup algorithms **/
+template<typename Range, typename Value, typename Scan, typename ReverseJoin>
+Value parallel_scan( const Range& range, const Value& identity, const Scan& scan, const ReverseJoin& reverse_join, const auto_partitioner& partitioner ) {
+    internal::lambda_scan_body<Range, Value, Scan, ReverseJoin> body(identity, scan, reverse_join);
+    tbb::parallel_scan(range,body,partitioner);
+    return body.result();
+}
+
 //@}
 
 } // namespace tbb
 
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_parallel_scan_H_include_area
+
 #endif /* __TBB_parallel_scan_H */
 
diff --git a/inst/include/tbb/parallel_sort.h b/inst/include/tbb/parallel_sort.h
index 07d3907b..b865b2ee 100644
--- a/inst/include/tbb/parallel_sort.h
+++ b/inst/include/tbb/parallel_sort.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,21 +12,23 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_parallel_sort_H
 #define __TBB_parallel_sort_H
 
+#define __TBB_parallel_sort_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #include "parallel_for.h"
 #include "blocked_range.h"
 #include "internal/_range_iterator.h"
 #include <algorithm>
 #include <iterator>
 #include <functional>
+#if __TBB_TASK_GROUP_CONTEXT
+    #include "tbb_profiling.h"
+#endif
 
 namespace tbb {
 
@@ -159,7 +161,7 @@ struct quick_sort_body {
 template<typename RandomAccessIterator, typename Compare>
 void parallel_quick_sort( RandomAccessIterator begin, RandomAccessIterator end, const Compare& comp ) {
 #if __TBB_TASK_GROUP_CONTEXT
-    task_group_context my_context;
+    task_group_context my_context(PARALLEL_SORT);
     const int serial_cutoff = 9;
 
     __TBB_ASSERT( begin + serial_cutoff < end, "min_parallel_size is smaller than serial cutoff?" );
@@ -230,13 +232,6 @@ void parallel_sort(Range& rng, const Compare& comp) {
     parallel_sort(tbb::internal::first(rng), tbb::internal::last(rng), comp);
 }
 
-//! Sorts the data in const rng using the given comparator
-/** @ingroup algorithms **/
-template<typename Range, typename Compare>
-void parallel_sort(const Range& rng, const Compare& comp) {
-    parallel_sort(tbb::internal::first(rng), tbb::internal::last(rng), comp);
-}
-
 //! Sorts the data in rng with a default comparator \c std::less<RandomAccessIterator>
 /** @ingroup algorithms **/
 template<typename Range>
@@ -244,13 +239,6 @@ void parallel_sort(Range& rng) {
     parallel_sort(tbb::internal::first(rng), tbb::internal::last(rng));
 }
 
-//! Sorts the data in const rng with a default comparator \c std::less<RandomAccessIterator>
-/** @ingroup algorithms **/
-template<typename Range>
-void parallel_sort(const Range& rng) {
-    parallel_sort(tbb::internal::first(rng), tbb::internal::last(rng));
-}
-
 //! Sorts the data in the range \c [begin,end) with a default comparator \c std::less<T>
 /** @ingroup algorithms **/
 template<typename T>
@@ -262,5 +250,8 @@ inline void parallel_sort( T * begin, T * end ) {
 
 } // namespace tbb
 
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_parallel_sort_H_include_area
+
 #endif
 
diff --git a/inst/include/tbb/parallel_while.h b/inst/include/tbb/parallel_while.h
index 2f37a41a..65984af5 100644
--- a/inst/include/tbb/parallel_while.h
+++ b/inst/include/tbb/parallel_while.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,15 +12,14 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_parallel_while
 #define __TBB_parallel_while
 
+#define __TBB_parallel_while_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #include "task.h"
 #include <new>
 
@@ -183,4 +182,7 @@ void parallel_while<Body>::add( const value_type& item ) {
 
 } // namespace
 
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_parallel_while_H_include_area
+
 #endif /* __TBB_parallel_while */
diff --git a/inst/include/tbb/partitioner.h b/inst/include/tbb/partitioner.h
index 96a0b757..c130d349 100644
--- a/inst/include/tbb/partitioner.h
+++ b/inst/include/tbb/partitioner.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,15 +12,14 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_partitioner_H
 #define __TBB_partitioner_H
 
+#define __TBB_partitioner_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #ifndef __TBB_INITIAL_CHUNKS
 // initial task divisions per thread
 #define __TBB_INITIAL_CHUNKS 2
@@ -50,6 +49,7 @@
 #endif // __TBB_DEFINE_MIC
 
 #include "task.h"
+#include "task_arena.h"
 #include "aligned_space.h"
 #include "atomic.h"
 #include "internal/_template_helpers.h"
@@ -76,7 +76,7 @@ namespace interface9 {
 namespace internal { //< @cond INTERNAL
 size_t __TBB_EXPORTED_FUNC get_initial_auto_partitioner_divisor();
 
-//! Defines entry point for affinity partitioner into tbb run-time library.
+//! Defines entry point for affinity partitioner into TBB run-time library.
 class affinity_partitioner_base_v3: no_copy {
     friend class tbb::affinity_partitioner;
     friend class tbb::interface9::internal::affinity_partition_type;
@@ -122,6 +122,7 @@ namespace internal {
 using namespace tbb::internal;
 template<typename Range, typename Body, typename Partitioner> class start_for;
 template<typename Range, typename Body, typename Partitioner> class start_reduce;
+template<typename Range, typename Body, typename Partitioner> class start_deterministic_reduce;
 
 //! Join task node that contains shared flag for stealing feedback
 class flag_task: public task {
@@ -260,7 +261,6 @@ struct partition_type_base {
 template <typename Partition>
 struct adaptive_mode : partition_type_base<Partition> {
     typedef Partition my_partition;
-    using partition_type_base<Partition>::self; // CRTP helper to get access to derived classes
     size_t my_divisor;
     // For affinity_partitioner, my_divisor indicates the number of affinity array indices the task reserves.
     // A task which has only one index must produce the right split without reserved index in order to avoid
@@ -269,12 +269,44 @@ struct adaptive_mode : partition_type_base<Partition> {
     static const unsigned factor = 1;
     adaptive_mode() : my_divisor(tbb::internal::get_initial_auto_partitioner_divisor() / 4 * my_partition::factor) {}
     adaptive_mode(adaptive_mode &src, split) : my_divisor(do_split(src, split())) {}
-    adaptive_mode(adaptive_mode &src, const proportional_split& split_obj) : my_divisor(do_split(src, split_obj)) {}
     /*! Override do_split methods in order to specify splitting strategy */
     size_t do_split(adaptive_mode &src, split) {
         return src.my_divisor /= 2u;
     }
-    size_t do_split(adaptive_mode &src, const proportional_split& split_obj) {
+};
+
+//! A helper class to create a proportional_split object for a given type of Range.
+/** If the Range has static boolean constant 'is_splittable_in_proportion' set to 'true',
+    the created object splits a provided value in an implemenation-defined proportion;
+    otherwise it represents equal-size split. */
+// TODO: check if this helper can be a nested class of proportional_mode.
+template <typename Range, typename = void>
+struct proportion_helper {
+    static proportional_split get_split(size_t) { return proportional_split(1,1); }
+};
+template <typename Range>
+struct proportion_helper<Range, typename enable_if<Range::is_splittable_in_proportion, void>::type> {
+    static proportional_split get_split(size_t n) {
+#if __TBB_NONUNIFORM_TASK_CREATION
+        size_t right = (n + 2) / 3;
+#else
+        size_t right = n / 2;
+#endif
+        size_t left = n - right;
+        return proportional_split(left, right);
+    }
+};
+
+//! Provides proportional splitting strategy for partition objects
+template <typename Partition>
+struct proportional_mode : adaptive_mode<Partition> {
+    typedef Partition my_partition;
+    using partition_type_base<Partition>::self; // CRTP helper to get access to derived classes
+
+    proportional_mode() : adaptive_mode<Partition>() {}
+    proportional_mode(proportional_mode &src, split) : adaptive_mode<Partition>(src, split()) {}
+    proportional_mode(proportional_mode &src, const proportional_split& split_obj) { self().my_divisor = do_split(src, split_obj); }
+    size_t do_split(proportional_mode &src, const proportional_split& split_obj) {
 #if __TBB_ENABLE_RANGE_FEEDBACK
         size_t portion = size_t(float(src.my_divisor) * float(split_obj.right())
                                 / float(split_obj.left() + split_obj.right()) + 0.5f);
@@ -293,81 +325,43 @@ struct adaptive_mode : partition_type_base<Partition> {
         return portion;
     }
     bool is_divisible() { // part of old should_execute_range()
-        return my_divisor > my_partition::factor;
+        return self().my_divisor > my_partition::factor;
+    }
+    template <typename Range>
+    proportional_split get_split() {
+        // Create a proportion for the number of threads expected to handle "this" subrange
+        return proportion_helper<Range>::get_split( self().my_divisor / my_partition::factor );
     }
 };
 
+static size_t get_initial_partition_head() {
+    int current_index = tbb::this_task_arena::current_thread_index();
+    if (current_index == tbb::task_arena::not_initialized)
+        current_index = 0;
+    return size_t(current_index);
+}
+
 //! Provides default linear indexing of partitioner's sequence
 template <typename Partition>
-struct linear_affinity_mode : adaptive_mode<Partition> {
-    using adaptive_mode<Partition>::my_divisor;
+struct linear_affinity_mode : proportional_mode<Partition> {
     size_t my_head;
-    using adaptive_mode<Partition>::self;
-    linear_affinity_mode() : adaptive_mode<Partition>(), my_head(0) {}
-    linear_affinity_mode(linear_affinity_mode &src, split) : adaptive_mode<Partition>(src, split())
-        , my_head(src.my_head + src.my_divisor) {}
-    linear_affinity_mode(linear_affinity_mode &src, const proportional_split& split_obj) : adaptive_mode<Partition>(src, split_obj)
-        , my_head(src.my_head + src.my_divisor) {}
+    size_t my_max_affinity;
+    using proportional_mode<Partition>::self;
+    linear_affinity_mode() : proportional_mode<Partition>(), my_head(get_initial_partition_head()),
+                             my_max_affinity(self().my_divisor) {}
+    linear_affinity_mode(linear_affinity_mode &src, split) : proportional_mode<Partition>(src, split())
+        , my_head((src.my_head + src.my_divisor) % src.my_max_affinity), my_max_affinity(src.my_max_affinity) {}
+    linear_affinity_mode(linear_affinity_mode &src, const proportional_split& split_obj) : proportional_mode<Partition>(src, split_obj)
+        , my_head((src.my_head + src.my_divisor) % src.my_max_affinity), my_max_affinity(src.my_max_affinity) {}
     void set_affinity( task &t ) {
-        if( my_divisor )
+        if( self().my_divisor )
             t.set_affinity( affinity_id(my_head) + 1 );
     }
 };
 
-//! Class determines whether template parameter has static boolean constant
-//! 'is_splittable_in_proportion' initialized with value of 'true' or not.
-/** If template parameter has such field that has been initialized with non-zero
- *  value then class field will be set to 'true', otherwise - 'false'
- */
-template <typename Range>
-class is_splittable_in_proportion {
-private:
-    typedef char yes[1];
-    typedef char no [2];
-
-    template <typename range_type> static yes& decide(typename enable_if<range_type::is_splittable_in_proportion>::type *);
-    template <typename range_type> static no& decide(...);
-public:
-    // equals to 'true' if and only if static const variable 'is_splittable_in_proportion' of template parameter
-    // initialized with the value of 'true'
-    static const bool value = (sizeof(decide<Range>(0)) == sizeof(yes));
-};
-
-//! Provides default methods for non-balancing partition objects.
-template<class Mode>
-struct unbalancing_partition_type : Mode {
-    using Mode::self;
-    unbalancing_partition_type() : Mode() {}
-    unbalancing_partition_type(unbalancing_partition_type& p, split) : Mode(p, split()) {}
-    unbalancing_partition_type(unbalancing_partition_type& p, const proportional_split& split_obj) : Mode(p, split_obj) {}
-#if _MSC_VER && !defined(__INTEL_COMPILER)
-    // Suppress "conditional expression is constant" warning.
-    #pragma warning( push )
-    #pragma warning( disable: 4127 )
-#endif
-    template <typename Range>
-    proportional_split get_split() {
-        if (is_splittable_in_proportion<Range>::value) {
-            size_t size = self().my_divisor / Mode::my_partition::factor;
-#if __TBB_NONUNIFORM_TASK_CREATION
-            size_t right = (size + 2) / 3;
-#else
-            size_t right = size / 2;
-#endif
-            size_t left = size - right;
-            return proportional_split(left, right);
-        } else {
-            return proportional_split(1, 1);
-        }
-    }
-#if _MSC_VER && !defined(__INTEL_COMPILER)
-    #pragma warning( pop )
-#endif // warning 4127 is back
-};
-
 /*! Determine work-balance phase implementing splitting & stealing actions */
 template<class Mode>
-struct balancing_partition_type : unbalancing_partition_type<Mode> {
+struct dynamic_grainsize_mode : Mode {
     using Mode::self;
 #ifdef __TBB_USE_MACHINE_TIME_STAMPS
     tbb::internal::machine_tsc_t my_dst_tsc;
@@ -379,27 +373,27 @@ struct balancing_partition_type : unbalancing_partition_type<Mode> {
     } my_delay;
     depth_t my_max_depth;
     static const unsigned range_pool_size = __TBB_RANGE_POOL_CAPACITY;
-    balancing_partition_type(): unbalancing_partition_type<Mode>()
+    dynamic_grainsize_mode(): Mode()
 #ifdef __TBB_USE_MACHINE_TIME_STAMPS
         , my_dst_tsc(0)
 #endif
         , my_delay(begin)
         , my_max_depth(__TBB_INIT_DEPTH) {}
-    balancing_partition_type(balancing_partition_type& p, split)
-        : unbalancing_partition_type<Mode>(p, split())
+    dynamic_grainsize_mode(dynamic_grainsize_mode& p, split)
+        : Mode(p, split())
 #ifdef __TBB_USE_MACHINE_TIME_STAMPS
         , my_dst_tsc(0)
 #endif
         , my_delay(pass)
         , my_max_depth(p.my_max_depth) {}
-    balancing_partition_type(balancing_partition_type& p, const proportional_split& split_obj)
-        : unbalancing_partition_type<Mode>(p, split_obj)
+    dynamic_grainsize_mode(dynamic_grainsize_mode& p, const proportional_split& split_obj)
+        : Mode(p, split_obj)
 #ifdef __TBB_USE_MACHINE_TIME_STAMPS
         , my_dst_tsc(0)
 #endif
         , my_delay(begin)
         , my_max_depth(p.my_max_depth) {}
-    bool check_being_stolen( task &t) { // part of old should_execute_range()
+    bool check_being_stolen(task &t) { // part of old should_execute_range()
         if( !(self().my_divisor / Mode::my_partition::factor) ) { // if not from the top P tasks of binary tree
             self().my_divisor = 1; // TODO: replace by on-stack flag (partition_state's member)?
             if( t.is_stolen_task() && t.parent()->ref_count() >= 2 ) { // runs concurrently with the left task
@@ -478,14 +472,14 @@ struct balancing_partition_type : unbalancing_partition_type<Mode> {
     }
 };
 
-class auto_partition_type: public balancing_partition_type<adaptive_mode<auto_partition_type> > {
+class auto_partition_type: public dynamic_grainsize_mode<adaptive_mode<auto_partition_type> > {
 public:
     auto_partition_type( const auto_partitioner& )
-        : balancing_partition_type<adaptive_mode<auto_partition_type> >() {
+        : dynamic_grainsize_mode<adaptive_mode<auto_partition_type> >() {
         my_divisor *= __TBB_INITIAL_CHUNKS;
     }
     auto_partition_type( auto_partition_type& src, split)
-        : balancing_partition_type<adaptive_mode<auto_partition_type> >(src, split()) {}
+        : dynamic_grainsize_mode<adaptive_mode<auto_partition_type> >(src, split()) {}
     bool is_divisible() { // part of old should_execute_range()
         if( my_divisor > 1 ) return true;
         if( my_divisor && my_max_depth ) { // can split the task. TODO: on-stack flag instead
@@ -517,25 +511,25 @@ class simple_partition_type: public partition_type_base<simple_partition_type> {
     }
 };
 
-class static_partition_type : public unbalancing_partition_type<linear_affinity_mode<static_partition_type> > {
+class static_partition_type : public linear_affinity_mode<static_partition_type> {
 public:
     typedef proportional_split split_type;
     static_partition_type( const static_partitioner& )
-        : unbalancing_partition_type<linear_affinity_mode<static_partition_type> >() {}
+        : linear_affinity_mode<static_partition_type>() {}
     static_partition_type( static_partition_type& p, split )
-        : unbalancing_partition_type<linear_affinity_mode<static_partition_type> >(p, split()) {}
+        : linear_affinity_mode<static_partition_type>(p, split()) {}
     static_partition_type( static_partition_type& p, const proportional_split& split_obj )
-        : unbalancing_partition_type<linear_affinity_mode<static_partition_type> >(p, split_obj) {}
+        : linear_affinity_mode<static_partition_type>(p, split_obj) {}
 };
 
-class affinity_partition_type : public balancing_partition_type<linear_affinity_mode<affinity_partition_type> > {
+class affinity_partition_type : public dynamic_grainsize_mode<linear_affinity_mode<affinity_partition_type> > {
     static const unsigned factor_power = 4; // TODO: get a unified formula based on number of computing units
     tbb::internal::affinity_id* my_array;
 public:
     static const unsigned factor = 1 << factor_power; // number of slots in affinity array per task
     typedef proportional_split split_type;
     affinity_partition_type( tbb::internal::affinity_partitioner_base_v3& ap )
-        : balancing_partition_type<linear_affinity_mode<affinity_partition_type> >() {
+        : dynamic_grainsize_mode<linear_affinity_mode<affinity_partition_type> >() {
         __TBB_ASSERT( (factor&(factor-1))==0, "factor must be power of two" );
         ap.resize(factor);
         my_array = ap.my_array;
@@ -543,10 +537,10 @@ class affinity_partition_type : public balancing_partition_type<linear_affinity_
         __TBB_ASSERT( my_max_depth < __TBB_RANGE_POOL_CAPACITY, 0 );
     }
     affinity_partition_type(affinity_partition_type& p, split)
-        : balancing_partition_type<linear_affinity_mode<affinity_partition_type> >(p, split())
+        : dynamic_grainsize_mode<linear_affinity_mode<affinity_partition_type> >(p, split())
         , my_array(p.my_array) {}
     affinity_partition_type(affinity_partition_type& p, const proportional_split& split_obj)
-        : balancing_partition_type<linear_affinity_mode<affinity_partition_type> >(p, split_obj)
+        : dynamic_grainsize_mode<linear_affinity_mode<affinity_partition_type> >(p, split_obj)
         , my_array(p.my_array) {}
     void set_affinity( task &t ) {
         if( my_divisor ) {
@@ -596,6 +590,7 @@ class simple_partitioner {
     template<typename Range, typename Body, typename Partitioner> friend class serial::interface9::start_for;
     template<typename Range, typename Body, typename Partitioner> friend class interface9::internal::start_for;
     template<typename Range, typename Body, typename Partitioner> friend class interface9::internal::start_reduce;
+    template<typename Range, typename Body, typename Partitioner> friend class interface9::internal::start_deterministic_reduce;
     template<typename Range, typename Body, typename Partitioner> friend class internal::start_scan;
     // backward compatibility
     class partition_type: public internal::partition_type_base {
@@ -641,6 +636,7 @@ class static_partitioner {
     template<typename Range, typename Body, typename Partitioner> friend class serial::interface9::start_for;
     template<typename Range, typename Body, typename Partitioner> friend class interface9::internal::start_for;
     template<typename Range, typename Body, typename Partitioner> friend class interface9::internal::start_reduce;
+    template<typename Range, typename Body, typename Partitioner> friend class interface9::internal::start_deterministic_reduce;
     template<typename Range, typename Body, typename Partitioner> friend class internal::start_scan;
     // backward compatibility
     typedef interface9::internal::old_auto_partition_type partition_type;
@@ -678,4 +674,8 @@ class affinity_partitioner: internal::affinity_partitioner_base_v3 {
 #undef __TBB_INITIAL_CHUNKS
 #undef __TBB_RANGE_POOL_CAPACITY
 #undef __TBB_INIT_DEPTH
+
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_partitioner_H_include_area
+
 #endif /* __TBB_partitioner_H */
diff --git a/inst/include/tbb/pipeline.h b/inst/include/tbb/pipeline.h
index 20a8ec9b..b8212ddb 100644
--- a/inst/include/tbb/pipeline.h
+++ b/inst/include/tbb/pipeline.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,21 +12,20 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_pipeline_H
 #define __TBB_pipeline_H
 
+#define __TBB_pipeline_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #include "atomic.h"
 #include "task.h"
 #include "tbb_allocator.h"
 #include <cstddef>
 
-#if __TBB_CPP11_TYPE_PROPERTIES_PRESENT || __TBB_TR1_TYPE_PROPERTIES_IN_STD_PRESENT
+#if __TBB_CPP11_TYPE_PROPERTIES_PRESENT
 #include <type_traits>
 #endif
 
@@ -65,7 +64,7 @@ namespace interface6 {
 class filter: internal::no_copy {
 private:
     //! Value used to mark "not in pipeline"
-    static filter* not_in_pipeline() {return reinterpret_cast<filter*>(intptr_t(-1));}
+    static filter* not_in_pipeline() { return reinterpret_cast<filter*>(intptr_t(-1)); }
 protected:
     //! The lowest bit 0 is for parallel vs. serial
     static const unsigned char filter_is_serial = 0x1;
@@ -157,7 +156,7 @@ class filter: internal::no_copy {
     //! Destroys item if pipeline was cancelled.
     /** Required to prevent memory leaks.
         Note it can be called concurrently even for serial filters.*/
-    virtual void finalize( void* /*item*/ ) {};
+    virtual void finalize( void* /*item*/ ) {}
 #endif
 
 private:
@@ -233,7 +232,7 @@ class thread_bound_filter: public filter {
 
 //! A processing pipeline that applies filters to items.
 /** @ingroup algorithms */
-class pipeline {
+class __TBB_DEPRECATED_MSG("tbb::pipeline is deprecated, use tbb::parallel_pipeline") pipeline {
 public:
     //! Construct empty pipeline.
     __TBB_EXPORTED_METHOD pipeline();
@@ -301,6 +300,12 @@ class pipeline {
 // Support for lambda-friendly parallel_pipeline interface
 //------------------------------------------------------------------------
 
+namespace flow {
+namespace interface11 {
+    template<typename Output> class input_node;
+}
+}
+
 namespace interface6 {
 
 namespace internal {
@@ -312,6 +317,7 @@ class flow_control {
     bool is_pipeline_stopped;
     flow_control() { is_pipeline_stopped = false; }
     template<typename T, typename U, typename Body> friend class internal::concrete_filter;
+    template<typename Output> friend class flow::interface11::input_node;
 public:
     void stop() { is_pipeline_stopped = true; }
 };
@@ -319,43 +325,58 @@ class flow_control {
 //! @cond INTERNAL
 namespace internal {
 
-template<typename T> struct tbb_large_object {enum { value = sizeof(T) > sizeof(void *) }; };
-
-// Obtain type properties in one or another way
+// Emulate std::is_trivially_copyable (false positives not allowed, false negatives suboptimal but safe).
 #if   __TBB_CPP11_TYPE_PROPERTIES_PRESENT
 template<typename T> struct tbb_trivially_copyable { enum { value = std::is_trivially_copyable<T>::value }; };
-#elif __TBB_TR1_TYPE_PROPERTIES_IN_STD_PRESENT
-template<typename T> struct tbb_trivially_copyable { enum { value = std::has_trivial_copy_constructor<T>::value }; };
 #else
-// Explicitly list the types we wish to be placed as-is in the pipeline input_buffers.
-template<typename T> struct tbb_trivially_copyable { enum { value = false }; };
-template<typename T> struct tbb_trivially_copyable <T*> { enum { value = true }; };
-template<> struct tbb_trivially_copyable <short> { enum { value = true }; };
-template<> struct tbb_trivially_copyable <unsigned short> { enum { value = true }; };
-template<> struct tbb_trivially_copyable <int> { enum { value = !tbb_large_object<int>::value }; };
-template<> struct tbb_trivially_copyable <unsigned int> { enum { value = !tbb_large_object<int>::value }; };
-template<> struct tbb_trivially_copyable <long> { enum { value = !tbb_large_object<long>::value }; };
-template<> struct tbb_trivially_copyable <unsigned long> { enum { value = !tbb_large_object<long>::value }; };
-template<> struct tbb_trivially_copyable <float> { enum { value = !tbb_large_object<float>::value }; };
-template<> struct tbb_trivially_copyable <double> { enum { value = !tbb_large_object<double>::value }; };
-#endif // Obtaining type properties
-
-template<typename T> struct is_large_object {enum { value = tbb_large_object<T>::value || !tbb_trivially_copyable<T>::value }; };
-
-template<typename T, bool> class token_helper;
-
-// large object helper (uses tbb_allocator)
+template<typename T> struct tbb_trivially_copyable                      { enum { value = false }; };
+template<typename T> struct tbb_trivially_copyable <         T*       > { enum { value = true  }; };
+template<>           struct tbb_trivially_copyable <         bool     > { enum { value = true  }; };
+template<>           struct tbb_trivially_copyable <         char     > { enum { value = true  }; };
+template<>           struct tbb_trivially_copyable <  signed char     > { enum { value = true  }; };
+template<>           struct tbb_trivially_copyable <unsigned char     > { enum { value = true  }; };
+template<>           struct tbb_trivially_copyable <         short    > { enum { value = true  }; };
+template<>           struct tbb_trivially_copyable <unsigned short    > { enum { value = true  }; };
+template<>           struct tbb_trivially_copyable <         int      > { enum { value = true  }; };
+template<>           struct tbb_trivially_copyable <unsigned int      > { enum { value = true  }; };
+template<>           struct tbb_trivially_copyable <         long     > { enum { value = true  }; };
+template<>           struct tbb_trivially_copyable <unsigned long     > { enum { value = true  }; };
+template<>           struct tbb_trivially_copyable <         long long> { enum { value = true  }; };
+template<>           struct tbb_trivially_copyable <unsigned long long> { enum { value = true  }; };
+template<>           struct tbb_trivially_copyable <         float    > { enum { value = true  }; };
+template<>           struct tbb_trivially_copyable <         double   > { enum { value = true  }; };
+template<>           struct tbb_trivially_copyable <    long double   > { enum { value = true  }; };
+#if !_MSC_VER || defined(_NATIVE_WCHAR_T_DEFINED)
+template<>           struct tbb_trivially_copyable <         wchar_t  > { enum { value = true  }; };
+#endif /* _MSC_VER||!defined(_NATIVE_WCHAR_T_DEFINED) */
+#endif // tbb_trivially_copyable
+
+template<typename T>
+struct use_allocator {
+    enum { value = sizeof(T) > sizeof(void *) || !tbb_trivially_copyable<T>::value };
+};
+
+// A helper class to customize how a type is passed between filters.
+// Usage: token_helper<T, use_allocator<T>::value>
+template<typename T, bool Allocate> class token_helper;
+
+// using tbb_allocator
 template<typename T>
 class token_helper<T, true> {
-    public:
+public:
     typedef typename tbb::tbb_allocator<T> allocator;
     typedef T* pointer;
     typedef T value_type;
-    static pointer create_token(const value_type & source) {
+#if __TBB_CPP11_RVALUE_REF_PRESENT
+    static pointer create_token(value_type && source)
+#else
+    static pointer create_token(const value_type & source)
+#endif
+    {
         pointer output_t = allocator().allocate(1);
-        return new (output_t) T(source);
+        return new (output_t) T(tbb::internal::move(source));
     }
-    static value_type & token(pointer & t) { return *t;}
+    static value_type & token(pointer & t) { return *t; }
     static void * cast_to_void_ptr(pointer ref) { return (void *) ref; }
     static pointer cast_from_void_ptr(void * ref) { return (pointer)ref; }
     static void destroy_token(pointer token) {
@@ -366,30 +387,29 @@ class token_helper<T, true> {
 
 // pointer specialization
 template<typename T>
-class token_helper<T*, false > {
-    public:
+class token_helper<T*, false> {
+public:
     typedef T* pointer;
     typedef T* value_type;
     static pointer create_token(const value_type & source) { return source; }
-    static value_type & token(pointer & t) { return t;}
+    static value_type & token(pointer & t) { return t; }
     static void * cast_to_void_ptr(pointer ref) { return (void *)ref; }
     static pointer cast_from_void_ptr(void * ref) { return (pointer)ref; }
     static void destroy_token( pointer /*token*/) {}
 };
 
-// small object specialization (converts void* to the correct type, passes objects directly.)
+// converting type to and from void*, passing objects directly
 template<typename T>
 class token_helper<T, false> {
     typedef union {
         T actual_value;
         void * void_overlay;
     } type_to_void_ptr_map;
-    public:
+public:
     typedef T pointer;  // not really a pointer in this case.
     typedef T value_type;
-    static pointer create_token(const value_type & source) {
-        return source; }
-    static value_type & token(pointer & t) { return t;}
+    static pointer create_token(const value_type & source) { return source; }
+    static value_type & token(pointer & t) { return t; }
     static void * cast_to_void_ptr(pointer ref) {
         type_to_void_ptr_map mymap;
         mymap.void_overlay = NULL;
@@ -404,17 +424,18 @@ class token_helper<T, false> {
     static void destroy_token( pointer /*token*/) {}
 };
 
+// intermediate
 template<typename T, typename U, typename Body>
 class concrete_filter: public tbb::filter {
     const Body& my_body;
-    typedef token_helper<T,is_large_object<T>::value > t_helper;
+    typedef token_helper<T,use_allocator<T>::value> t_helper;
     typedef typename t_helper::pointer t_pointer;
-    typedef token_helper<U,is_large_object<U>::value > u_helper;
+    typedef token_helper<U,use_allocator<U>::value> u_helper;
     typedef typename u_helper::pointer u_pointer;
 
     void* operator()(void* input) __TBB_override {
         t_pointer temp_input = t_helper::cast_from_void_ptr(input);
-        u_pointer output_u = u_helper::create_token(my_body(t_helper::token(temp_input)));
+        u_pointer output_u = u_helper::create_token(my_body(tbb::internal::move(t_helper::token(temp_input))));
         t_helper::destroy_token(temp_input);
         return u_helper::cast_to_void_ptr(output_u);
     }
@@ -432,7 +453,7 @@ class concrete_filter: public tbb::filter {
 template<typename U, typename Body>
 class concrete_filter<void,U,Body>: public filter {
     const Body& my_body;
-    typedef token_helper<U, is_large_object<U>::value > u_helper;
+    typedef token_helper<U, use_allocator<U>::value> u_helper;
     typedef typename u_helper::pointer u_pointer;
 
     void* operator()(void*) __TBB_override {
@@ -453,15 +474,16 @@ class concrete_filter<void,U,Body>: public filter {
     {}
 };
 
+// output
 template<typename T, typename Body>
 class concrete_filter<T,void,Body>: public filter {
     const Body& my_body;
-    typedef token_helper<T, is_large_object<T>::value > t_helper;
+    typedef token_helper<T, use_allocator<T>::value> t_helper;
     typedef typename t_helper::pointer t_pointer;
 
     void* operator()(void* input) __TBB_override {
         t_pointer temp_input = t_helper::cast_from_void_ptr(input);
-        my_body(t_helper::token(temp_input));
+        my_body(tbb::internal::move(t_helper::token(temp_input)));
         t_helper::destroy_token(temp_input);
         return NULL;
     }
@@ -478,7 +500,6 @@ template<typename Body>
 class concrete_filter<void,void,Body>: public filter {
     const Body& my_body;
 
-    /** Override privately because it is always called virtually */
     void* operator()(void*) __TBB_override {
         flow_control control;
         my_body(control);
@@ -518,7 +539,7 @@ class filter_node: tbb::internal::no_copy {
     //! Add concrete_filter to pipeline
     virtual void add_to( pipeline& ) = 0;
     //! Increment reference count
-    void add_ref() {++ref_count;}
+    void add_ref() { ++ref_count; }
     //! Decrement reference count and delete if it becomes zero.
     void remove_ref() {
         __TBB_ASSERT(ref_count>0,"ref_count underflow");
@@ -534,7 +555,7 @@ class filter_node: tbb::internal::no_copy {
 
 //! Node in parse tree representing result of make_filter.
 template<typename T, typename U, typename Body>
-class filter_node_leaf: public filter_node  {
+class filter_node_leaf: public filter_node {
     const tbb::filter::mode mode;
     const Body body;
     void add_to( pipeline& p ) __TBB_override {
@@ -662,4 +683,7 @@ using interface6::parallel_pipeline;
 
 } // tbb
 
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_pipeline_H_include_area
+
 #endif /* __TBB_pipeline_H */
diff --git a/inst/include/tbb/queuing_mutex.h b/inst/include/tbb/queuing_mutex.h
index 0fe4b3ea..c5c64993 100644
--- a/inst/include/tbb/queuing_mutex.h
+++ b/inst/include/tbb/queuing_mutex.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,29 +12,15 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_queuing_mutex_H
 #define __TBB_queuing_mutex_H
 
-#include "tbb_config.h"
-
-#if !TBB_USE_EXCEPTIONS && _MSC_VER
-    // Suppress "C++ exception handler used, but unwind semantics are not enabled" warning in STL headers
-    #pragma warning (push)
-    #pragma warning (disable: 4530)
-#endif
+#define __TBB_queuing_mutex_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
 
 #include <cstring>
-
-#if !TBB_USE_EXCEPTIONS && _MSC_VER
-    #pragma warning (pop)
-#endif
-
 #include "atomic.h"
 #include "tbb_profiling.h"
 
@@ -59,6 +45,7 @@ class queuing_mutex : internal::mutex_copy_deprecated_and_disabled {
         //! Initialize fields to mean "no lock held".
         void initialize() {
             mutex = NULL;
+            going = 0;
 #if TBB_USE_ASSERT
             internal::poison_pointer(next);
 #endif /* TBB_USE_ASSERT */
@@ -120,4 +107,7 @@ __TBB_DEFINE_PROFILING_SET_NAME(queuing_mutex)
 
 } // namespace tbb
 
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_queuing_mutex_H_include_area
+
 #endif /* __TBB_queuing_mutex_H */
diff --git a/inst/include/tbb/queuing_rw_mutex.h b/inst/include/tbb/queuing_rw_mutex.h
index e0224ed5..b264141c 100644
--- a/inst/include/tbb/queuing_rw_mutex.h
+++ b/inst/include/tbb/queuing_rw_mutex.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,29 +12,15 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_queuing_rw_mutex_H
 #define __TBB_queuing_rw_mutex_H
 
-#include "tbb_config.h"
-
-#if !TBB_USE_EXCEPTIONS && _MSC_VER
-    // Suppress "C++ exception handler used, but unwind semantics are not enabled" warning in STL headers
-    #pragma warning (push)
-    #pragma warning (disable: 4530)
-#endif
+#define __TBB_queuing_rw_mutex_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
 
 #include <cstring>
-
-#if !TBB_USE_EXCEPTIONS && _MSC_VER
-    #pragma warning (pop)
-#endif
-
 #include "atomic.h"
 #include "tbb_profiling.h"
 
@@ -68,6 +54,8 @@ class queuing_rw_mutex : internal::mutex_copy_deprecated_and_disabled {
         //! Initialize fields to mean "no lock held".
         void initialize() {
             my_mutex = NULL;
+            my_internal_lock = 0;
+            my_going = 0;
 #if TBB_USE_ASSERT
             my_state = 0xFF; // Set to invalid state
             internal::poison_pointer(my_next);
@@ -160,4 +148,7 @@ __TBB_DEFINE_PROFILING_SET_NAME(queuing_rw_mutex)
 
 } // namespace tbb
 
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_queuing_rw_mutex_H_include_area
+
 #endif /* __TBB_queuing_rw_mutex_H */
diff --git a/inst/include/tbb/reader_writer_lock.h b/inst/include/tbb/reader_writer_lock.h
index 353beec5..509ff7b7 100644
--- a/inst/include/tbb/reader_writer_lock.h
+++ b/inst/include/tbb/reader_writer_lock.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,15 +12,25 @@
     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 "internal/_deprecated_header_message_guard.h"
 
+#if !defined(__TBB_show_deprecation_message_reader_writer_lock_H) && defined(__TBB_show_deprecated_header_message)
+#define  __TBB_show_deprecation_message_reader_writer_lock_H
+#pragma message("TBB Warning: tbb/reader_writer_lock.h is deprecated. For details, please see Deprecated Features appendix in the TBB reference manual.")
+#endif
 
-
-*/
+#if defined(__TBB_show_deprecated_header_message)
+#undef __TBB_show_deprecated_header_message
+#endif
 
 #ifndef __TBB_reader_writer_lock_H
 #define __TBB_reader_writer_lock_H
 
+#define __TBB_reader_writer_lock_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #include "tbb_thread.h"
 #include "tbb_allocator.h"
 #include "atomic.h"
@@ -31,7 +41,8 @@ namespace interface5 {
 /** Loosely adapted from Mellor-Crummey and Scott pseudocode at
     http://www.cs.rochester.edu/research/synchronization/pseudocode/rw.html#s_wp
     @ingroup synchronization */
-    class reader_writer_lock : tbb::internal::no_copy {
+    class __TBB_DEPRECATED_IN_VERBOSE_MODE_MSG("tbb::reader_writer_lock is deprecated, use std::shared_mutex")
+    reader_writer_lock : tbb::internal::no_copy {
  public:
     friend class scoped_lock;
     friend class scoped_lock_read;
@@ -229,4 +240,7 @@ using interface5::reader_writer_lock;
 
 } // namespace tbb
 
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_reader_writer_lock_H_include_area
+
 #endif /* __TBB_reader_writer_lock_H */
diff --git a/inst/include/tbb/recursive_mutex.h b/inst/include/tbb/recursive_mutex.h
index 5a23c097..d5be2c4f 100644
--- a/inst/include/tbb/recursive_mutex.h
+++ b/inst/include/tbb/recursive_mutex.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,15 +12,25 @@
     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 "internal/_deprecated_header_message_guard.h"
 
+#if !defined(__TBB_show_deprecation_message_recursive_mutex_H) && defined(__TBB_show_deprecated_header_message)
+#define  __TBB_show_deprecation_message_recursive_mutex_H
+#pragma message("TBB Warning: tbb/recursive_mutex.h is deprecated. For details, please see Deprecated Features appendix in the TBB reference manual.")
+#endif
 
-
-*/
+#if defined(__TBB_show_deprecated_header_message)
+#undef __TBB_show_deprecated_header_message
+#endif
 
 #ifndef __TBB_recursive_mutex_H
 #define __TBB_recursive_mutex_H
 
+#define __TBB_recursive_mutex_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #if _WIN32||_WIN64
 #include "machine/windows_api.h"
 #else
@@ -36,7 +46,8 @@ namespace tbb {
 //! Mutex that allows recursive mutex acquisition.
 /** Mutex that allows recursive mutex acquisition.
     @ingroup synchronization */
-class recursive_mutex : internal::mutex_copy_deprecated_and_disabled {
+class __TBB_DEPRECATED_IN_VERBOSE_MODE_MSG("tbb::recursive_mutex is deprecated, use std::recursive_mutex")
+recursive_mutex : internal::mutex_copy_deprecated_and_disabled {
 public:
     //! Construct unacquired recursive_mutex.
     recursive_mutex() {
@@ -231,4 +242,7 @@ __TBB_DEFINE_PROFILING_SET_NAME(recursive_mutex)
 
 } // namespace tbb
 
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_recursive_mutex_H_include_area
+
 #endif /* __TBB_recursive_mutex_H */
diff --git a/inst/include/tbb/runtime_loader.h b/inst/include/tbb/runtime_loader.h
index df284645..9aaeea5b 100644
--- a/inst/include/tbb/runtime_loader.h
+++ b/inst/include/tbb/runtime_loader.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,15 +12,25 @@
     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 "internal/_deprecated_header_message_guard.h"
 
+#if !defined(__TBB_show_deprecation_message_runtime_loader_H) && defined(__TBB_show_deprecated_header_message)
+#define  __TBB_show_deprecation_message_runtime_loader_H
+#pragma message("TBB Warning: tbb/runtime_loader.h is deprecated. For details, please see Deprecated Features appendix in the TBB reference manual.")
+#endif
 
-
-*/
+#if defined(__TBB_show_deprecated_header_message)
+#undef __TBB_show_deprecated_header_message
+#endif
 
 #ifndef __TBB_runtime_loader_H
 #define __TBB_runtime_loader_H
 
+#define __TBB_runtime_loader_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #if ! TBB_PREVIEW_RUNTIME_LOADER
     #error Set TBB_PREVIEW_RUNTIME_LOADER to include runtime_loader.h
 #endif
@@ -82,7 +92,7 @@ There are some implications:
 
 */
 
-class runtime_loader : tbb::internal::no_copy {
+class __TBB_DEPRECATED_IN_VERBOSE_MODE runtime_loader : tbb::internal::no_copy {
 
     public:
 
@@ -176,5 +186,8 @@ using interface6::runtime_loader;
 
 } // namespace tbb
 
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_runtime_loader_H_include_area
+
 #endif /* __TBB_runtime_loader_H */
 
diff --git a/inst/include/tbb/scalable_allocator.h b/inst/include/tbb/scalable_allocator.h
index c2a81493..f1fc98ed 100644
--- a/inst/include/tbb/scalable_allocator.h
+++ b/inst/include/tbb/scalable_allocator.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_scalable_allocator_H
@@ -95,9 +91,12 @@ typedef enum {
     TBBMALLOC_USE_HUGE_PAGES,  /* value turns using huge pages on and off */
     /* deprecated, kept for backward compatibility only */
     USE_HUGE_PAGES = TBBMALLOC_USE_HUGE_PAGES,
-    /* try to limit memory consumption value Bytes, clean internal buffers
+    /* try to limit memory consumption value (Bytes), clean internal buffers
        if limit is exceeded, but not prevents from requesting memory from OS */
-    TBBMALLOC_SET_SOFT_HEAP_LIMIT
+    TBBMALLOC_SET_SOFT_HEAP_LIMIT,
+    /* Lower bound for the size (Bytes), that is interpreted as huge
+     * and not released during regular cleanup operations. */
+    TBBMALLOC_SET_HUGE_SIZE_THRESHOLD
 } AllocationModeParam;
 
 /** Set TBB allocator-specific allocation modes.
@@ -193,7 +192,9 @@ void *pool_aligned_realloc(MemoryPool* mPool, void *ptr, size_t size, size_t ali
 bool  pool_reset(MemoryPool* memPool);
 bool  pool_free(MemoryPool *memPool, void *object);
 MemoryPool *pool_identify(void *object);
-}
+size_t pool_msize(MemoryPool *memPool, void *object);
+
+} // namespace rml
 
 #include <new>      /* To use new with the placement argument */
 
@@ -207,7 +208,11 @@ MemoryPool *pool_identify(void *object);
 #endif
 
 #if __TBB_ALLOCATOR_CONSTRUCT_VARIADIC
- #include <utility> // std::forward
+#include <utility> // std::forward
+#endif
+
+#if __TBB_CPP17_MEMORY_RESOURCE_PRESENT
+#include <memory_resource>
 #endif
 
 namespace tbb {
@@ -314,6 +319,48 @@ inline bool operator==( const scalable_allocator<T>&, const scalable_allocator<U
 template<typename T, typename U>
 inline bool operator!=( const scalable_allocator<T>&, const scalable_allocator<U>& ) {return false;}
 
+#if __TBB_CPP17_MEMORY_RESOURCE_PRESENT
+
+namespace internal {
+
+//! C++17 memory resource implementation for scalable allocator
+//! ISO C++ Section 23.12.2
+class scalable_resource_impl : public std::pmr::memory_resource {
+private:
+    void* do_allocate(size_t bytes, size_t alignment) override {
+        void* ptr = scalable_aligned_malloc( bytes, alignment );
+        if (!ptr) {
+            throw_exception(std::bad_alloc());
+        }
+        return ptr;
+    }
+
+    void do_deallocate(void* ptr, size_t /*bytes*/, size_t /*alignment*/) override {
+        scalable_free(ptr);
+    }
+
+    //! Memory allocated by one instance of scalable_resource_impl could be deallocated by any
+    //! other instance of this class
+    bool do_is_equal(const std::pmr::memory_resource& other) const noexcept override {
+        return this == &other ||
+#if __TBB_USE_OPTIONAL_RTTI
+            dynamic_cast<const scalable_resource_impl*>(&other) != NULL;
+#else
+            false;
+#endif
+    }
+};
+
+} // namespace internal
+
+//! Global scalable allocator memory resource provider
+inline std::pmr::memory_resource* scalable_memory_resource() noexcept {
+    static tbb::internal::scalable_resource_impl scalable_res;
+    return &scalable_res;
+}
+
+#endif /* __TBB_CPP17_MEMORY_RESOURCE_PRESENT */
+
 } // namespace tbb
 
 #if _MSC_VER
diff --git a/inst/include/tbb/spin_mutex.h b/inst/include/tbb/spin_mutex.h
index 99ef15c2..56348c9d 100644
--- a/inst/include/tbb/spin_mutex.h
+++ b/inst/include/tbb/spin_mutex.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,15 +12,14 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_spin_mutex_H
 #define __TBB_spin_mutex_H
 
+#define __TBB_spin_mutex_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #include <cstddef>
 #include <new>
 #include "aligned_space.h"
@@ -209,4 +208,7 @@ __TBB_DEFINE_PROFILING_SET_NAME(speculative_spin_mutex)
 
 } // namespace tbb
 
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_spin_mutex_H_include_area
+
 #endif /* __TBB_spin_mutex_H */
diff --git a/inst/include/tbb/spin_rw_mutex.h b/inst/include/tbb/spin_rw_mutex.h
index b20f4ebd..57a4ce2f 100644
--- a/inst/include/tbb/spin_rw_mutex.h
+++ b/inst/include/tbb/spin_rw_mutex.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_spin_rw_mutex_H
@@ -90,9 +86,6 @@ class spin_rw_mutex_v3 : internal::mutex_copy_deprecated_and_disabled {
     class scoped_lock : internal::no_copy {
 #if __TBB_TSX_AVAILABLE
         friend class tbb::interface8::internal::x86_rtm_rw_mutex;
-        // helper methods for x86_rtm_rw_mutex
-        spin_rw_mutex *internal_get_mutex() const { return mutex; }
-        void internal_set_mutex(spin_rw_mutex* m) { mutex = m; }
 #endif
     public:
         //! Construct lock that has not acquired a mutex.
@@ -121,15 +114,15 @@ class spin_rw_mutex_v3 : internal::mutex_copy_deprecated_and_disabled {
         //! Upgrade reader to become a writer.
         /** Returns whether the upgrade happened without releasing and re-acquiring the lock */
         bool upgrade_to_writer() {
-            __TBB_ASSERT( mutex, "lock is not acquired" );
-            __TBB_ASSERT( !is_writer, "not a reader" );
+            __TBB_ASSERT( mutex, "mutex is not acquired" );
+            if (is_writer) return true; // Already a writer
             is_writer = true;
             return mutex->internal_upgrade();
         }
 
         //! Release lock.
         void release() {
-            __TBB_ASSERT( mutex, "lock is not acquired" );
+            __TBB_ASSERT( mutex, "mutex is not acquired" );
             spin_rw_mutex *m = mutex;
             mutex = NULL;
 #if TBB_USE_THREADING_TOOLS||TBB_USE_ASSERT
@@ -143,8 +136,8 @@ class spin_rw_mutex_v3 : internal::mutex_copy_deprecated_and_disabled {
 
         //! Downgrade writer to become a reader.
         bool downgrade_to_reader() {
-            __TBB_ASSERT( mutex, "lock is not acquired" );
-            __TBB_ASSERT( is_writer, "not a writer" );
+            __TBB_ASSERT( mutex, "mutex is not acquired" );
+            if (!is_writer) return true; // Already a reader
 #if TBB_USE_THREADING_TOOLS||TBB_USE_ASSERT
             mutex->internal_downgrade();
 #else
diff --git a/inst/include/tbb/task.h b/inst/include/tbb/task.h
index 246684ab..5e137c69 100644
--- a/inst/include/tbb/task.h
+++ b/inst/include/tbb/task.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,15 +12,25 @@
     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 "internal/_deprecated_header_message_guard.h"
 
+#if !defined(__TBB_show_deprecation_message_task_H) && defined(__TBB_show_deprecated_header_message)
+#define  __TBB_show_deprecation_message_task_H
+#pragma message("TBB Warning: tbb/task.h is deprecated. For details, please see Deprecated Features appendix in the TBB reference manual.")
+#endif
 
-
-*/
+#if defined(__TBB_show_deprecated_header_message)
+#undef __TBB_show_deprecated_header_message
+#endif
 
 #ifndef __TBB_task_H
 #define __TBB_task_H
 
+#define __TBB_task_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #include "tbb_stddef.h"
 #include "tbb_machine.h"
 #include "tbb_profiling.h"
@@ -49,7 +59,9 @@ namespace internal { //< @cond INTERNAL
         task* self;
         task& parent;
     public:
-        explicit allocate_additional_child_of_proxy( task& parent_ ) : self(NULL), parent(parent_) {}
+        explicit allocate_additional_child_of_proxy( task& parent_ ) : self(NULL), parent(parent_) {
+            suppress_unused_warning( self );
+        }
         task& __TBB_EXPORTED_METHOD allocate( size_t size ) const;
         void __TBB_EXPORTED_METHOD free( task& ) const;
     };
@@ -118,6 +130,11 @@ namespace internal {
     /** Should always be non-negative.  A signed type is used so that underflow can be detected. */
     typedef intptr_t reference_count;
 
+#if __TBB_PREVIEW_RESUMABLE_TASKS
+    //! The flag to indicate that the wait task has been abandoned.
+    static const reference_count abandon_flag = reference_count(1) << (sizeof(reference_count)*CHAR_BIT - 2);
+#endif
+
     //! An id as used for specifying affinity.
     typedef unsigned short affinity_id;
 
@@ -162,18 +179,25 @@ namespace internal {
         void __TBB_EXPORTED_METHOD free( task& ) const;
     };
 
+#if __TBB_PREVIEW_CRITICAL_TASKS
+    // TODO: move to class methods when critical task API becomes public
+    void make_critical( task& t );
+    bool is_critical( task& t );
+#endif
+
     //! Memory prefix to a task object.
     /** This class is internal to the library.
         Do not reference it directly, except within the library itself.
-        Fields are ordered in way that preserves backwards compatibility and yields
-        good packing on typical 32-bit and 64-bit platforms. New fields should be
-        added at the beginning for backward compatibility with accesses to the task
-        prefix inlined into application code.
+        Fields are ordered in way that preserves backwards compatibility and yields good packing on
+        typical 32-bit and 64-bit platforms. New fields should be added at the beginning for
+        backward compatibility with accesses to the task prefix inlined into application code. To
+        prevent ODR violation, the class shall have the same layout in all application translation
+        units. If some fields are conditional (e.g. enabled by preview macros) and might get
+        skipped, use reserved fields to adjust the layout.
 
-        In case task prefix size exceeds 32 or 64 bytes on IA32 and Intel64
-        architectures correspondingly, consider dynamic setting of task_alignment
-        and task_prefix_reservation_size based on the maximal operand size supported
-        by the current CPU.
+        In case task prefix size exceeds 32 or 64 bytes on IA32 and Intel64 architectures
+        correspondingly, consider dynamic setting of task_alignment and task_prefix_reservation_size
+        based on the maximal operand size supported by the current CPU.
 
         @ingroup task_scheduling */
     class task_prefix {
@@ -186,10 +210,16 @@ namespace internal {
         friend class internal::allocate_child_proxy;
         friend class internal::allocate_continuation_proxy;
         friend class internal::allocate_additional_child_of_proxy;
+#if __TBB_PREVIEW_CRITICAL_TASKS
+        friend void make_critical( task& );
+        friend bool is_critical( task& );
+#endif
 
 #if __TBB_TASK_ISOLATION
         //! The tag used for task isolation.
         isolation_tag isolation;
+#else
+        intptr_t reserved_space_for_task_isolation_tag;
 #endif /* __TBB_TASK_ISOLATION */
 
 #if __TBB_TASK_GROUP_CONTEXT
@@ -208,7 +238,7 @@ namespace internal {
             thread-specific pools. */
         scheduler* origin;
 
-#if __TBB_TASK_PRIORITY
+#if __TBB_TASK_PRIORITY || __TBB_PREVIEW_RESUMABLE_TASKS
         union {
 #endif /* __TBB_TASK_PRIORITY */
         //! Obsolete. The scheduler that owns the task.
@@ -220,8 +250,15 @@ namespace internal {
         //! Pointer to the next offloaded lower priority task.
         /** Used to maintain a list of offloaded tasks inside the scheduler. **/
         task* next_offloaded;
+#endif
+
+#if __TBB_PREVIEW_RESUMABLE_TASKS
+        //! Pointer to the abandoned scheduler where the current task is waited for.
+        scheduler* abandoned_scheduler;
+#endif
+#if __TBB_TASK_PRIORITY || __TBB_PREVIEW_RESUMABLE_TASKS
         };
-#endif /* __TBB_TASK_PRIORITY */
+#endif /* __TBB_TASK_PRIORITY || __TBB_PREVIEW_RESUMABLE_TASKS */
 
         //! The task whose reference count includes me.
         /** In the "blocking style" of programming, this field points to the parent task.
@@ -271,6 +308,10 @@ namespace internal {
 #if __TBB_TASK_PRIORITY
 namespace internal {
     static const int priority_stride_v4 = INT_MAX / 4;
+#if __TBB_PREVIEW_CRITICAL_TASKS
+    // TODO: move into priority_t enum when critical tasks become public feature
+    static const int priority_critical = priority_stride_v4 * 3 + priority_stride_v4 / 3 * 2;
+#endif
 }
 
 enum priority_t {
@@ -291,6 +332,7 @@ enum priority_t {
 
 class task_scheduler_init;
 namespace interface7 { class task_arena; }
+using interface7::task_arena;
 
 //! Used to form groups of tasks
 /** @ingroup task_scheduling
@@ -317,7 +359,7 @@ class task_group_context : internal::no_copy {
 private:
     friend class internal::generic_scheduler;
     friend class task_scheduler_init;
-    friend class interface7::task_arena;
+    friend class task_arena;
 
 #if TBB_USE_CAPTURED_EXCEPTION
     typedef tbb_exception exception_container_type;
@@ -417,12 +459,16 @@ class task_group_context : internal::no_copy {
     intptr_t my_priority;
 #endif /* __TBB_TASK_PRIORITY */
 
+    //! Description of algorithm for scheduler based instrumentation.
+    internal::string_index my_name;
+
     //! Trailing padding protecting accesses to frequently used members from false sharing
     /** \sa _leading_padding **/
     char _trailing_padding[internal::NFS_MaxLineSize - 2 * sizeof(uintptr_t) - 2 * sizeof(void*)
 #if __TBB_TASK_PRIORITY
-                            - sizeof(intptr_t)
+                           - sizeof(intptr_t)
 #endif /* __TBB_TASK_PRIORITY */
+                           - sizeof(internal::string_index)
                           ];
 
 public:
@@ -458,7 +504,17 @@ class task_group_context : internal::no_copy {
     task_group_context ( kind_type relation_with_parent = bound,
                          uintptr_t t = default_traits )
         : my_kind(relation_with_parent)
-        , my_version_and_traits(2 | t)
+        , my_version_and_traits(3 | t)
+        , my_name(internal::CUSTOM_CTX)
+    {
+        init();
+    }
+
+    // Custom constructor for instrumentation of TBB algorithm
+    task_group_context ( internal::string_index name )
+        : my_kind(bound)
+        , my_version_and_traits(3 | default_traits)
+        , my_name(name)
     {
         init();
     }
@@ -512,10 +568,10 @@ class task_group_context : internal::no_copy {
 
 #if __TBB_TASK_PRIORITY
     //! Changes priority of the task group
-    void set_priority ( priority_t );
+    __TBB_DEPRECATED_IN_VERBOSE_MODE void set_priority ( priority_t );
 
     //! Retrieves current priority of the current task group
-    priority_t priority () const;
+    __TBB_DEPRECATED_IN_VERBOSE_MODE priority_t priority () const;
 #endif /* __TBB_TASK_PRIORITY */
 
     //! Returns the context's trait
@@ -556,7 +612,7 @@ class task_group_context : internal::no_copy {
 
 //! Base class for user-defined tasks.
 /** @ingroup task_scheduling */
-class task: __TBB_TASK_BASE_ACCESS interface5::internal::task_base {
+class __TBB_DEPRECATED_IN_VERBOSE_MODE task: __TBB_TASK_BASE_ACCESS interface5::internal::task_base {
 
     //! Set reference count
     void __TBB_EXPORTED_METHOD internal_set_ref_count( int count );
@@ -592,6 +648,10 @@ class task: __TBB_TASK_BASE_ACCESS interface5::internal::task_base {
 #if __TBB_RECYCLE_TO_ENQUEUE
         //! task to be scheduled for starvation-resistant execution
         ,to_enqueue
+#endif
+#if __TBB_PREVIEW_RESUMABLE_TASKS
+        //! a special task used to resume a scheduler.
+        ,to_resume
 #endif
     };
 
@@ -780,11 +840,24 @@ class task: __TBB_TASK_BASE_ACCESS interface5::internal::task_base {
 #if __TBB_TASK_PRIORITY
     //! Enqueue task for starvation-resistant execution on the specified priority level.
     static void enqueue( task& t, priority_t p ) {
-        __TBB_ASSERT( p == priority_low || p == priority_normal || p == priority_high, "Invalid priority level value" );
+#if __TBB_PREVIEW_CRITICAL_TASKS
+        __TBB_ASSERT(p == priority_low || p == priority_normal || p == priority_high
+                     || p == internal::priority_critical, "Invalid priority level value");
+#else
+        __TBB_ASSERT(p == priority_low || p == priority_normal || p == priority_high, "Invalid priority level value");
+#endif
         t.prefix().owner->enqueue( t, (void*)p );
     }
 #endif /* __TBB_TASK_PRIORITY */
 
+    //! Enqueue task in task_arena
+    //! The implementation is in task_arena.h
+#if __TBB_TASK_PRIORITY
+    inline static void enqueue( task& t, task_arena& arena, priority_t p = priority_t(0) );
+#else
+    inline static void enqueue( task& t, task_arena& arena);
+#endif
+
     //! The innermost task being executed or destroyed by the current thread at the moment.
     static task& __TBB_EXPORTED_FUNC self();
 
@@ -813,6 +886,24 @@ class task: __TBB_TASK_BASE_ACCESS interface5::internal::task_base {
         return (prefix().extra_state & 0x80)!=0;
     }
 
+    //! True if the task was enqueued
+    bool is_enqueued_task() const {
+        // es_task_enqueued = 0x10
+        return (prefix().extra_state & 0x10)!=0;
+    }
+
+#if __TBB_PREVIEW_RESUMABLE_TASKS
+    //! Type that defines suspension point
+    typedef void* suspend_point;
+
+    //! Suspend current task execution
+    template <typename F>
+    static void suspend(F f);
+
+    //! Resume specific suspend point
+    static void resume(suspend_point tag);
+#endif
+
     //------------------------------------------------------------------------
     // Debugging
     //------------------------------------------------------------------------
@@ -823,10 +914,18 @@ class task: __TBB_TASK_BASE_ACCESS interface5::internal::task_base {
     //! The internal reference count.
     int ref_count() const {
 #if TBB_USE_ASSERT
+#if __TBB_PREVIEW_RESUMABLE_TASKS
+        internal::reference_count ref_count_ = prefix().ref_count & ~internal::abandon_flag;
+#else
         internal::reference_count ref_count_ = prefix().ref_count;
+#endif
         __TBB_ASSERT( ref_count_==int(ref_count_), "integer overflow error");
 #endif
+#if __TBB_PREVIEW_RESUMABLE_TASKS
+        return int(prefix().ref_count & ~internal::abandon_flag);
+#else
         return int(prefix().ref_count);
+#endif
     }
 
     //! Obsolete, and only retained for the sake of backward compatibility. Always returns true.
@@ -879,10 +978,10 @@ class task: __TBB_TASK_BASE_ACCESS interface5::internal::task_base {
 
 #if __TBB_TASK_PRIORITY
     //! Changes priority of the task group this task belongs to.
-    void set_group_priority ( priority_t p ) {  prefix().context->set_priority(p); }
+    __TBB_DEPRECATED void set_group_priority ( priority_t p ) {  prefix().context->set_priority(p); }
 
     //! Retrieves current priority of the task group this task belongs to.
-    priority_t group_priority () const { return prefix().context->priority(); }
+    __TBB_DEPRECATED priority_t group_priority () const { return prefix().context->priority(); }
 
 #endif /* __TBB_TASK_PRIORITY */
 
@@ -903,11 +1002,44 @@ class task: __TBB_TASK_BASE_ACCESS interface5::internal::task_base {
     internal::task_prefix& prefix( internal::version_tag* = NULL ) const {
         return reinterpret_cast<internal::task_prefix*>(const_cast<task*>(this))[-1];
     }
+#if __TBB_PREVIEW_CRITICAL_TASKS
+    friend void internal::make_critical( task& );
+    friend bool internal::is_critical( task& );
+#endif
 }; // class task
 
+#if __TBB_PREVIEW_CRITICAL_TASKS
+namespace internal {
+inline void make_critical( task& t ) { t.prefix().extra_state |= 0x8; }
+inline bool is_critical( task& t ) { return bool((t.prefix().extra_state & 0x8) != 0); }
+} // namespace internal
+#endif /* __TBB_PREVIEW_CRITICAL_TASKS */
+
+#if __TBB_PREVIEW_RESUMABLE_TASKS
+namespace internal {
+    template <typename F>
+    static void suspend_callback(void* user_callback, task::suspend_point tag) {
+        // Copy user function to a new stack to avoid a race when the previous scheduler is resumed.
+        F user_callback_copy = *static_cast<F*>(user_callback);
+        user_callback_copy(tag);
+    }
+    void __TBB_EXPORTED_FUNC internal_suspend(void* suspend_callback, void* user_callback);
+    void __TBB_EXPORTED_FUNC internal_resume(task::suspend_point);
+    task::suspend_point __TBB_EXPORTED_FUNC internal_current_suspend_point();
+}
+
+template <typename F>
+inline void task::suspend(F f) {
+    internal::internal_suspend((void*)internal::suspend_callback<F>, &f);
+}
+inline void task::resume(suspend_point tag) {
+    internal::internal_resume(tag);
+}
+#endif
+
 //! task that does nothing.  Useful for synchronization.
 /** @ingroup task_scheduling */
-class empty_task: public task {
+class __TBB_DEPRECATED_IN_VERBOSE_MODE empty_task: public task {
     task* execute() __TBB_override {
         return NULL;
     }
@@ -918,6 +1050,7 @@ namespace internal {
     template<typename F>
     class function_task : public task {
 #if __TBB_ALLOW_MUTABLE_FUNCTORS
+        // TODO: deprecated behavior, remove
         F my_func;
 #else
         const F my_func;
@@ -928,6 +1061,9 @@ namespace internal {
         }
     public:
         function_task( const F& f ) : my_func(f) {}
+#if __TBB_CPP11_RVALUE_REF_PRESENT
+        function_task( F&& f ) : my_func( std::move(f) ) {}
+#endif
     };
 } // namespace internal
 //! @endcond
@@ -935,7 +1071,7 @@ namespace internal {
 //! A list of children.
 /** Used for method task::spawn_children
     @ingroup task_scheduling */
-class task_list: internal::no_copy {
+class __TBB_DEPRECATED_IN_VERBOSE_MODE task_list: internal::no_copy {
 private:
     task* first;
     task** next_ptr;
@@ -948,7 +1084,7 @@ class task_list: internal::no_copy {
     //! Destroys the list, but does not destroy the task objects.
     ~task_list() {}
 
-    //! True if list if empty; false otherwise.
+    //! True if list is empty; false otherwise.
     bool empty() const {return !first;}
 
     //! Push task onto back of list.
@@ -1047,4 +1183,7 @@ inline void operator delete( void* task, const tbb::internal::allocate_additiona
     p.free( *static_cast<tbb::task*>(task) );
 }
 
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_task_H_include_area
+
 #endif /* __TBB_task_H */
diff --git a/inst/include/tbb/task_arena.h b/inst/include/tbb/task_arena.h
index f33135b6..46eb4959 100644
--- a/inst/include/tbb/task_arena.h
+++ b/inst/include/tbb/task_arena.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,20 +12,24 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_task_arena_H
 #define __TBB_task_arena_H
 
+#define __TBB_task_arena_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #include "task.h"
 #include "tbb_exception.h"
+#include "internal/_template_helpers.h"
+#if __TBB_NUMA_SUPPORT
+#include "info.h"
+#endif /*__TBB_NUMA_SUPPORT*/
 #if TBB_USE_THREADING_TOOLS
 #include "atomic.h" // for as_atomic
 #endif
+#include "aligned_space.h"
 
 namespace tbb {
 
@@ -55,17 +59,62 @@ class delegate_base : no_assign {
     virtual ~delegate_base() {}
 };
 
-template<typename F>
+// If decltype is available, the helper detects the return type of functor of specified type,
+// otherwise it defines the void type.
+template <typename F>
+struct return_type_or_void {
+#if __TBB_CPP11_DECLTYPE_PRESENT && !__TBB_CPP11_DECLTYPE_OF_FUNCTION_RETURN_TYPE_BROKEN
+    typedef decltype(declval<F>()()) type;
+#else
+    typedef void type;
+#endif
+};
+
+template<typename F, typename R>
 class delegated_function : public delegate_base {
+    F &my_func;
+    tbb::aligned_space<R> my_return_storage;
+    // The function should be called only once.
+    void operator()() const __TBB_override {
+        new (my_return_storage.begin()) R(my_func());
+    }
+public:
+    delegated_function(F& f) : my_func(f) {}
+    // The function can be called only after operator() and only once.
+    R consume_result() const {
+        return tbb::internal::move(*(my_return_storage.begin()));
+    }
+    ~delegated_function() {
+        my_return_storage.begin()->~R();
+    }
+};
+
+template<typename F>
+class delegated_function<F,void> : public delegate_base {
     F &my_func;
     void operator()() const __TBB_override {
         my_func();
     }
 public:
-    delegated_function ( F& f ) : my_func(f) {}
+    delegated_function(F& f) : my_func(f) {}
+    void consume_result() const {}
+
+    friend class task_arena_base;
 };
 
 class task_arena_base {
+#if __TBB_NUMA_SUPPORT
+public:
+    // TODO: consider version approach to resolve backward compatibility potential issues.
+    struct constraints {
+        constraints(numa_node_id id = automatic, int maximal_concurrency = automatic)
+            : numa_id(id)
+            , max_concurrency(maximal_concurrency)
+        {}
+        numa_node_id numa_id;
+        int max_concurrency;
+    };
+#endif /*__TBB_NUMA_SUPPORT*/
 protected:
     //! NULL if not currently initialized.
     internal::arena* my_arena;
@@ -84,11 +133,30 @@ class task_arena_base {
     //! Special settings
     intptr_t my_version_and_traits;
 
+    bool my_initialized;
+
+#if __TBB_NUMA_SUPPORT
+    //! The NUMA node index to which the arena will be attached
+    numa_node_id my_numa_id;
+
+    // Do not access my_numa_id without the following runtime check.
+    // Despite my_numa_id is accesible, it does not exist in task_arena_base on user side
+    // if TBB_PREVIEW_NUMA_SUPPORT macro is not defined by the user. To be sure that
+    // my_numa_id exists in task_arena_base layout we check the traits.
+    // TODO: Consider increasing interface version for task_arena_base instead of this runtime check.
+    numa_node_id numa_id() {
+        return (my_version_and_traits & numa_support_flag) == numa_support_flag ? my_numa_id : automatic;
+    }
+#endif
+
     enum {
         default_flags = 0
 #if __TBB_TASK_GROUP_CONTEXT
         | (task_group_context::default_traits & task_group_context::exact_exception)  // 0 or 1 << 16
         , exact_exception_flag = task_group_context::exact_exception // used to specify flag for context directly
+#endif
+#if __TBB_NUMA_SUPPORT
+        , numa_support_flag = 1
 #endif
     };
 
@@ -99,8 +167,30 @@ class task_arena_base {
 #endif
         , my_max_concurrency(max_concurrency)
         , my_master_slots(reserved_for_masters)
+#if __TBB_NUMA_SUPPORT
+        , my_version_and_traits(default_flags | numa_support_flag)
+#else
         , my_version_and_traits(default_flags)
+#endif
+        , my_initialized(false)
+#if __TBB_NUMA_SUPPORT
+        , my_numa_id(automatic)
+#endif
+        {}
+
+#if __TBB_NUMA_SUPPORT
+    task_arena_base(const constraints& constraints_, unsigned reserved_for_masters)
+        : my_arena(0)
+#if __TBB_TASK_GROUP_CONTEXT
+        , my_context(0)
+#endif
+        , my_max_concurrency(constraints_.max_concurrency)
+        , my_master_slots(reserved_for_masters)
+        , my_version_and_traits(default_flags | numa_support_flag)
+        , my_initialized(false)
+        , my_numa_id(constraints_.numa_id )
         {}
+#endif /*__TBB_NUMA_SUPPORT*/
 
     void __TBB_EXPORTED_METHOD internal_initialize();
     void __TBB_EXPORTED_METHOD internal_terminate();
@@ -118,7 +208,14 @@ class task_arena_base {
 };
 
 #if __TBB_TASK_ISOLATION
-void __TBB_EXPORTED_FUNC isolate_within_arena( delegate_base& d, intptr_t reserved = 0 );
+void __TBB_EXPORTED_FUNC isolate_within_arena( delegate_base& d, intptr_t isolation = 0 );
+
+template<typename R, typename F>
+R isolate_impl(F& f) {
+    delegated_function<F, R> d(f);
+    isolate_within_arena(d);
+    return d.consume_result();
+}
 #endif /* __TBB_TASK_ISOLATION */
 } // namespace internal
 //! @endcond
@@ -130,8 +227,12 @@ void __TBB_EXPORTED_FUNC isolate_within_arena( delegate_base& d, intptr_t reserv
  */
 class task_arena : public internal::task_arena_base {
     friend class tbb::internal::task_scheduler_observer_v3;
+    friend void task::enqueue(task&, task_arena&
+#if __TBB_TASK_PRIORITY
+        , priority_t
+#endif
+    );
     friend int tbb::this_task_arena::max_concurrency();
-    bool my_initialized;
     void mark_initialized() {
         __TBB_ASSERT( my_arena, "task_arena initialization is incomplete" );
 #if __TBB_TASK_GROUP_CONTEXT
@@ -146,6 +247,31 @@ class task_arena : public internal::task_arena_base {
 #endif
     }
 
+    template<typename F>
+    void enqueue_impl( __TBB_FORWARDING_REF(F) f
+#if __TBB_TASK_PRIORITY
+        , priority_t p = priority_t(0)
+#endif
+    ) {
+#if !__TBB_TASK_PRIORITY
+        intptr_t p = 0;
+#endif
+        initialize();
+#if __TBB_TASK_GROUP_CONTEXT
+        internal_enqueue(*new(task::allocate_root(*my_context)) internal::function_task< typename internal::strip<F>::type >(internal::forward<F>(f)), p);
+#else
+        internal_enqueue(*new(task::allocate_root()) internal::function_task< typename internal::strip<F>::type >(internal::forward<F>(f)), p);
+#endif /* __TBB_TASK_GROUP_CONTEXT */
+    }
+
+    template<typename R, typename F>
+    R execute_impl(F& f) {
+        initialize();
+        internal::delegated_function<F, R> d(f);
+        internal_execute(d);
+        return d.consume_result();
+    }
+
 public:
     //! Creates task_arena with certain concurrency limits
     /** Sets up settings only, real construction is deferred till the first method invocation
@@ -155,14 +281,24 @@ class task_arena : public internal::task_arena_base {
      **/
     task_arena(int max_concurrency_ = automatic, unsigned reserved_for_masters = 1)
         : task_arena_base(max_concurrency_, reserved_for_masters)
-        , my_initialized(false)
     {}
 
+#if __TBB_NUMA_SUPPORT
+    //! Creates task arena pinned to certain NUMA node
+    task_arena(const constraints& constraints_, unsigned reserved_for_masters = 1)
+        : task_arena_base(constraints_, reserved_for_masters)
+    {}
+
+    //! Copies settings from another task_arena
+    task_arena(const task_arena &s) // copy settings but not the reference or instance
+        : task_arena_base(constraints(s.my_numa_id, s.my_max_concurrency), s.my_master_slots)
+    {}
+#else
     //! Copies settings from another task_arena
     task_arena(const task_arena &s) // copy settings but not the reference or instance
         : task_arena_base(s.my_max_concurrency, s.my_master_slots)
-        , my_initialized(false)
     {}
+#endif /*__TBB_NUMA_SUPPORT*/
 
     //! Tag class used to indicate the "attaching" constructor
     struct attach {};
@@ -170,7 +306,6 @@ class task_arena : public internal::task_arena_base {
     //! Creates an instance of task_arena attached to the current arena of the thread
     explicit task_arena( attach )
         : task_arena_base(automatic, 1) // use default settings if attach fails
-        , my_initialized(false)
     {
         internal_attach();
         if( my_arena ) my_initialized = true;
@@ -187,7 +322,7 @@ class task_arena : public internal::task_arena_base {
     //! Overrides concurrency level and forces initialization of internal representation
     inline void initialize(int max_concurrency_, unsigned reserved_for_masters = 1) {
         // TODO: decide if this call must be thread-safe
-        __TBB_ASSERT( !my_arena, "Impossible to modify settings of an already initialized task_arena");
+        __TBB_ASSERT(!my_arena, "Impossible to modify settings of an already initialized task_arena");
         if( !my_initialized ) {
             my_max_concurrency = max_concurrency_;
             my_master_slots = reserved_for_masters;
@@ -195,13 +330,26 @@ class task_arena : public internal::task_arena_base {
         }
     }
 
+#if __TBB_NUMA_SUPPORT
+    inline void initialize(constraints constraints_, unsigned reserved_for_masters = 1) {
+        // TODO: decide if this call must be thread-safe
+        __TBB_ASSERT(!my_arena, "Impossible to modify settings of an already initialized task_arena");
+        if( !my_initialized ) {
+            my_numa_id = constraints_.numa_id;
+            my_max_concurrency = constraints_.max_concurrency;
+            my_master_slots = reserved_for_masters;
+            initialize();
+        }
+    }
+#endif /*__TBB_NUMA_SUPPORT*/
+
     //! Attaches this instance to the current arena of the thread
     inline void initialize(attach) {
         // TODO: decide if this call must be thread-safe
-        __TBB_ASSERT( !my_arena, "Impossible to modify settings of an already initialized task_arena");
+        __TBB_ASSERT(!my_arena, "Impossible to modify settings of an already initialized task_arena");
         if( !my_initialized ) {
             internal_attach();
-            if( !my_arena ) internal_initialize();
+            if ( !my_arena ) internal_initialize();
             mark_initialized();
         }
     }
@@ -227,49 +375,62 @@ class task_arena : public internal::task_arena_base {
 
     //! Enqueues a task into the arena to process a functor, and immediately returns.
     //! Does not require the calling thread to join the arena
+
+#if __TBB_CPP11_RVALUE_REF_PRESENT
     template<typename F>
-    void enqueue( const F& f ) {
-        initialize();
-#if __TBB_TASK_GROUP_CONTEXT
-        internal_enqueue( *new( task::allocate_root(*my_context) ) internal::function_task<F>(f), 0 );
+    void enqueue( F&& f ) {
+        enqueue_impl(std::forward<F>(f));
+    }
 #else
-        internal_enqueue( *new( task::allocate_root() ) internal::function_task<F>(f), 0 );
-#endif
+    template<typename F>
+    void enqueue( const F& f ) {
+        enqueue_impl(f);
     }
+#endif
 
 #if __TBB_TASK_PRIORITY
     //! Enqueues a task with priority p into the arena to process a functor f, and immediately returns.
     //! Does not require the calling thread to join the arena
     template<typename F>
-    void enqueue( const F& f, priority_t p ) {
-        __TBB_ASSERT( p == priority_low || p == priority_normal || p == priority_high, "Invalid priority level value" );
-        initialize();
-#if __TBB_TASK_GROUP_CONTEXT
-        internal_enqueue( *new( task::allocate_root(*my_context) ) internal::function_task<F>(f), (intptr_t)p );
+#if __TBB_CPP11_RVALUE_REF_PRESENT
+    __TBB_DEPRECATED void enqueue( F&& f, priority_t p ) {
+#if __TBB_PREVIEW_CRITICAL_TASKS
+        __TBB_ASSERT(p == priority_low || p == priority_normal || p == priority_high
+                     || p == internal::priority_critical, "Invalid priority level value");
 #else
-        internal_enqueue( *new( task::allocate_root() ) internal::function_task<F>(f), (intptr_t)p );
+        __TBB_ASSERT(p == priority_low || p == priority_normal || p == priority_high, "Invalid priority level value");
 #endif
+        enqueue_impl(std::forward<F>(f), p);
     }
+#else
+    __TBB_DEPRECATED void enqueue( const F& f, priority_t p ) {
+#if __TBB_PREVIEW_CRITICAL_TASKS
+        __TBB_ASSERT(p == priority_low || p == priority_normal || p == priority_high
+                     || p == internal::priority_critical, "Invalid priority level value");
+#else
+        __TBB_ASSERT(p == priority_low || p == priority_normal || p == priority_high, "Invalid priority level value");
+#endif
+        enqueue_impl(f,p);
+    }
+#endif
 #endif// __TBB_TASK_PRIORITY
 
-    //! Joins the arena and executes a functor, then returns
+    //! Joins the arena and executes a mutable functor, then returns
     //! If not possible to join, wraps the functor into a task, enqueues it and waits for task completion
     //! Can decrement the arena demand for workers, causing a worker to leave and free a slot to the calling thread
+    //! Since C++11, the method returns the value returned by functor (prior to C++11 it returns void).
     template<typename F>
-    void execute(F& f) {
-        initialize();
-        internal::delegated_function<F> d(f);
-        internal_execute( d );
+    typename internal::return_type_or_void<F>::type execute(F& f) {
+        return execute_impl<typename internal::return_type_or_void<F>::type>(f);
     }
 
-    //! Joins the arena and executes a functor, then returns
+    //! Joins the arena and executes a constant functor, then returns
     //! If not possible to join, wraps the functor into a task, enqueues it and waits for task completion
     //! Can decrement the arena demand for workers, causing a worker to leave and free a slot to the calling thread
+    //! Since C++11, the method returns the value returned by functor (prior to C++11 it returns void).
     template<typename F>
-    void execute(const F& f) {
-        initialize();
-        internal::delegated_function<const F> d(f);
-        internal_execute( d );
+    typename internal::return_type_or_void<F>::type execute(const F& f) {
+        return execute_impl<typename internal::return_type_or_void<F>::type>(f);
     }
 
 #if __TBB_EXTRA_DEBUG
@@ -295,26 +456,30 @@ class task_arena : public internal::task_arena_base {
     }
 };
 
-#if __TBB_TASK_ISOLATION
 namespace this_task_arena {
+#if __TBB_TASK_ISOLATION
+    //! Executes a mutable functor in isolation within the current task arena.
+    //! Since C++11, the method returns the value returned by functor (prior to C++11 it returns void).
     template<typename F>
-    void isolate( const F& f ) {
-        internal::delegated_function<const F> d(f);
-        internal::isolate_within_arena( d );
+    typename internal::return_type_or_void<F>::type isolate(F& f) {
+        return internal::isolate_impl<typename internal::return_type_or_void<F>::type>(f);
     }
-}
-#endif /* __TBB_TASK_ISOLATION */
 
+    //! Executes a constant functor in isolation within the current task arena.
+    //! Since C++11, the method returns the value returned by functor (prior to C++11 it returns void).
+    template<typename F>
+    typename internal::return_type_or_void<F>::type isolate(const F& f) {
+        return internal::isolate_impl<typename internal::return_type_or_void<F>::type>(f);
+    }
+#endif /* __TBB_TASK_ISOLATION */
+} // namespace this_task_arena
 } // namespace interfaceX
 
 using interface7::task_arena;
-#if __TBB_TASK_ISOLATION
+
 namespace this_task_arena {
     using namespace interface7::this_task_arena;
-}
-#endif /* __TBB_TASK_ISOLATION */
 
-namespace this_task_arena {
     //! Returns the index, aka slot number, of the calling thread in its current arena
     inline int current_thread_index() {
         int idx = tbb::task_arena::current_thread_index();
@@ -325,9 +490,22 @@ namespace this_task_arena {
     inline int max_concurrency() {
         return tbb::task_arena::internal_max_concurrency(NULL);
     }
-
 } // namespace this_task_arena
 
+//! Enqueue task in task_arena
+#if __TBB_TASK_PRIORITY
+void task::enqueue( task& t, task_arena& arena, priority_t p ) {
+#else
+void task::enqueue( task& t, task_arena& arena ) {
+    intptr_t p = 0;
+#endif
+    arena.initialize();
+    //! Note: the context of the task may differ from the context instantiated by task_arena
+    arena.internal_enqueue(t, p);
+}
 } // namespace tbb
 
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_task_arena_H_include_area
+
 #endif /* __TBB_task_arena_H */
diff --git a/inst/include/tbb/task_group.h b/inst/include/tbb/task_group.h
index bf6922b9..f090d3a2 100644
--- a/inst/include/tbb/task_group.h
+++ b/inst/include/tbb/task_group.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,17 +12,20 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_task_group_H
 #define __TBB_task_group_H
 
+#define __TBB_task_group_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #include "task.h"
 #include "tbb_exception.h"
+#include "internal/_template_helpers.h"
+#if TBB_PREVIEW_ISOLATED_TASK_GROUP && __TBB_TASK_ISOLATION
+#include "task_arena.h"
+#endif
 
 #if __TBB_TASK_GROUP_CONTEXT
 
@@ -34,12 +37,18 @@ namespace internal {
 
 class task_group;
 class structured_task_group;
+#if TBB_PREVIEW_ISOLATED_TASK_GROUP && __TBB_TASK_ISOLATION
+class isolated_task_group;
+#endif
 
 template<typename F>
 class task_handle : internal::no_assign {
     template<typename _F> friend class internal::task_handle_task;
     friend class task_group;
     friend class structured_task_group;
+#if TBB_PREVIEW_ISOLATED_TASK_GROUP && __TBB_TASK_ISOLATION
+    friend class isolated_task_group;
+#endif
 
     static const intptr_t scheduled = 0x1;
 
@@ -54,6 +63,9 @@ class task_handle : internal::no_assign {
     }
 public:
     task_handle( const F& f ) : my_func(f), my_state(0) {}
+#if __TBB_CPP11_RVALUE_REF_PRESENT
+    task_handle( F&& f ) : my_func( std::move(f)), my_state(0) {}
+#endif
 
     void operator() () const { my_func(); }
 };
@@ -78,26 +90,38 @@ class task_handle_task : public task {
 };
 
 class task_group_base : internal::no_copy {
+    class ref_count_guard : internal::no_copy {
+        task& my_task;
+    public:
+        ref_count_guard(task& t) : my_task(t) {
+            my_task.increment_ref_count();
+        }
+        ~ref_count_guard() {
+            my_task.decrement_ref_count();
+        }
+    };
 protected:
     empty_task* my_root;
     task_group_context my_context;
 
-    task& owner () { return *my_root; }
-
     template<typename F>
     task_group_status internal_run_and_wait( F& f ) {
         __TBB_TRY {
-            if ( !my_context.is_group_execution_cancelled() )
+            if ( !my_context.is_group_execution_cancelled() ) {
+                // We need to increase the reference count of the root task to notify waiters that
+                // this task group has some work in progress.
+                ref_count_guard guard(*my_root);
                 f();
+            }
         } __TBB_CATCH( ... ) {
             my_context.register_pending_exception();
         }
         return wait();
     }
 
-    template<typename F, typename Task>
-    void internal_run( F& f ) {
-        owner().spawn( *new( owner().allocate_additional_child_of(*my_root) ) Task(f) );
+    template<typename Task, typename F>
+    task* prepare_task( __TBB_FORWARDING_REF(F) f ) {
+        return new( task::allocate_additional_child_of(*my_root) ) Task( internal::forward<F>(f) );
     }
 
 public:
@@ -110,7 +134,11 @@ class task_group_base : internal::no_copy {
 
     ~task_group_base() __TBB_NOEXCEPT(false) {
         if( my_root->ref_count() > 1 ) {
+#if __TBB_CPP17_UNCAUGHT_EXCEPTIONS_PRESENT
+            bool stack_unwinding_in_progress = std::uncaught_exceptions() > 0;
+#else
             bool stack_unwinding_in_progress = std::uncaught_exception();
+#endif
             // Always attempt to do proper cleanup to avoid inevitable memory corruption
             // in case of missing wait (for the sake of better testability & debuggability)
             if ( !is_canceling() )
@@ -132,7 +160,7 @@ class task_group_base : internal::no_copy {
 
     template<typename F>
     void run( task_handle<F>& h ) {
-        internal_run< task_handle<F>, internal::task_handle_task<F> >( h );
+        task::spawn( *prepare_task< internal::task_handle_task<F> >(h) );
     }
 
     task_group_status wait() {
@@ -168,31 +196,40 @@ class task_group : public internal::task_group_base {
 #if __SUNPRO_CC
     template<typename F>
     void run( task_handle<F>& h ) {
-        internal_run< task_handle<F>, internal::task_handle_task<F> >( h );
+        internal_run< internal::task_handle_task<F> >( h );
     }
 #else
     using task_group_base::run;
 #endif
 
+#if __TBB_CPP11_RVALUE_REF_PRESENT
     template<typename F>
-    void run( const F& f ) {
-        internal_run< const F, internal::function_task<F> >( f );
+    void run( F&& f ) {
+        task::spawn( *prepare_task< internal::function_task< typename internal::strip<F>::type > >(std::forward<F>(f)) );
     }
+#else
+    template<typename F>
+    void run(const F& f) {
+        task::spawn( *prepare_task< internal::function_task<F> >(f) );
+    }
+#endif
 
     template<typename F>
     task_group_status run_and_wait( const F& f ) {
         return internal_run_and_wait<const F>( f );
     }
 
+    // TODO: add task_handle rvalues support
     template<typename F>
     task_group_status run_and_wait( task_handle<F>& h ) {
-      h.mark_scheduled();
-      return internal_run_and_wait< task_handle<F> >( h );
+        h.mark_scheduled();
+        return internal_run_and_wait< task_handle<F> >( h );
     }
 }; // class task_group
 
-class structured_task_group : public internal::task_group_base {
+class __TBB_DEPRECATED structured_task_group : public internal::task_group_base {
 public:
+    // TODO: add task_handle rvalues support
     template<typename F>
     task_group_status run_and_wait ( task_handle<F>& h ) {
         h.mark_scheduled();
@@ -206,18 +243,124 @@ class structured_task_group : public internal::task_group_base {
     }
 }; // class structured_task_group
 
+#if TBB_PREVIEW_ISOLATED_TASK_GROUP && __TBB_TASK_ISOLATION
+namespace internal {
+    using interface7::internal::delegate_base;
+    using interface7::internal::isolate_within_arena;
+
+    class spawn_delegate : public delegate_base {
+        task* task_to_spawn;
+        void operator()() const __TBB_override {
+            task::spawn(*task_to_spawn);
+        }
+    public:
+        spawn_delegate(task* a_task) : task_to_spawn(a_task) {}
+    };
+
+    class wait_delegate : public delegate_base {
+        void operator()() const __TBB_override {
+            status = tg.wait();
+        }
+    protected:
+        task_group& tg;
+        task_group_status& status;
+    public:
+        wait_delegate(task_group& a_group, task_group_status& tgs)
+            : tg(a_group), status(tgs) {}
+    };
+
+    template<typename F>
+    class run_wait_delegate : public wait_delegate {
+        F& func;
+        void operator()() const __TBB_override {
+            status = tg.run_and_wait( func );
+        }
+    public:
+        run_wait_delegate(task_group& a_group, F& a_func, task_group_status& tgs)
+            : wait_delegate(a_group, tgs), func(a_func) {}
+    };
+} // namespace internal
+
+class isolated_task_group : public task_group {
+    intptr_t this_isolation() {
+        return reinterpret_cast<intptr_t>(this);
+    }
+public:
+    isolated_task_group () : task_group() {}
+
+#if __TBB_CPP11_RVALUE_REF_PRESENT
+    template<typename F>
+    void run( F&& f ) {
+        internal::spawn_delegate sd(
+            prepare_task< internal::function_task< typename internal::strip<F>::type > >(std::forward<F>(f))
+        );
+        internal::isolate_within_arena( sd, this_isolation() );
+    }
+#else
+    template<typename F>
+    void run(const F& f) {
+        internal::spawn_delegate sd( prepare_task< internal::function_task<F> >(f) );
+        internal::isolate_within_arena( sd, this_isolation() );
+    }
+#endif
+
+    template<typename F>
+    task_group_status run_and_wait( const F& f ) {
+        task_group_status result = not_complete;
+        internal::run_wait_delegate< const F > rwd( *this, f, result );
+        internal::isolate_within_arena( rwd, this_isolation() );
+        __TBB_ASSERT( result!=not_complete, "premature exit from wait?" );
+        return result;
+    }
+
+    // TODO: add task_handle rvalues support
+    template<typename F>
+    void run( task_handle<F>& h ) {
+        internal::spawn_delegate sd( prepare_task< internal::task_handle_task<F> >(h) );
+        internal::isolate_within_arena( sd, this_isolation() );
+    }
+
+    template<typename F>
+    task_group_status run_and_wait ( task_handle<F>& h ) {
+        task_group_status result = not_complete;
+        internal::run_wait_delegate< task_handle<F> > rwd( *this, h, result );
+        internal::isolate_within_arena( rwd, this_isolation() );
+        __TBB_ASSERT( result!=not_complete, "premature exit from wait?" );
+        return result;
+    }
+
+    task_group_status wait() {
+        task_group_status result = not_complete;
+        internal::wait_delegate wd( *this, result );
+        internal::isolate_within_arena( wd, this_isolation() );
+        __TBB_ASSERT( result!=not_complete, "premature exit from wait?" );
+        return result;
+    }
+}; // class isolated_task_group
+#endif // TBB_PREVIEW_ISOLATED_TASK_GROUP && __TBB_TASK_ISOLATION
+
 inline
 bool is_current_task_group_canceling() {
     return task::self().is_cancelled();
 }
 
+#if __TBB_CPP11_RVALUE_REF_PRESENT
+template<class F>
+task_handle< typename internal::strip<F>::type > make_task( F&& f ) {
+    return task_handle< typename internal::strip<F>::type >( std::forward<F>(f) );
+}
+#else
 template<class F>
 task_handle<F> make_task( const F& f ) {
     return task_handle<F>( f );
 }
+#endif /* __TBB_CPP11_RVALUE_REF_PRESENT */
 
 } // namespace tbb
 
 #endif /* __TBB_TASK_GROUP_CONTEXT */
 
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_task_group_H_include_area
+
 #endif /* __TBB_task_group_H */
diff --git a/inst/include/tbb/task_scheduler_init.h b/inst/include/tbb/task_scheduler_init.h
index 928e7a4e..687bba1d 100644
--- a/inst/include/tbb/task_scheduler_init.h
+++ b/inst/include/tbb/task_scheduler_init.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,15 +12,25 @@
     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 "internal/_deprecated_header_message_guard.h"
 
+#if !defined(__TBB_show_deprecation_message_task_scheduler_init_H) && defined(__TBB_show_deprecated_header_message)
+#define  __TBB_show_deprecation_message_task_scheduler_init_H
+#pragma message("TBB Warning: tbb/task_scheduler_init.h is deprecated. For details, please see Deprecated Features appendix in the TBB reference manual.")
+#endif
 
-
-*/
+#if defined(__TBB_show_deprecated_header_message)
+#undef __TBB_show_deprecated_header_message
+#endif
 
 #ifndef __TBB_task_scheduler_init_H
 #define __TBB_task_scheduler_init_H
 
+#define __TBB_task_scheduler_init_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #include "tbb_stddef.h"
 #include "limits.h"
 #if __TBB_SUPPORTS_WORKERS_WAITING_IN_TERMINATE
@@ -53,7 +63,7 @@ namespace internal {
     and will persist until this thread exits. Default concurrency level is defined
     as described in task_scheduler_init::initialize().
     @ingroup task_scheduling */
-class task_scheduler_init: internal::no_copy {
+class __TBB_DEPRECATED_IN_VERBOSE_MODE task_scheduler_init: internal::no_copy {
     enum ExceptionPropagationMode {
         propagation_mode_exact = 1u,
         propagation_mode_captured = 2u,
@@ -136,8 +146,8 @@ class task_scheduler_init: internal::no_copy {
     /** Result returned by this method does not depend on whether the scheduler
         has already been initialized.
 
-        Because tbb 2.0 does not support blocking tasks yet, you may use this method
-        to boost the number of threads in the tbb's internal pool, if your tasks are
+        Because TBB 2.0 does not support blocking tasks yet, you may use this method
+        to boost the number of threads in the TBB's internal pool, if your tasks are
         doing I/O operations. The optimal number of additional threads depends on how
         much time your tasks spend in the blocked state.
 
@@ -158,4 +168,7 @@ class task_scheduler_init: internal::no_copy {
 
 } // namespace tbb
 
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_task_scheduler_init_H_include_area
+
 #endif /* __TBB_task_scheduler_init_H */
diff --git a/inst/include/tbb/task_scheduler_observer.h b/inst/include/tbb/task_scheduler_observer.h
index 5586ad4f..1bb93636 100644
--- a/inst/include/tbb/task_scheduler_observer.h
+++ b/inst/include/tbb/task_scheduler_observer.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,17 +12,16 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_task_scheduler_observer_H
 #define __TBB_task_scheduler_observer_H
 
+#define __TBB_task_scheduler_observer_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #include "atomic.h"
-#if __TBB_ARENA_OBSERVER || __TBB_SLEEP_PERMISSION
+#if __TBB_ARENA_OBSERVER
 #include "task_arena.h"
 #endif
 
@@ -88,7 +87,7 @@ class task_scheduler_observer_v3 {
 
 } // namespace internal
 
-#if __TBB_ARENA_OBSERVER || __TBB_SLEEP_PERMISSION
+#if __TBB_ARENA_OBSERVER
 namespace interface6 {
 class task_scheduler_observer : public internal::task_scheduler_observer_v3 {
     friend class internal::task_scheduler_observer_v3;
@@ -149,26 +148,19 @@ class task_scheduler_observer : public internal::task_scheduler_observer_v3 {
         }
         internal::task_scheduler_observer_v3::observe(state);
     }
-
-#if  __TBB_SLEEP_PERMISSION
-    //! Return commands for may_sleep()
-    enum { keep_awake = false, allow_sleep = true };
-
-    //! The callback can be invoked by a worker thread before it goes to sleep.
-    /** If it returns false ('keep_awake'), the thread will keep spinning and looking for work.
-        It will not be called for master threads. **/
-    virtual bool may_sleep() { return allow_sleep; }
-#endif /*__TBB_SLEEP_PERMISSION*/
 };
 
 } //namespace interface6
 using interface6::task_scheduler_observer;
-#else /*__TBB_ARENA_OBSERVER || __TBB_SLEEP_PERMISSION*/
+#else /*__TBB_ARENA_OBSERVER*/
 typedef tbb::internal::task_scheduler_observer_v3 task_scheduler_observer;
-#endif /*__TBB_ARENA_OBSERVER || __TBB_SLEEP_PERMISSION*/
+#endif /*__TBB_ARENA_OBSERVER*/
 
 } // namespace tbb
 
 #endif /* __TBB_SCHEDULER_OBSERVER */
 
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_task_scheduler_observer_H_include_area
+
 #endif /* __TBB_task_scheduler_observer_H */
diff --git a/inst/include/tbb/tbb.h b/inst/include/tbb/tbb.h
index 5e385ea2..f06ec5a3 100644
--- a/inst/include/tbb/tbb.h
+++ b/inst/include/tbb/tbb.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,18 +12,21 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_tbb_H
 #define __TBB_tbb_H
 
+#if (!defined(TBB_SUPPRESS_DEPRECATED_MESSAGES) || (TBB_SUPPRESS_DEPRECATED_MESSAGES == 0)) && !defined(__TBB_INTERNAL_INCLUDES_DEPRECATION_MESSAGE)
+#pragma message("TBB Warning: tbb.h contains deprecated functionality. For details, please see Deprecated Features appendix in the TBB reference manual.")
+#endif
+
+#define __TBB_tbb_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 /**
     This header bulk-includes declarations or definitions of all the functionality
-    provided by TBB (save for malloc dependent headers).
+    provided by TBB (save for tbbmalloc and 3rd party dependent headers).
 
     If you use only a few TBB constructs, consider including specific headers only.
     Any header listed below can be included independently of others.
@@ -37,6 +40,9 @@
 #include "blocked_range.h"
 #include "blocked_range2d.h"
 #include "blocked_range3d.h"
+#if TBB_PREVIEW_BLOCKED_RANGE_ND
+#include "blocked_rangeNd.h"
+#endif
 #include "cache_aligned_allocator.h"
 #include "combinable.h"
 #include "concurrent_hash_map.h"
@@ -47,13 +53,16 @@
 #include "concurrent_queue.h"
 #include "concurrent_unordered_map.h"
 #include "concurrent_unordered_set.h"
+#if TBB_PREVIEW_CONCURRENT_ORDERED_CONTAINERS
+#include "concurrent_map.h"
+#include "concurrent_set.h"
+#endif
 #include "concurrent_vector.h"
 #include "critical_section.h"
 #include "enumerable_thread_specific.h"
 #include "flow_graph.h"
-#if TBB_PREVIEW_GLOBAL_CONTROL
 #include "global_control.h"
-#endif
+#include "iterators.h"
 #include "mutex.h"
 #include "null_mutex.h"
 #include "null_rw_mutex.h"
@@ -82,4 +91,7 @@
 #include "tbb_thread.h"
 #include "tick_count.h"
 
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_tbb_H_include_area
+
 #endif /* __TBB_tbb_H */
diff --git a/inst/include/tbb/tbb_allocator.h b/inst/include/tbb/tbb_allocator.h
index a3f1ef0c..ac0d1a6b 100644
--- a/inst/include/tbb/tbb_allocator.h
+++ b/inst/include/tbb/tbb_allocator.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_tbb_allocator_H
@@ -26,19 +22,8 @@
 #if __TBB_ALLOCATOR_CONSTRUCT_VARIADIC
  #include <utility> // std::forward
 #endif
-
-#if !TBB_USE_EXCEPTIONS && _MSC_VER
-    // Suppress "C++ exception handler used, but unwind semantics are not enabled" warning in STL headers
-    #pragma warning (push)
-    #pragma warning (disable: 4530)
-#endif
-
 #include <cstring>
 
-#if !TBB_USE_EXCEPTIONS && _MSC_VER
-    #pragma warning (pop)
-#endif
-
 namespace tbb {
 
 //! @cond INTERNAL
@@ -185,7 +170,7 @@ class zero_allocator : public Allocator<T>
 
     pointer allocate(const size_type n, const void *hint = 0 ) {
         pointer ptr = base_allocator_type::allocate( n, hint );
-        std::memset( (void*) ptr, 0, n * sizeof(value_type) );
+        std::memset( static_cast<void*>(ptr), 0, n * sizeof(value_type) );
         return ptr;
     }
 };
diff --git a/inst/include/tbb/tbb_config.h b/inst/include/tbb/tbb_config.h
index bdc8dcb9..7a8d06a0 100644
--- a/inst/include/tbb/tbb_config.h
+++ b/inst/include/tbb/tbb_config.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_tbb_config_H
@@ -34,29 +30,32 @@
  */
 #define __TBB_TODO 0
 
-/*Check which standard library we use on macOS*.*/
-/*__TBB_SYMBOL is defined only while processing exported symbols list where C++ is not allowed.*/
-#if !defined(__TBB_SYMBOL) && (__APPLE__ || __ANDROID__)
+/* Check which standard library we use. */
+/* __TBB_SYMBOL is defined only while processing exported symbols list where C++ is not allowed. */
+#if !defined(__TBB_SYMBOL) && !__TBB_CONFIG_PREPROC_ONLY
     #include <cstddef>
 #endif
 
-// note that when ICC or Clang is in use, __TBB_GCC_VERSION might not fully match
+// Note that when ICC or Clang is in use, __TBB_GCC_VERSION might not fully match
 // the actual GCC version on the system.
 #define __TBB_GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
 
-// Since GNU libstdc++ does not have a convenient macro for its version,
-// we rely on the version of GCC or the user-specified macro below.
-// The format of TBB_USE_GLIBCXX_VERSION should match the __TBB_GCC_VERSION above,
-// e.g. it should be set to 40902 for libstdc++ coming with GCC 4.9.2.
-#ifdef TBB_USE_GLIBCXX_VERSION
+// Prior to GCC 7, GNU libstdc++ did not have a convenient version macro.
+// Therefore we use different ways to detect its version.
+#if defined(TBB_USE_GLIBCXX_VERSION) && !defined(_GLIBCXX_RELEASE)
+// The version is explicitly specified in our public TBB_USE_GLIBCXX_VERSION macro.
+// Its format should match the __TBB_GCC_VERSION above, e.g. 70301 for libstdc++ coming with GCC 7.3.1.
 #define __TBB_GLIBCXX_VERSION TBB_USE_GLIBCXX_VERSION
-#else
+#elif _GLIBCXX_RELEASE && _GLIBCXX_RELEASE != __GNUC__
+// Reported versions of GCC and libstdc++ do not match; trust the latter
+#define __TBB_GLIBCXX_VERSION (_GLIBCXX_RELEASE*10000)
+#elif __GLIBCPP__ || __GLIBCXX__
+// The version macro is not defined or matches the GCC version; use __TBB_GCC_VERSION
 #define __TBB_GLIBCXX_VERSION __TBB_GCC_VERSION
-//TODO: analyze __GLIBCXX__ instead of __TBB_GCC_VERSION ?
 #endif
 
 #if __clang__
-    /**according to clang documentation version can be vendor specific **/
+    // according to clang documentation, version can be vendor specific
     #define __TBB_CLANG_VERSION (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__)
 #endif
 
@@ -65,6 +64,16 @@
     #define __TBB_IOS 1
 #endif
 
+#if __APPLE__
+    #if __INTEL_COMPILER && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ > 1099 \
+                         && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 101000
+        // ICC does not correctly set the macro if -mmacosx-min-version is not specified
+        #define __TBB_MACOS_TARGET_VERSION  (100000 + 10*(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ - 1000))
+    #else
+        #define __TBB_MACOS_TARGET_VERSION  __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__
+    #endif
+#endif
+
 /** Preprocessor symbols to determine HW architecture **/
 
 #if _WIN32||_WIN64
@@ -108,6 +117,14 @@
     #define __INTEL_COMPILER 1210
 #endif
 
+#if __clang__ && !__INTEL_COMPILER
+#define __TBB_USE_OPTIONAL_RTTI __has_feature(cxx_rtti)
+#elif defined(_CPPRTTI)
+#define __TBB_USE_OPTIONAL_RTTI 1
+#else
+#define __TBB_USE_OPTIONAL_RTTI (__GXX_RTTI || __RTTI || __INTEL_RTTI__)
+#endif
+
 #if __TBB_GCC_VERSION >= 40400 && !defined(__INTEL_COMPILER)
     /** warning suppression pragmas available in GCC since 4.4 **/
     #define __TBB_GCC_WARNING_SUPPRESSION_PRESENT 1
@@ -124,7 +141,17 @@
    support added.
  */
 
-/** C++11 mode detection macros for Intel(R) C++ compiler (enabled by -std=c++XY option):
+/**
+    __TBB_CPP11_PRESENT macro indicates that the compiler supports vast majority of C++11 features.
+    Depending on the compiler, some features might still be unsupported or work incorrectly.
+    Use it when enabling C++11 features individually is not practical, and be aware that
+    some "good enough" compilers might be excluded. **/
+#define __TBB_CPP11_PRESENT (__cplusplus >= 201103L || _MSC_VER >= 1900)
+
+#define __TBB_CPP17_FALLTHROUGH_PRESENT (__cplusplus >= 201703L)
+#define __TBB_FALLTHROUGH_PRESENT       (__TBB_GCC_VERSION >= 70000 && !__INTEL_COMPILER)
+
+/** C++11 mode detection macros for Intel(R) C++ Compiler (enabled by -std=c++XY option):
     __INTEL_CXX11_MODE__ for version >=13.0 (not available for ICC 15.0 if -std=c++14 is used),
     __STDC_HOSTED__ for version >=12.0 (useful only on Windows),
     __GXX_EXPERIMENTAL_CXX0X__ for version >=12.0 on Linux and macOS. **/
@@ -133,16 +160,9 @@
     #define __INTEL_CXX11_MODE__ (__GXX_EXPERIMENTAL_CXX0X__ || (_MSC_VER && __STDC_HOSTED__))
 #endif
 
-// Intel(R) C++ Compiler offloading API to the Intel(R) Graphics Technology presence macro
-// TODO: add support for ICC 15.00 _GFX_enqueue API and then decrease Intel compiler supported version
-// TODO: add linux support and restict it with (__linux__ && __TBB_x86_64 && !__ANDROID__) macro
-#if __INTEL_COMPILER >= 1600 && _WIN32
-#define __TBB_GFX_PRESENT 1
-#endif
-
 #if __INTEL_COMPILER && (!_MSC_VER || __INTEL_CXX11_MODE__)
     //  On Windows, C++11 features supported by Visual Studio 2010 and higher are enabled by default,
-    //  so in absence of /Qstd= use MSVC branch for __TBB_CPP11_* detection.
+    //  so in absence of /Qstd= use MSVC branch for feature detection.
     //  On other platforms, no -std= means C++03.
 
     #define __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT          (__INTEL_CXX11_MODE__ && __VARIADIC_TEMPLATES)
@@ -169,14 +189,7 @@
     #endif
     #define __TBB_STATIC_ASSERT_PRESENT                     (__INTEL_CXX11_MODE__ || _MSC_VER >= 1600)
     #define __TBB_CPP11_TUPLE_PRESENT                       (_MSC_VER >= 1600 || __GXX_EXPERIMENTAL_CXX0X__ && (__TBB_GLIBCXX_VERSION >= 40300 || _LIBCPP_VERSION))
-    #if (__clang__ && __INTEL_COMPILER > 1400)
-        /* Older versions of Intel Compiler do not have __has_include */
-        #if (__has_feature(__cxx_generalized_initializers__) && __has_include(<initializer_list>))
-            #define __TBB_INITIALIZER_LISTS_PRESENT         1
-        #endif
-    #else
-        #define __TBB_INITIALIZER_LISTS_PRESENT             (__INTEL_CXX11_MODE__ && __INTEL_COMPILER >= 1400 && (_MSC_VER >= 1800 || __TBB_GLIBCXX_VERSION >= 40400 || _LIBCPP_VERSION))
-    #endif
+    #define __TBB_INITIALIZER_LISTS_PRESENT                 (__INTEL_CXX11_MODE__ && __INTEL_COMPILER >= 1400 && (_MSC_VER >= 1800 || __TBB_GLIBCXX_VERSION >= 40400 || _LIBCPP_VERSION))
     #define __TBB_CONSTEXPR_PRESENT                         (__INTEL_CXX11_MODE__ && __INTEL_COMPILER >= 1400)
     #define __TBB_DEFAULTED_AND_DELETED_FUNC_PRESENT        (__INTEL_CXX11_MODE__ && __INTEL_COMPILER >= 1200)
     /** ICC seems to disable support of noexcept event in c++11 when compiling in compatibility mode for gcc <4.6 **/
@@ -189,19 +202,19 @@
     #define __TBB_OVERRIDE_PRESENT                          (__INTEL_CXX11_MODE__ && __INTEL_COMPILER >= 1400)
     #define __TBB_ALIGNAS_PRESENT                           (__INTEL_CXX11_MODE__ && __INTEL_COMPILER >= 1500)
     #define __TBB_CPP11_TEMPLATE_ALIASES_PRESENT            (__INTEL_CXX11_MODE__ && __INTEL_COMPILER >= 1210)
+    #define __TBB_CPP14_INTEGER_SEQUENCE_PRESENT            (__cplusplus >= 201402L)
+    #define __TBB_CPP14_VARIABLE_TEMPLATES_PRESENT          (__cplusplus >= 201402L)
+    #define __TBB_CPP17_DEDUCTION_GUIDES_PRESENT            (__INTEL_COMPILER > 1910) // a future version
+    #define __TBB_CPP17_INVOKE_RESULT_PRESENT               (__cplusplus >= 201703L)
 #elif __clang__
 /** TODO: these options need to be rechecked **/
-/** on macOS the only way to get C++11 is to use clang. For library features (e.g. exception_ptr) libc++ is also
- *  required. So there is no need to check GCC version for clang**/
     #define __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT          __has_feature(__cxx_variadic_templates__)
     #define __TBB_CPP11_RVALUE_REF_PRESENT                  (__has_feature(__cxx_rvalue_references__) && (_LIBCPP_VERSION || __TBB_GLIBCXX_VERSION >= 40500))
     #define __TBB_IMPLICIT_MOVE_PRESENT                     __has_feature(cxx_implicit_moves)
 /** TODO: extend exception_ptr related conditions to cover libstdc++ **/
     #define __TBB_EXCEPTION_PTR_PRESENT                     (__cplusplus >= 201103L && (_LIBCPP_VERSION || __TBB_GLIBCXX_VERSION >= 40600))
     #define __TBB_STATIC_ASSERT_PRESENT                     __has_feature(__cxx_static_assert__)
-    /**Clang (preprocessor) has problems with dealing with expression having __has_include in #ifs
-     * used inside C++ code. (At least version that comes with OS X 10.8 : Apple LLVM version 4.2 (clang-425.0.28) (based on LLVM 3.2svn)) **/
-    #if (__GXX_EXPERIMENTAL_CXX0X__ && __has_include(<tuple>))
+    #if (__cplusplus >= 201103L && __has_include(<tuple>))
         #define __TBB_CPP11_TUPLE_PRESENT                   1
     #endif
     #if (__has_feature(__cxx_generalized_initializers__) && __has_include(<initializer_list>))
@@ -219,6 +232,10 @@
     #define __TBB_OVERRIDE_PRESENT                          __has_feature(cxx_override_control)
     #define __TBB_ALIGNAS_PRESENT                           __has_feature(cxx_alignas)
     #define __TBB_CPP11_TEMPLATE_ALIASES_PRESENT            __has_feature(cxx_alias_templates)
+    #define __TBB_CPP14_INTEGER_SEQUENCE_PRESENT            (__cplusplus >= 201402L)
+    #define __TBB_CPP14_VARIABLE_TEMPLATES_PRESENT          (__has_feature(cxx_variable_templates))
+    #define __TBB_CPP17_DEDUCTION_GUIDES_PRESENT            (__has_feature(__cpp_deduction_guides))
+    #define __TBB_CPP17_INVOKE_RESULT_PRESENT               (__has_feature(__cpp_lib_is_invocable))
 #elif __GNUC__
     #define __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT          __GXX_EXPERIMENTAL_CXX0X__
     #define __TBB_CPP11_VARIADIC_FIXED_LENGTH_EXP_PRESENT   (__GXX_EXPERIMENTAL_CXX0X__ && __TBB_GCC_VERSION >= 40700)
@@ -243,8 +260,13 @@
     #define __TBB_OVERRIDE_PRESENT                          (__GXX_EXPERIMENTAL_CXX0X__ && __TBB_GCC_VERSION >= 40700)
     #define __TBB_ALIGNAS_PRESENT                           (__GXX_EXPERIMENTAL_CXX0X__ && __TBB_GCC_VERSION >= 40800)
     #define __TBB_CPP11_TEMPLATE_ALIASES_PRESENT            (__GXX_EXPERIMENTAL_CXX0X__ && __TBB_GCC_VERSION >= 40700)
+    #define __TBB_CPP14_INTEGER_SEQUENCE_PRESENT            (__cplusplus >= 201402L     && __TBB_GCC_VERSION >= 50000)
+    #define __TBB_CPP14_VARIABLE_TEMPLATES_PRESENT          (__cplusplus >= 201402L     && __TBB_GCC_VERSION >= 50000)
+    #define __TBB_CPP17_DEDUCTION_GUIDES_PRESENT            (__cpp_deduction_guides >= 201606L)
+    #define __TBB_CPP17_INVOKE_RESULT_PRESENT               (__cplusplus >= 201703L     && __TBB_GCC_VERSION >= 70000)
 #elif _MSC_VER
-    // These definitions are also used with Intel Compiler in "default" mode; see a comment above.
+    // These definitions are also used with Intel C++ Compiler in "default" mode (__INTEL_CXX11_MODE__ == 0);
+    // see a comment in "__INTEL_COMPILER" section above.
 
     #define __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT          (_MSC_VER >= 1800)
     // Contains a workaround for ICC 13
@@ -265,47 +287,71 @@
     #define __TBB_OVERRIDE_PRESENT                          (_MSC_VER >= 1700)
     #define __TBB_ALIGNAS_PRESENT                           (_MSC_VER >= 1900)
     #define __TBB_CPP11_TEMPLATE_ALIASES_PRESENT            (_MSC_VER >= 1800)
+    #define __TBB_CPP14_INTEGER_SEQUENCE_PRESENT            (_MSC_VER >= 1900)
+    /* Variable templates are supported in VS2015 Update 2 or later */
+    #define __TBB_CPP14_VARIABLE_TEMPLATES_PRESENT          (_MSC_FULL_VER >= 190023918 && (!__INTEL_COMPILER || __INTEL_COMPILER >= 1700))
+    #define __TBB_CPP17_DEDUCTION_GUIDES_PRESENT            (_MSVC_LANG >= 201703L && _MSC_VER >= 1914)
+    #define __TBB_CPP17_INVOKE_RESULT_PRESENT               (_MSVC_LANG >= 201703L && _MSC_VER >= 1911)
 #else
-    #define __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT          0
-    #define __TBB_CPP11_RVALUE_REF_PRESENT                  0
-    #define __TBB_IMPLICIT_MOVE_PRESENT                     0
-    #define __TBB_EXCEPTION_PTR_PRESENT                     0
-    #define __TBB_STATIC_ASSERT_PRESENT                     0
-    #define __TBB_CPP11_TUPLE_PRESENT                       0
-    #define __TBB_INITIALIZER_LISTS_PRESENT                 0
-    #define __TBB_CONSTEXPR_PRESENT                         0
-    #define __TBB_DEFAULTED_AND_DELETED_FUNC_PRESENT        0
-    #define __TBB_NOEXCEPT_PRESENT                          0
-    #define __TBB_CPP11_STD_BEGIN_END_PRESENT               0
-    #define __TBB_CPP11_AUTO_PRESENT                        0
-    #define __TBB_CPP11_DECLTYPE_PRESENT                    0
-    #define __TBB_CPP11_LAMBDAS_PRESENT                     0
-    #define __TBB_CPP11_DEFAULT_FUNC_TEMPLATE_ARGS_PRESENT  0
-    #define __TBB_OVERRIDE_PRESENT                          0
-    #define __TBB_ALIGNAS_PRESENT                           0
-    #define __TBB_CPP11_TEMPLATE_ALIASES_PRESENT            0
+    #define __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT          __TBB_CPP11_PRESENT
+    #define __TBB_CPP11_RVALUE_REF_PRESENT                  __TBB_CPP11_PRESENT
+    #define __TBB_IMPLICIT_MOVE_PRESENT                     __TBB_CPP11_PRESENT
+    #define __TBB_EXCEPTION_PTR_PRESENT                     __TBB_CPP11_PRESENT
+    #define __TBB_STATIC_ASSERT_PRESENT                     __TBB_CPP11_PRESENT
+    #define __TBB_CPP11_TUPLE_PRESENT                       __TBB_CPP11_PRESENT
+    #define __TBB_INITIALIZER_LISTS_PRESENT                 __TBB_CPP11_PRESENT
+    #define __TBB_CONSTEXPR_PRESENT                         __TBB_CPP11_PRESENT
+    #define __TBB_DEFAULTED_AND_DELETED_FUNC_PRESENT        __TBB_CPP11_PRESENT
+    #define __TBB_NOEXCEPT_PRESENT                          __TBB_CPP11_PRESENT
+    #define __TBB_CPP11_STD_BEGIN_END_PRESENT               __TBB_CPP11_PRESENT
+    #define __TBB_CPP11_AUTO_PRESENT                        __TBB_CPP11_PRESENT
+    #define __TBB_CPP11_DECLTYPE_PRESENT                    __TBB_CPP11_PRESENT
+    #define __TBB_CPP11_LAMBDAS_PRESENT                     __TBB_CPP11_PRESENT
+    #define __TBB_CPP11_DEFAULT_FUNC_TEMPLATE_ARGS_PRESENT  __TBB_CPP11_PRESENT
+    #define __TBB_OVERRIDE_PRESENT                          __TBB_CPP11_PRESENT
+    #define __TBB_ALIGNAS_PRESENT                           __TBB_CPP11_PRESENT
+    #define __TBB_CPP11_TEMPLATE_ALIASES_PRESENT            __TBB_CPP11_PRESENT
+    #define __TBB_CPP14_INTEGER_SEQUENCE_PRESENT            (__cplusplus >= 201402L)
+    #define __TBB_CPP14_VARIABLE_TEMPLATES_PRESENT          (__cplusplus >= 201402L)
+    #define __TBB_CPP17_DEDUCTION_GUIDES_PRESENT            (__cplusplus >= 201703L)
+    #define __TBB_CPP17_INVOKE_RESULT_PRESENT               (__cplusplus >= 201703L)
 #endif
 
 // C++11 standard library features
 
+#define __TBB_CPP11_ARRAY_PRESENT                           (_MSC_VER >= 1700 || _LIBCPP_VERSION || __GXX_EXPERIMENTAL_CXX0X__ && __TBB_GLIBCXX_VERSION >= 40300)
+
 #ifndef __TBB_CPP11_VARIADIC_FIXED_LENGTH_EXP_PRESENT
 #define __TBB_CPP11_VARIADIC_FIXED_LENGTH_EXP_PRESENT       __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT
 #endif
-#define __TBB_CPP11_VARIADIC_TUPLE_PRESENT          (!_MSC_VER || _MSC_VER >=1800)
+#define __TBB_CPP11_VARIADIC_TUPLE_PRESENT                  (!_MSC_VER || _MSC_VER >= 1800)
 
-#define __TBB_CPP11_TYPE_PROPERTIES_PRESENT         (_LIBCPP_VERSION || _MSC_VER >= 1700 || (__TBB_GLIBCXX_VERSION >= 50000 && (__GXX_EXPERIMENTAL_CXX0X__ || __cplusplus >= 201103L)))
-#define __TBB_TR1_TYPE_PROPERTIES_IN_STD_PRESENT    (__GXX_EXPERIMENTAL_CXX0X__ && __TBB_GLIBCXX_VERSION >= 40300 || _MSC_VER >= 1600)
+#define __TBB_CPP11_TYPE_PROPERTIES_PRESENT                 (_LIBCPP_VERSION || _MSC_VER >= 1700 || (__TBB_GLIBCXX_VERSION >= 50000 && __GXX_EXPERIMENTAL_CXX0X__))
 // GCC supported some of type properties since 4.7
-#define __TBB_CPP11_IS_COPY_CONSTRUCTIBLE_PRESENT   (__GXX_EXPERIMENTAL_CXX0X__ && __TBB_GLIBCXX_VERSION >= 40700 || __TBB_CPP11_TYPE_PROPERTIES_PRESENT)
+#define __TBB_CPP11_IS_COPY_CONSTRUCTIBLE_PRESENT           (__GXX_EXPERIMENTAL_CXX0X__ && __TBB_GLIBCXX_VERSION >= 40700 || __TBB_CPP11_TYPE_PROPERTIES_PRESENT)
 
 // In GCC, std::move_if_noexcept appeared later than noexcept
-#define __TBB_MOVE_IF_NOEXCEPT_PRESENT     (__TBB_NOEXCEPT_PRESENT && (__TBB_GLIBCXX_VERSION >= 40700 || _MSC_VER >= 1900 || _LIBCPP_VERSION))
-#define __TBB_ALLOCATOR_TRAITS_PRESENT     (__cplusplus >= 201103L && _LIBCPP_VERSION  || _MSC_VER >= 1700 ||  \
-                                            __GXX_EXPERIMENTAL_CXX0X__ && __TBB_GLIBCXX_VERSION >= 40700 && !(__TBB_GLIBCXX_VERSION == 40700 && __TBB_DEFINE_MIC))
-#define __TBB_MAKE_EXCEPTION_PTR_PRESENT   (__TBB_EXCEPTION_PTR_PRESENT && (_MSC_VER >= 1700 || __TBB_GLIBCXX_VERSION >= 40600 || _LIBCPP_VERSION))
-
-#define __TBB_CPP11_FUTURE_PRESENT (_MSC_VER >= 1700 || __TBB_GLIBCXX_VERSION >= 40600 && _GXX_EXPERIMENTAL_CXX0X__ || _LIBCPP_VERSION)
-
+#define __TBB_MOVE_IF_NOEXCEPT_PRESENT                      (__TBB_NOEXCEPT_PRESENT && (__TBB_GLIBCXX_VERSION >= 40700 || _MSC_VER >= 1900 || _LIBCPP_VERSION))
+#define __TBB_ALLOCATOR_TRAITS_PRESENT                      (__cplusplus >= 201103L && _LIBCPP_VERSION  || _MSC_VER >= 1800 ||  \
+                                                            __GXX_EXPERIMENTAL_CXX0X__ && __TBB_GLIBCXX_VERSION >= 40700 && !(__TBB_GLIBCXX_VERSION == 40700 && __TBB_DEFINE_MIC))
+#define __TBB_MAKE_EXCEPTION_PTR_PRESENT                    (__TBB_EXCEPTION_PTR_PRESENT && (_MSC_VER >= 1700 || __TBB_GLIBCXX_VERSION >= 40600 || _LIBCPP_VERSION || __SUNPRO_CC))
+
+// Due to libc++ limitations in C++03 mode, do not pass rvalues to std::make_shared()
+#define __TBB_CPP11_SMART_POINTERS_PRESENT                  ( _MSC_VER >= 1600 || _LIBCPP_VERSION   \
+                                                            || ((__cplusplus >= 201103L || __GXX_EXPERIMENTAL_CXX0X__)  \
+                                                            && (__TBB_GLIBCXX_VERSION >= 40500 || __TBB_GLIBCXX_VERSION >= 40400 && __TBB_USE_OPTIONAL_RTTI)) )
+
+#define __TBB_CPP11_FUTURE_PRESENT                          (_MSC_VER >= 1700 || __TBB_GLIBCXX_VERSION >= 40600 && __GXX_EXPERIMENTAL_CXX0X__ || _LIBCPP_VERSION)
+
+#define __TBB_CPP11_GET_NEW_HANDLER_PRESENT                 (_MSC_VER >= 1900 || __TBB_GLIBCXX_VERSION >= 40900 && __GXX_EXPERIMENTAL_CXX0X__ || _LIBCPP_VERSION)
+
+#define __TBB_CPP17_UNCAUGHT_EXCEPTIONS_PRESENT             (_MSC_VER >= 1900 || __GLIBCXX__ && __cpp_lib_uncaught_exceptions \
+                                                            || _LIBCPP_VERSION >= 3700 && (!__TBB_MACOS_TARGET_VERSION || __TBB_MACOS_TARGET_VERSION >= 101200))
+// TODO: wait when memory_resource will be fully supported in clang and define the right macro
+// Currently it is in experimental stage since 6 version.
+#define __TBB_CPP17_MEMORY_RESOURCE_PRESENT                 (_MSC_VER >= 1913 && (_MSVC_LANG > 201402L || __cplusplus > 201402L) || \
+                                                            __GLIBCXX__ && __cpp_lib_memory_resource >= 201603)
+#define __TBB_CPP17_HW_INTERFERENCE_SIZE_PRESENT            (_MSC_VER >= 1911)
 // std::swap is in <utility> only since C++11, though MSVC had it at least since VS2005
 #if _MSC_VER>=1400 || _LIBCPP_VERSION || __GXX_EXPERIMENTAL_CXX0X__
 #define __TBB_STD_SWAP_HEADER <utility>
@@ -340,11 +386,21 @@
     #define __TBB_GCC_BUILTIN_ATOMICS_PRESENT 1
 #endif
 
+#if __TBB_GCC_VERSION >= 70000 && !__INTEL_COMPILER && !__clang__
+    // After GCC7 there was possible reordering problem in generic atomic load/store operations.
+    // So always using builtins.
+    #define TBB_USE_GCC_BUILTINS 1
+#endif
+
 #if __INTEL_COMPILER >= 1200
     /** built-in C++11 style atomics available in ICC since 12.0 **/
     #define __TBB_ICC_BUILTIN_ATOMICS_PRESENT 1
 #endif
 
+#if _MSC_VER>=1600 && (!__INTEL_COMPILER || __INTEL_COMPILER>=1310)
+    #define __TBB_MSVC_PART_WORD_INTERLOCKED_INTRINSICS_PRESENT 1
+#endif
+
 #define __TBB_TSX_INTRINSICS_PRESENT ((__RTM__ || _MSC_VER>=1700 || __INTEL_COMPILER>=1300) && !__TBB_DEFINE_MIC && !__ANDROID__)
 
 /** Macro helpers **/
@@ -361,8 +417,8 @@
 /*
 There are four cases that are supported:
   1. "_DEBUG is undefined" means "no debug";
-  2. "_DEBUG defined to something that is evaluated to 0 (the "garbage" is also evaluated to 0 [cpp.cond])" means "no debug";
-  3. "_DEBUG defined to something that is evaluated to non-zero value" means "debug";
+  2. "_DEBUG defined to something that is evaluated to 0" (including "garbage", as per [cpp.cond]) means "no debug";
+  3. "_DEBUG defined to something that is evaluated to a non-zero value" means "debug";
   4. "_DEBUG defined to nothing (empty)" means "debug".
 */
 #ifdef _DEBUG
@@ -391,7 +447,7 @@ There are four cases that are supported:
 #define TBB_USE_PERFORMANCE_WARNINGS TBB_PERFORMANCE_WARNINGS
 #else
 #define TBB_USE_PERFORMANCE_WARNINGS TBB_USE_DEBUG
-#endif /* TBB_PEFORMANCE_WARNINGS */
+#endif /* TBB_PERFORMANCE_WARNINGS */
 #endif /* TBB_USE_PERFORMANCE_WARNINGS */
 
 #if __TBB_DEFINE_MIC
@@ -410,18 +466,10 @@ There are four cases that are supported:
     #define TBB_USE_EXCEPTIONS 1
 #endif
 
-#if __clang__ && !__INTEL_COMPILER
-#define __TBB_USE_OPTIONAL_RTTI __has_feature(cxx_rtti)
-#elif defined(_CPPRTTI)
-#define __TBB_USE_OPTIONAL_RTTI 1
-#else
-#define __TBB_USE_OPTIONAL_RTTI (__GXX_RTTI || __RTTI || __INTEL_RTTI__)
-#endif
-
 #ifndef TBB_IMPLEMENT_CPP0X
 /** By default, use C++11 classes if available **/
     #if __clang__
-        /* Old versions of Intel Compiler do not have __has_include or cannot use it in #define */
+        /* Old versions of Intel C++ Compiler do not have __has_include or cannot use it in #define */
         #if (__INTEL_COMPILER && (__INTEL_COMPILER < 1500 || __INTEL_COMPILER == 1500 && __INTEL_COMPILER_UPDATE <= 1))
             #define TBB_IMPLEMENT_CPP0X (__cplusplus < 201103L || !_LIBCPP_VERSION)
         #else
@@ -458,6 +506,15 @@ There are four cases that are supported:
 
 /** Internal TBB features & modes **/
 
+/** __TBB_CONCURRENT_ORDERED_CONTAINERS indicates that all conditions of use
+ * concurrent_map and concurrent_set are met. **/
+// TODO: Add cpp11 random generation macro
+#ifndef __TBB_CONCURRENT_ORDERED_CONTAINERS_PRESENT
+    #define __TBB_CONCURRENT_ORDERED_CONTAINERS_PRESENT ( __TBB_CPP11_RVALUE_REF_PRESENT && __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT \
+     && __TBB_IMPLICIT_MOVE_PRESENT  && __TBB_CPP11_AUTO_PRESENT && __TBB_CPP11_LAMBDAS_PRESENT && __TBB_CPP11_ARRAY_PRESENT \
+     && __TBB_INITIALIZER_LISTS_PRESENT )
+#endif
+
 /** __TBB_WEAK_SYMBOLS_PRESENT denotes that the system supports the weak symbol mechanism **/
 #ifndef __TBB_WEAK_SYMBOLS_PRESENT
 #define __TBB_WEAK_SYMBOLS_PRESENT ( !_WIN32 && !__APPLE__ && !__sun && (__TBB_GCC_VERSION >= 40000 || __INTEL_COMPILER ) )
@@ -499,29 +556,13 @@ There are four cases that are supported:
 #define __TBB_RECYCLE_TO_ENQUEUE __TBB_BUILD // keep non-official
 
 #ifndef __TBB_ARENA_OBSERVER
-    #define __TBB_ARENA_OBSERVER ((__TBB_BUILD||TBB_PREVIEW_LOCAL_OBSERVER)&& __TBB_SCHEDULER_OBSERVER)
+    #define __TBB_ARENA_OBSERVER __TBB_SCHEDULER_OBSERVER
 #endif /* __TBB_ARENA_OBSERVER */
 
-#ifndef __TBB_SLEEP_PERMISSION
-    #define __TBB_SLEEP_PERMISSION ((__TBB_CPF_BUILD||TBB_PREVIEW_LOCAL_OBSERVER)&& __TBB_SCHEDULER_OBSERVER)
-#endif /* __TBB_SLEEP_PERMISSION */
-
 #ifndef __TBB_TASK_ISOLATION
-    #define __TBB_TASK_ISOLATION (__TBB_CPF_BUILD||TBB_PREVIEW_TASK_ISOLATION)
+    #define __TBB_TASK_ISOLATION 1
 #endif /* __TBB_TASK_ISOLATION */
 
-#if TBB_PREVIEW_FLOW_GRAPH_TRACE
-// Users of flow-graph trace need to explicitly link against the preview library.  This
-// prevents the linker from implicitly linking an application with a preview version of
-// TBB and unexpectedly bringing in other community preview features, which might change
-// the behavior of the application.
-#define __TBB_NO_IMPLICIT_LINKAGE 1
-#endif /* TBB_PREVIEW_FLOW_GRAPH_TRACE */
-
-#ifndef __TBB_ITT_STRUCTURE_API
-#define __TBB_ITT_STRUCTURE_API ( !__TBB_DEFINE_MIC && (__TBB_CPF_BUILD || TBB_PREVIEW_FLOW_GRAPH_TRACE) )
-#endif
-
 #if TBB_USE_EXCEPTIONS && !__TBB_TASK_GROUP_CONTEXT
     #error TBB_USE_EXCEPTIONS requires __TBB_TASK_GROUP_CONTEXT to be enabled
 #endif
@@ -534,6 +575,10 @@ There are four cases that are supported:
     #error __TBB_TASK_PRIORITY requires __TBB_TASK_GROUP_CONTEXT to be enabled
 #endif
 
+#if TBB_PREVIEW_NUMA_SUPPORT || __TBB_BUILD
+    #define __TBB_NUMA_SUPPORT 1
+#endif
+
 #if TBB_PREVIEW_WAITING_FOR_WORKERS || __TBB_BUILD
     #define __TBB_SUPPORTS_WORKERS_WAITING_IN_TERMINATE 1
 #endif
@@ -548,14 +593,8 @@ There are four cases that are supported:
 #endif /* __TBB_SURVIVE_THREAD_SWITCH */
 
 #ifndef __TBB_DEFAULT_PARTITIONER
-#if TBB_DEPRECATED
-/** Default partitioner for parallel loop templates in TBB 1.0-2.1 */
-#define __TBB_DEFAULT_PARTITIONER tbb::simple_partitioner
-#else
-/** Default partitioner for parallel loop templates since TBB 2.2 */
 #define __TBB_DEFAULT_PARTITIONER tbb::auto_partitioner
-#endif /* TBB_DEPRECATED */
-#endif /* !defined(__TBB_DEFAULT_PARTITIONER */
+#endif
 
 #ifndef __TBB_USE_PROPORTIONAL_SPLIT_IN_BLOCKED_RANGES
 #define __TBB_USE_PROPORTIONAL_SPLIT_IN_BLOCKED_RANGES 1
@@ -577,8 +616,45 @@ There are four cases that are supported:
     #endif
 #endif
 
-/** __TBB_WIN8UI_SUPPORT enables support of New Windows*8 Store Apps and limit a possibility to load
+// Intel C++ Compiler starts analyzing usages of the deprecated content at the template
+// instantiation site, which is too late for suppression of the corresponding messages for internal
+// stuff.
+#if !defined(__INTEL_COMPILER) && (!defined(TBB_SUPPRESS_DEPRECATED_MESSAGES) || (TBB_SUPPRESS_DEPRECATED_MESSAGES == 0))
+    #if (__cplusplus >= 201402L)
+        #define __TBB_DEPRECATED [[deprecated]]
+        #define __TBB_DEPRECATED_MSG(msg) [[deprecated(msg)]]
+    #elif _MSC_VER
+        #define __TBB_DEPRECATED __declspec(deprecated)
+        #define __TBB_DEPRECATED_MSG(msg) __declspec(deprecated(msg))
+    #elif (__GNUC__ && __TBB_GCC_VERSION >= 40805) || __clang__
+        #define __TBB_DEPRECATED __attribute__((deprecated))
+        #define __TBB_DEPRECATED_MSG(msg) __attribute__((deprecated(msg)))
+    #endif
+#endif  // !defined(TBB_SUPPRESS_DEPRECATED_MESSAGES) || (TBB_SUPPRESS_DEPRECATED_MESSAGES == 0)
+
+#if !defined(__TBB_DEPRECATED)
+    #define __TBB_DEPRECATED
+    #define __TBB_DEPRECATED_MSG(msg)
+#elif !defined(__TBB_SUPPRESS_INTERNAL_DEPRECATED_MESSAGES)
+    // Suppress deprecated messages from self
+    #define __TBB_SUPPRESS_INTERNAL_DEPRECATED_MESSAGES 1
+#endif
+
+#if defined(TBB_SUPPRESS_DEPRECATED_MESSAGES) && (TBB_SUPPRESS_DEPRECATED_MESSAGES == 0)
+    #define __TBB_DEPRECATED_IN_VERBOSE_MODE __TBB_DEPRECATED
+    #define __TBB_DEPRECATED_IN_VERBOSE_MODE_MSG(msg) __TBB_DEPRECATED_MSG(msg)
+#else
+    #define __TBB_DEPRECATED_IN_VERBOSE_MODE
+    #define __TBB_DEPRECATED_IN_VERBOSE_MODE_MSG(msg)
+#endif // (TBB_SUPPRESS_DEPRECATED_MESSAGES == 0)
+
+#if (!defined(TBB_SUPPRESS_DEPRECATED_MESSAGES) || (TBB_SUPPRESS_DEPRECATED_MESSAGES == 0)) && !__TBB_CPP11_PRESENT
+    #pragma message("TBB Warning: Support for C++98/03 is deprecated. Please use the compiler that supports C++11 features at least.")
+#endif
+
+/** __TBB_WIN8UI_SUPPORT enables support of Windows* Store Apps and limit a possibility to load
     shared libraries at run time only from application container **/
+// TODO: Separate this single macro into two for Windows 8 Store* (win8ui mode) and UWP/UWD modes.
 #if defined(WINAPI_FAMILY) && WINAPI_FAMILY == WINAPI_FAMILY_APP
     #define __TBB_WIN8UI_SUPPORT 1
 #else
@@ -627,7 +703,7 @@ There are four cases that are supported:
 #endif
 
 #if (_WIN32||_WIN64) && __INTEL_COMPILER == 1110
-    /** That's a bug in Intel(R) C++ Compiler 11.1.044/IA-32 architecture/Windows* OS, that leads to a worker thread crash on the thread's startup. **/
+    /** That's a bug in Intel C++ Compiler 11.1.044/IA-32 architecture/Windows* OS, that leads to a worker thread crash on the thread's startup. **/
     #define __TBB_ICL_11_1_CODE_GEN_BROKEN 1
 #endif
 
@@ -658,12 +734,12 @@ There are four cases that are supported:
 #endif /* __FreeBSD__ */
 
 #if (__linux__ || __APPLE__) && __i386__ && defined(__INTEL_COMPILER)
-    /** The Intel(R) C++ Compiler for IA-32 architecture (Linux* OS|macOS) crashes or generates
+    /** The Intel C++ Compiler for IA-32 architecture (Linux* OS|macOS) crashes or generates
         incorrect code when __asm__ arguments have a cast to volatile. **/
     #define __TBB_ICC_ASM_VOLATILE_BROKEN 1
 #endif
 
-#if !__INTEL_COMPILER && (_MSC_VER || __GNUC__==3 && __GNUC_MINOR__<=2)
+#if !__INTEL_COMPILER && (_MSC_VER && _MSC_VER < 1700 || __GNUC__==3 && __GNUC_MINOR__<=2)
     /** Bug in GCC 3.2 and MSVC compilers that sometimes return 0 for __alignof(T)
         when T has not yet been instantiated. **/
     #define __TBB_ALIGNOF_NOT_INSTANTIATED_TYPES_BROKEN 1
@@ -686,11 +762,7 @@ There are four cases that are supported:
 #endif
 
 #if __INTEL_COMPILER==1300 && __TBB_GLIBCXX_VERSION>=40700 && defined(__GXX_EXPERIMENTAL_CXX0X__)
-/* Some C++11 features used inside libstdc++ are not supported by Intel compiler.
- * Checking version of gcc instead of libstdc++ because
- *  - they are directly connected,
- *  - for now it is not possible to check version of any standard library in this file
- */
+/* Some C++11 features used inside libstdc++ are not supported by Intel C++ Compiler. */
     #define __TBB_ICC_13_0_CPP11_STDLIB_SUPPORT_BROKEN 1
 #endif
 
@@ -703,7 +775,7 @@ There are four cases that are supported:
     #endif
 #endif
 
-/*In a PIC mode some versions of GCC 4.1.2 generate incorrect inlined code for 8 byte __sync_val_compare_and_swap intrinsic */
+/* In a PIC mode some versions of GCC 4.1.2 generate incorrect inlined code for 8 byte __sync_val_compare_and_swap intrinsic */
 #if __TBB_GCC_VERSION == 40102 && __PIC__ && !defined(__INTEL_COMPILER) && !defined(__clang__)
     #define __TBB_GCC_CAS8_BUILTIN_INLINING_BROKEN 1
 #endif
@@ -734,16 +806,23 @@ There are four cases that are supported:
 #define __TBB_IF_NO_COPY_CTOR_MOVE_SEMANTICS_BROKEN (_MSC_VER && (__INTEL_COMPILER >= 1300 && __INTEL_COMPILER <= 1310) && !__INTEL_CXX11_MODE__)
 
 #define __TBB_CPP11_DECLVAL_BROKEN (_MSC_VER == 1600 || (__GNUC__ && __TBB_GCC_VERSION < 40500) )
-
-// Intel C++ compiler has difficulties with copying std::pair with VC11 std::reference_wrapper being a const member
+// Intel C++ Compiler has difficulties with copying std::pair with VC11 std::reference_wrapper being a const member
 #define __TBB_COPY_FROM_NON_CONST_REF_BROKEN (_MSC_VER == 1700 && __INTEL_COMPILER && __INTEL_COMPILER < 1600)
 
 // The implicit upcasting of the tuple of a reference of a derived class to a base class fails on icc 13.X if the system's gcc environment is 4.8
 // Also in gcc 4.4 standard library the implementation of the tuple<&> conversion (tuple<A&> a = tuple<B&>, B is inherited from A) is broken.
-#if __GXX_EXPERIMENTAL_CXX0X__ && ((__INTEL_COMPILER >=1300 && __INTEL_COMPILER <=1310 && __TBB_GLIBCXX_VERSION>=40700) || (__TBB_GLIBCXX_VERSION < 40500))
+#if __GXX_EXPERIMENTAL_CXX0X__ && __GLIBCXX__ && ((__INTEL_COMPILER >=1300 && __INTEL_COMPILER <=1310 && __TBB_GLIBCXX_VERSION>=40700) || (__TBB_GLIBCXX_VERSION < 40500))
 #define __TBB_UPCAST_OF_TUPLE_OF_REF_BROKEN 1
 #endif
 
+// In some cases decltype of a function adds a reference to a return type.
+#define __TBB_CPP11_DECLTYPE_OF_FUNCTION_RETURN_TYPE_BROKEN (_MSC_VER == 1600 && !__INTEL_COMPILER)
+
+// Visual Studio 2013 does not delete the copy constructor when a user-defined move constructor is provided
+#if _MSC_VER && _MSC_VER <= 1800
+    #define __TBB_IMPLICIT_COPY_DELETION_BROKEN 1
+#endif
+
 /** End of __TBB_XXX_BROKEN macro section **/
 
 #if defined(_MSC_VER) && _MSC_VER>=1500 && !defined(__INTEL_COMPILER)
@@ -764,7 +843,7 @@ There are four cases that are supported:
 
 #define __TBB_VARIADIC_PARALLEL_INVOKE          (TBB_PREVIEW_VARIADIC_PARALLEL_INVOKE && __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT && __TBB_CPP11_RVALUE_REF_PRESENT)
 #define __TBB_FLOW_GRAPH_CPP11_FEATURES         (__TBB_CPP11_VARIADIC_TEMPLATES_PRESENT \
-                                                && __TBB_CPP11_RVALUE_REF_PRESENT && __TBB_CPP11_AUTO_PRESENT) \
+                                                && __TBB_CPP11_SMART_POINTERS_PRESENT && __TBB_CPP11_RVALUE_REF_PRESENT && __TBB_CPP11_AUTO_PRESENT) \
                                                 && __TBB_CPP11_VARIADIC_TUPLE_PRESENT && __TBB_CPP11_DEFAULT_FUNC_TEMPLATE_ARGS_PRESENT \
                                                 && !__TBB_UPCAST_OF_TUPLE_OF_REF_BROKEN
 #define __TBB_PREVIEW_STREAMING_NODE            (__TBB_CPP11_VARIADIC_FIXED_LENGTH_EXP_PRESENT && __TBB_FLOW_GRAPH_CPP11_FEATURES \
@@ -773,7 +852,22 @@ There are four cases that are supported:
 #define __TBB_PREVIEW_MESSAGE_BASED_KEY_MATCHING (TBB_PREVIEW_FLOW_GRAPH_FEATURES || __TBB_PREVIEW_OPENCL_NODE)
 #define __TBB_PREVIEW_ASYNC_MSG                 (TBB_PREVIEW_FLOW_GRAPH_FEATURES && __TBB_FLOW_GRAPH_CPP11_FEATURES)
 
-#define __TBB_PREVIEW_GFX_FACTORY               (__TBB_GFX_PRESENT && TBB_PREVIEW_FLOW_GRAPH_FEATURES && !__TBB_MIC_OFFLOAD \
-                                                && __TBB_FLOW_GRAPH_CPP11_FEATURES && __TBB_CPP11_TEMPLATE_ALIASES_PRESENT \
-                                                && __TBB_CPP11_FUTURE_PRESENT)
+
+#ifndef __TBB_PREVIEW_FLOW_GRAPH_PRIORITIES
+#define __TBB_PREVIEW_FLOW_GRAPH_PRIORITIES     TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#endif
+
+// This feature works only in combination with critical tasks (__TBB_PREVIEW_CRITICAL_TASKS)
+#ifndef __TBB_PREVIEW_RESUMABLE_TASKS
+#define __TBB_PREVIEW_RESUMABLE_TASKS           ((__TBB_CPF_BUILD || TBB_PREVIEW_RESUMABLE_TASKS) && !__TBB_WIN8UI_SUPPORT && !__ANDROID__ && !__TBB_ipf)
+#endif
+
+#ifndef __TBB_PREVIEW_CRITICAL_TASKS
+#define __TBB_PREVIEW_CRITICAL_TASKS            (__TBB_CPF_BUILD || __TBB_PREVIEW_FLOW_GRAPH_PRIORITIES || __TBB_PREVIEW_RESUMABLE_TASKS)
+#endif
+
+#ifndef __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+#define __TBB_PREVIEW_FLOW_GRAPH_NODE_SET       (TBB_PREVIEW_FLOW_GRAPH_FEATURES && __TBB_CPP11_PRESENT && __TBB_FLOW_GRAPH_CPP11_FEATURES)
+#endif
+
 #endif /* __TBB_tbb_config_H */
diff --git a/inst/include/tbb/tbb_disable_exceptions.h b/inst/include/tbb/tbb_disable_exceptions.h
index a1d28a60..69ef5c57 100644
--- a/inst/include/tbb/tbb_disable_exceptions.h
+++ b/inst/include/tbb/tbb_disable_exceptions.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 //! To disable use of exceptions, include this header before any other header file from the library.
diff --git a/inst/include/tbb/tbb_exception.h b/inst/include/tbb/tbb_exception.h
index 1c843309..3c5fb7dd 100644
--- a/inst/include/tbb/tbb_exception.h
+++ b/inst/include/tbb/tbb_exception.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,31 +12,19 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_exception_H
 #define __TBB_exception_H
 
-#include "tbb_stddef.h"
-
-#if !TBB_USE_EXCEPTIONS && _MSC_VER
-    // Suppress "C++ exception handler used, but unwind semantics are not enabled" warning in STL headers
-    #pragma warning (push)
-    #pragma warning (disable: 4530)
-#endif
+#define __TBB_tbb_exception_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
 
+#include "tbb_stddef.h"
 #include <exception>
-#include <new>    //required for bad_alloc definition, operators new
+#include <new>    // required for bad_alloc definition, operators new
 #include <string> // required to construct std exception classes
 
-#if !TBB_USE_EXCEPTIONS && _MSC_VER
-    #pragma warning (pop)
-#endif
-
 namespace tbb {
 
 //! Exception for concurrent containers
@@ -49,7 +37,7 @@ class bad_last_alloc : public std::bad_alloc {
 };
 
 //! Exception for PPL locks
-class improper_lock : public std::exception {
+class __TBB_DEPRECATED improper_lock : public std::exception {
 public:
     const char* what() const throw() __TBB_override;
 };
@@ -146,7 +134,7 @@ namespace tbb {
 
     TBB provides two implementations of this interface: tbb::captured_exception and
     template class tbb::movable_exception. See their declarations for more info. **/
-class tbb_exception : public std::exception
+class __TBB_DEPRECATED tbb_exception : public std::exception
 {
     /** No operator new is provided because the TBB usage model assumes dynamic
         creation of the TBB exception objects only by means of applying move()
@@ -164,19 +152,19 @@ class tbb_exception : public std::exception
 
     //! Creates and returns pointer to the deep copy of this exception object.
     /** Move semantics is allowed. **/
-    virtual tbb_exception* move () throw() = 0;
+    virtual tbb_exception* move() throw() = 0;
 
     //! Destroys objects created by the move() method.
     /** Frees memory and calls destructor for this exception object.
         Can and must be used only on objects created by the move method. **/
-    virtual void destroy () throw() = 0;
+    virtual void destroy() throw() = 0;
 
     //! Throws this exception object.
     /** Make sure that if you have several levels of derivation from this interface
         you implement or override this method on the most derived level. The implementation
         is as simple as "throw *this;". Failure to do this will result in exception
         of a base class type being thrown. **/
-    virtual void throw_self () = 0;
+    virtual void throw_self() = 0;
 
     //! Returns RTTI name of the originally intercepted exception
     virtual const char* name() const throw() = 0;
@@ -200,22 +188,22 @@ class tbb_exception : public std::exception
     algorithm ) if an unhandled exception was intercepted during the algorithm execution in one
     of the workers.
     \sa tbb::tbb_exception **/
-class captured_exception : public tbb_exception
+class __TBB_DEPRECATED_IN_VERBOSE_MODE captured_exception : public tbb_exception
 {
 public:
-    captured_exception ( const captured_exception& src )
+    captured_exception( const captured_exception& src )
         : tbb_exception(src), my_dynamic(false)
     {
         set(src.my_exception_name, src.my_exception_info);
     }
 
-    captured_exception ( const char* name_, const char* info )
+    captured_exception( const char* name_, const char* info )
         : my_dynamic(false)
     {
         set(name_, info);
     }
 
-    __TBB_EXPORTED_METHOD ~captured_exception () throw();
+    __TBB_EXPORTED_METHOD ~captured_exception() throw();
 
     captured_exception& operator= ( const captured_exception& src ) {
         if ( this != &src ) {
@@ -225,25 +213,25 @@ class captured_exception : public tbb_exception
         return *this;
     }
 
-    captured_exception* __TBB_EXPORTED_METHOD move () throw() __TBB_override;
+    captured_exception* __TBB_EXPORTED_METHOD move() throw() __TBB_override;
 
-    void __TBB_EXPORTED_METHOD destroy () throw() __TBB_override;
+    void __TBB_EXPORTED_METHOD destroy() throw() __TBB_override;
 
-    void throw_self () __TBB_override { __TBB_THROW(*this); }
+    void throw_self() __TBB_override { __TBB_THROW(*this); }
 
     const char* __TBB_EXPORTED_METHOD name() const throw() __TBB_override;
 
     const char* __TBB_EXPORTED_METHOD what() const throw() __TBB_override;
 
-    void __TBB_EXPORTED_METHOD set ( const char* name, const char* info ) throw();
-    void __TBB_EXPORTED_METHOD clear () throw();
+    void __TBB_EXPORTED_METHOD set( const char* name, const char* info ) throw();
+    void __TBB_EXPORTED_METHOD clear() throw();
 
 private:
-    //! Used only by method clone().
-    captured_exception() {}
+    //! Used only by method move().
+    captured_exception() : my_dynamic(), my_exception_name(), my_exception_info() {}
 
-    //! Functionally equivalent to {captured_exception e(name,info); return e.clone();}
-    static captured_exception* allocate ( const char* name, const char* info );
+    //! Functionally equivalent to {captured_exception e(name,info); return e.move();}
+    static captured_exception* allocate( const char* name, const char* info );
 
     bool my_dynamic;
     const char* my_exception_name;
@@ -256,12 +244,12 @@ class captured_exception : public tbb_exception
     and delivered to the root thread ().
     \sa tbb::tbb_exception **/
 template<typename ExceptionData>
-class movable_exception : public tbb_exception
+class __TBB_DEPRECATED movable_exception : public tbb_exception
 {
     typedef movable_exception<ExceptionData> self_type;
 
 public:
-    movable_exception ( const ExceptionData& data_ )
+    movable_exception( const ExceptionData& data_ )
         : my_exception_data(data_)
         , my_dynamic(false)
         , my_exception_name(
@@ -273,14 +261,14 @@ class movable_exception : public tbb_exception
         )
     {}
 
-    movable_exception ( const movable_exception& src ) throw ()
+    movable_exception( const movable_exception& src ) throw ()
         : tbb_exception(src)
         , my_exception_data(src.my_exception_data)
         , my_dynamic(false)
         , my_exception_name(src.my_exception_name)
     {}
 
-    ~movable_exception () throw() {}
+    ~movable_exception() throw() {}
 
     const movable_exception& operator= ( const movable_exception& src ) {
         if ( this != &src ) {
@@ -290,15 +278,15 @@ class movable_exception : public tbb_exception
         return *this;
     }
 
-    ExceptionData& data () throw() { return my_exception_data; }
+    ExceptionData& data() throw() { return my_exception_data; }
 
-    const ExceptionData& data () const throw() { return my_exception_data; }
+    const ExceptionData& data() const throw() { return my_exception_data; }
 
-    const char* name () const throw() __TBB_override { return my_exception_name; }
+    const char* name() const throw() __TBB_override { return my_exception_name; }
 
-    const char* what () const throw() __TBB_override { return "tbb::movable_exception"; }
+    const char* what() const throw() __TBB_override { return "tbb::movable_exception"; }
 
-    movable_exception* move () throw() __TBB_override {
+    movable_exception* move() throw() __TBB_override {
         void* e = internal::allocate_via_handler_v3(sizeof(movable_exception));
         if ( e ) {
             ::new (e) movable_exception(*this);
@@ -306,14 +294,14 @@ class movable_exception : public tbb_exception
         }
         return (movable_exception*)e;
     }
-    void destroy () throw() __TBB_override {
+    void destroy() throw() __TBB_override {
         __TBB_ASSERT ( my_dynamic, "Method destroy can be called only on dynamically allocated movable_exceptions" );
         if ( my_dynamic ) {
             this->~movable_exception();
             internal::deallocate_via_handler_v3(this);
         }
     }
-    void throw_self () __TBB_override { __TBB_THROW( *this ); }
+    void throw_self() __TBB_override { __TBB_THROW( *this ); }
 
 protected:
     //! User data
@@ -333,26 +321,26 @@ namespace internal {
 
 //! Exception container that preserves the exact copy of the original exception
 /** This class can be used only when the appropriate runtime support (mandated
-    by C++0x) is present **/
+    by C++11) is present **/
 class tbb_exception_ptr {
     std::exception_ptr  my_ptr;
 
 public:
-    static tbb_exception_ptr* allocate ();
-    static tbb_exception_ptr* allocate ( const tbb_exception& tag );
+    static tbb_exception_ptr* allocate();
+    static tbb_exception_ptr* allocate( const tbb_exception& tag );
     //! This overload uses move semantics (i.e. it empties src)
-    static tbb_exception_ptr* allocate ( captured_exception& src );
+    static tbb_exception_ptr* allocate( captured_exception& src );
 
     //! Destroys this objects
     /** Note that objects of this type can be created only by the allocate() method. **/
-    void destroy () throw();
+    void destroy() throw();
 
     //! Throws the contained exception .
-    void throw_self () { std::rethrow_exception(my_ptr); }
+    void throw_self() { std::rethrow_exception(my_ptr); }
 
 private:
-    tbb_exception_ptr ( const std::exception_ptr& src ) : my_ptr(src) {}
-    tbb_exception_ptr ( const captured_exception& src ) :
+    tbb_exception_ptr( const std::exception_ptr& src ) : my_ptr(src) {}
+    tbb_exception_ptr( const captured_exception& src ) :
         #if __TBB_MAKE_EXCEPTION_PTR_PRESENT
             my_ptr(std::make_exception_ptr(src))  // the final function name in C++11
         #else
@@ -368,4 +356,7 @@ class tbb_exception_ptr {
 
 #endif /* __TBB_TASK_GROUP_CONTEXT */
 
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_tbb_exception_H_include_area
+
 #endif /* __TBB_exception_H */
diff --git a/inst/include/tbb/tbb_machine.h b/inst/include/tbb/tbb_machine.h
index 68d1d5d0..9752be58 100644
--- a/inst/include/tbb/tbb_machine.h
+++ b/inst/include/tbb/tbb_machine.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_machine_H
@@ -227,7 +223,7 @@ template<> struct atomic_selector<8> {
         #include "machine/linux_intel64.h"
     #endif
 
-#elif __linux__ || __FreeBSD__ || __NetBSD__
+#elif __linux__ || __FreeBSD__ || __NetBSD__ || __OpenBSD__
 
     #if (TBB_USE_GCC_BUILTINS && __TBB_GCC_BUILTIN_ATOMICS_PRESENT)
         #include "machine/gcc_generic.h"
@@ -241,8 +237,8 @@ template<> struct atomic_selector<8> {
         #include "machine/linux_ia64.h"
     #elif __powerpc__
         #include "machine/mac_ppc.h"
-    #elif __ARM_ARCH_7A__
-        #include "machine/gcc_armv7.h"
+    #elif __ARM_ARCH_7A__ || __aarch64__
+        #include "machine/gcc_arm.h"
     #elif __TBB_GCC_BUILTIN_ATOMICS_PRESENT
         #include "machine/gcc_generic.h"
     #endif
@@ -663,7 +659,15 @@ struct machine_load_store_seq_cst<T,8> {
         return __TBB_machine_cmpswp8( (volatile void*)const_cast<volatile T*>(&location), anyvalue, anyvalue );
     }
     static void store ( volatile T &location, T value ) {
+#if __TBB_GCC_VERSION >= 40702
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
+#endif
+        // An atomic initialization leads to reading of uninitialized memory
         int64_t result = (volatile int64_t&)location;
+#if __TBB_GCC_VERSION >= 40702
+#pragma GCC diagnostic pop
+#endif
         while ( __TBB_machine_cmpswp8((volatile void*)&location, (int64_t)value, result) != result )
             result = (volatile int64_t&)location;
     }
@@ -780,7 +784,7 @@ struct __TBB_machine_type_with_alignment_##PowerOf2 { \
 #endif
 
 /* Now declare types aligned to useful powers of two */
-// TODO: Is __TBB_DefineTypeWithAlignment(8) needed on 32 bit platforms?
+__TBB_DefineTypeWithAlignment(8) // i386 ABI says that uint64_t is aligned on 4 bytes  
 __TBB_DefineTypeWithAlignment(16)
 __TBB_DefineTypeWithAlignment(32)
 __TBB_DefineTypeWithAlignment(64)
@@ -794,7 +798,7 @@ template<size_t N> struct type_with_alignment;
 template<> struct type_with_alignment<1> { char member; };
 template<> struct type_with_alignment<2> { uint16_t member; };
 template<> struct type_with_alignment<4> { uint32_t member; };
-template<> struct type_with_alignment<8> { uint64_t member; };
+template<> struct type_with_alignment<8> { __TBB_machine_type_with_alignment_8 member; };
 template<> struct type_with_alignment<16> {__TBB_machine_type_with_alignment_16 member; };
 template<> struct type_with_alignment<32> {__TBB_machine_type_with_alignment_32 member; };
 template<> struct type_with_alignment<64> {__TBB_machine_type_with_alignment_64 member; };
diff --git a/inst/include/tbb/tbb_profiling.h b/inst/include/tbb/tbb_profiling.h
index ffaf98b9..20f8f512 100644
--- a/inst/include/tbb/tbb_profiling.h
+++ b/inst/include/tbb/tbb_profiling.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,22 +12,17 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_profiling_H
 #define __TBB_profiling_H
 
+#define __TBB_tbb_profiling_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 namespace tbb {
     namespace internal {
 
-        //
-        // This is not under __TBB_ITT_STRUCTURE_API because these values are used directly in flow_graph.h.
-        //
-
         // include list of index names
         #define TBB_STRING_RESOURCE(index_name,str) index_name,
         enum string_index {
@@ -126,6 +121,7 @@ namespace tbb {
 #endif /* no tools support */
 
 #include "atomic.h"
+
 // Need these to work regardless of tools support
 namespace tbb {
     namespace internal {
@@ -138,13 +134,14 @@ namespace tbb {
         void __TBB_EXPORTED_FUNC itt_store_pointer_with_release_v3(void *dst, void *src);
         void* __TBB_EXPORTED_FUNC itt_load_pointer_with_acquire_v3(const void *src);
         void* __TBB_EXPORTED_FUNC itt_load_pointer_v3( const void* src );
-#if __TBB_ITT_STRUCTURE_API
-        enum itt_domain_enum { ITT_DOMAIN_FLOW=0 };
+        enum itt_domain_enum { ITT_DOMAIN_FLOW=0, ITT_DOMAIN_MAIN=1, ITT_DOMAIN_ALGO=2, ITT_NUM_DOMAINS };
 
         void __TBB_EXPORTED_FUNC itt_make_task_group_v7( itt_domain_enum domain, void *group, unsigned long long group_extra,
                                                          void *parent, unsigned long long parent_extra, string_index name_index );
         void __TBB_EXPORTED_FUNC itt_metadata_str_add_v7( itt_domain_enum domain, void *addr, unsigned long long addr_extra,
                                                           string_index key, const char *value );
+        void __TBB_EXPORTED_FUNC itt_metadata_ptr_add_v11( itt_domain_enum domain, void *addr, unsigned long long addr_extra,
+                                                           string_index key, void* value );
         void __TBB_EXPORTED_FUNC itt_relation_add_v7( itt_domain_enum domain, void *addr0, unsigned long long addr0_extra,
                                                       itt_relation relation, void *addr1, unsigned long long addr1_extra );
         void __TBB_EXPORTED_FUNC itt_task_begin_v7( itt_domain_enum domain, void *task, unsigned long long task_extra,
@@ -154,7 +151,6 @@ namespace tbb {
         void __TBB_EXPORTED_FUNC itt_region_begin_v9( itt_domain_enum domain, void *region, unsigned long long region_extra,
                                                       void *parent, unsigned long long parent_extra, string_index name_index );
         void __TBB_EXPORTED_FUNC itt_region_end_v9( itt_domain_enum domain, void *region, unsigned long long region_extra );
-#endif // __TBB_ITT_STRUCTURE_API
 
         // two template arguments are to workaround /Wp64 warning with tbb::atomic specialized for unsigned type
         template <typename T, typename U>
@@ -238,12 +234,6 @@ namespace tbb {
             call_itt_notify_v5((int)t, ptr);
         }
 
-#else
-        inline void call_itt_notify(notify_type /*t*/, void * /*ptr*/) {}
-
-#endif // TBB_USE_THREADING_TOOLS
-
-#if __TBB_ITT_STRUCTURE_API
         inline void itt_make_task_group( itt_domain_enum domain, void *group, unsigned long long group_extra,
                                          void *parent, unsigned long long parent_extra, string_index name_index ) {
             itt_make_task_group_v7( domain, group, group_extra, parent, parent_extra, name_index );
@@ -253,6 +243,11 @@ namespace tbb {
                                           string_index key, const char *value ) {
             itt_metadata_str_add_v7( domain, addr, addr_extra, key, value );
         }
+        
+        inline void register_node_addr(itt_domain_enum domain, void *addr, unsigned long long addr_extra,
+            string_index key, void *value) {
+            itt_metadata_ptr_add_v11(domain, addr, addr_extra, key, value);
+        }
 
         inline void itt_relation_add( itt_domain_enum domain, void *addr0, unsigned long long addr0_extra,
                                       itt_relation relation, void *addr1, unsigned long long addr1_extra ) {
@@ -276,9 +271,85 @@ namespace tbb {
         inline void itt_region_end( itt_domain_enum domain, void *region, unsigned long long region_extra  ) {
             itt_region_end_v9( domain, region, region_extra );
         }
-#endif // __TBB_ITT_STRUCTURE_API
+#else
+        inline void register_node_addr( itt_domain_enum /*domain*/, void* /*addr*/, unsigned long long /*addr_extra*/, string_index /*key*/, void* /*value*/ ) {}
+        inline void call_itt_notify(notify_type /*t*/, void* /*ptr*/) {}
+
+        inline void itt_make_task_group( itt_domain_enum /*domain*/, void* /*group*/, unsigned long long /*group_extra*/,
+                                         void* /*parent*/, unsigned long long /*parent_extra*/, string_index /*name_index*/ ) {}
+
+        inline void itt_metadata_str_add( itt_domain_enum /*domain*/, void* /*addr*/, unsigned long long /*addr_extra*/,
+                                          string_index /*key*/, const char* /*value*/ ) {}
+
+        inline void itt_relation_add( itt_domain_enum /*domain*/, void* /*addr0*/, unsigned long long /*addr0_extra*/,
+                                      itt_relation /*relation*/, void* /*addr1*/, unsigned long long /*addr1_extra*/ ) {}
+
+        inline void itt_task_begin( itt_domain_enum /*domain*/, void* /*task*/, unsigned long long /*task_extra*/,
+                                    void* /*parent*/, unsigned long long /*parent_extra*/, string_index /*name_index*/ ) {}
+
+        inline void itt_task_end( itt_domain_enum /*domain*/ ) {}
+
+        inline void itt_region_begin( itt_domain_enum /*domain*/, void* /*region*/, unsigned long long /*region_extra*/,
+                                      void* /*parent*/, unsigned long long /*parent_extra*/, string_index /*name_index*/ ) {}
+
+        inline void itt_region_end( itt_domain_enum /*domain*/, void* /*region*/, unsigned long long /*region_extra*/ ) {}
+#endif // TBB_USE_THREADING_TOOLS
 
     } // namespace internal
 } // namespace tbb
 
+#if TBB_PREVIEW_FLOW_GRAPH_TRACE
+#include <string>
+
+namespace tbb {
+namespace profiling {
+namespace interface10 {
+
+#if TBB_USE_THREADING_TOOLS && !(TBB_USE_THREADING_TOOLS == 2)
+class event {
+/** This class supports user event traces through itt.
+    Common use-case is tagging data flow graph tasks (data-id)
+    and visualization by Intel Advisor Flow Graph Analyzer (FGA)  **/
+//  TODO: Replace implementation by itt user event api.
+
+    const std::string my_name;
+
+    static void emit_trace(const std::string &input) {
+        itt_metadata_str_add( tbb::internal::ITT_DOMAIN_FLOW, NULL, tbb::internal::FLOW_NULL, tbb::internal::USER_EVENT, ( "FGA::DATAID::" + input ).c_str() );
+    }
+
+public:
+    event(const std::string &input)
+              : my_name( input )
+    { }
+
+    void emit() {
+        emit_trace(my_name);
+    }
+
+    static void emit(const std::string &description) {
+        emit_trace(description);
+    }
+
+};
+#else // TBB_USE_THREADING_TOOLS && !(TBB_USE_THREADING_TOOLS == 2)
+// Using empty struct if user event tracing is disabled:
+struct event {
+    event(const std::string &) { }
+
+    void emit() { }
+
+    static void emit(const std::string &) { }
+};
+#endif // TBB_USE_THREADING_TOOLS && !(TBB_USE_THREADING_TOOLS == 2)
+
+} // interfaceX
+using interface10::event;
+} // namespace profiling
+} // namespace tbb
+#endif // TBB_PREVIEW_FLOW_GRAPH_TRACE
+
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_tbb_profiling_H_include_area
+
 #endif /* __TBB_profiling_H */
diff --git a/inst/include/tbb/tbb_stddef.h b/inst/include/tbb/tbb_stddef.h
index 236f3d83..96743024 100644
--- a/inst/include/tbb/tbb_stddef.h
+++ b/inst/include/tbb/tbb_stddef.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,21 +12,17 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_tbb_stddef_H
 #define __TBB_tbb_stddef_H
 
 // Marketing-driven product version
-#define TBB_VERSION_MAJOR 2017
-#define TBB_VERSION_MINOR 0
+#define TBB_VERSION_MAJOR 2020
+#define TBB_VERSION_MINOR 3
 
 // Engineering-focused interface version
-#define TBB_INTERFACE_VERSION 9107
+#define TBB_INTERFACE_VERSION 11103
 #define TBB_INTERFACE_VERSION_MAJOR TBB_INTERFACE_VERSION/1000
 
 // The oldest major interface version still supported
@@ -155,8 +151,8 @@ namespace tbb {
 
 #if TBB_USE_ASSERT
 
-    //! Assert that x is true.
-    /** If x is false, print assertion failure message.
+    //! Assert that predicate is true.
+    /** If predicate is false, print assertion failure message.
         If the comment argument is not NULL, it is printed as part of the failure message.
         The comment argument has no other effect. */
     #define __TBB_ASSERT(predicate,message) __TBB_ASSERT_RELEASE(predicate,message)
@@ -246,6 +242,14 @@ const size_t NFS_MaxLineSize = 128;
 #define __TBB_override // formal comment only
 #endif
 
+#if __TBB_CPP17_FALLTHROUGH_PRESENT
+#define __TBB_fallthrough [[fallthrough]]
+#elif __TBB_FALLTHROUGH_PRESENT
+#define __TBB_fallthrough __attribute__ ((fallthrough))
+#else
+#define __TBB_fallthrough
+#endif
+
 template<class T, size_t S, size_t R>
 struct padded_base : T {
     char pad[S - R];
@@ -278,7 +282,7 @@ void __TBB_EXPORTED_FUNC handle_perror( int error_code, const char* aux_info );
     inline bool __TBB_false() { return false; }
     #define __TBB_TRY
     #define __TBB_CATCH(e) if ( tbb::internal::__TBB_false() )
-    #define __TBB_THROW(e) ((void)0)
+    #define __TBB_THROW(e) tbb::internal::suppress_unused_warning(e)
     #define __TBB_RETHROW() ((void)0)
 #endif /* !TBB_USE_EXCEPTIONS */
 
@@ -312,6 +316,25 @@ inline T punned_cast( U* ptr ) {
     return reinterpret_cast<T>(x);
 }
 
+#if __TBB_DEFAULTED_AND_DELETED_FUNC_PRESENT
+
+//! Base class for types that should not be assigned.
+class no_assign {
+public:
+    void operator=( const no_assign& ) = delete;
+    no_assign( const no_assign& ) = default;
+    no_assign() = default;
+};
+
+//! Base class for types that should not be copied or assigned.
+class no_copy: no_assign {
+public:
+    no_copy( const no_copy& ) = delete;
+    no_copy() = default;
+};
+
+#else /*__TBB_DEFAULTED_AND_DELETED_FUNC_PRESENT*/
+
 //! Base class for types that should not be assigned.
 class no_assign {
     // Deny assignment
@@ -332,6 +355,8 @@ class no_copy: no_assign {
     no_copy() {}
 };
 
+#endif /*__TBB_DEFAULTED_AND_DELETED_FUNC_PRESENT*/
+
 #if TBB_DEPRECATED_MUTEX_COPYING
 class mutex_copy_deprecated_and_disabled {};
 #else
@@ -423,17 +448,24 @@ class proportional_split: internal::no_assign {
 // Following is a set of classes and functions typically used in compile-time "metaprogramming".
 // TODO: move all that to a separate header
 
-#if __TBB_ALLOCATOR_TRAITS_PRESENT
-#include <memory> //for allocator_traits
+#if __TBB_CPP11_SMART_POINTERS_PRESENT
+#include <memory> // for unique_ptr
 #endif
 
-#if __TBB_CPP11_RVALUE_REF_PRESENT || _LIBCPP_VERSION
-#include <utility> // for std::move
+#if __TBB_CPP11_RVALUE_REF_PRESENT || __TBB_CPP11_DECLTYPE_PRESENT || _LIBCPP_VERSION
+#include <utility> // for std::move, std::forward, std::declval
 #endif
 
 namespace tbb {
 namespace internal {
 
+#if __TBB_CPP11_SMART_POINTERS_PRESENT && __TBB_CPP11_RVALUE_REF_PRESENT && __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT
+    template<typename T, typename... Args>
+    std::unique_ptr<T> make_unique(Args&&... args) {
+        return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
+    }
+#endif
+
 //! Class for determining type of std::allocator<T>::value_type.
 template<typename T>
 struct allocator_type {
@@ -457,15 +489,6 @@ struct bool_constant {
 typedef bool_constant<true> true_type;
 typedef bool_constant<false> false_type;
 
-#if __TBB_ALLOCATOR_TRAITS_PRESENT
-using std::allocator_traits;
-#else
-template<typename allocator>
-struct allocator_traits{
-    typedef tbb::internal::false_type propagate_on_container_move_assignment;
-};
-#endif
-
 //! A template to select either 32-bit or 64-bit constant as compile time, depending on machine word size.
 template <unsigned u, unsigned long long ull >
 struct select_size_t_constant {
@@ -526,7 +549,7 @@ struct STATIC_ASSERTION_FAILED<true>; //intentionally left undefined to cause co
 //! @endcond
 }} // namespace tbb::internal
 
-#if    __TBB_STATIC_ASSERT_PRESENT
+#if __TBB_STATIC_ASSERT_PRESENT
 #define __TBB_STATIC_ASSERT(condition,msg) static_assert(condition,msg)
 #else
 //please note condition is intentionally inverted to get a bit more understandable error msg
diff --git a/inst/include/tbb/tbb_thread.h b/inst/include/tbb/tbb_thread.h
index d1cafd65..48c11711 100644
--- a/inst/include/tbb/tbb_thread.h
+++ b/inst/include/tbb/tbb_thread.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,15 +12,25 @@
     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 "internal/_deprecated_header_message_guard.h"
 
+#if !defined(__TBB_show_deprecation_message_tbb_thread_H) && defined(__TBB_show_deprecated_header_message)
+#define  __TBB_show_deprecation_message_tbb_thread_H
+#pragma message("TBB Warning: tbb/tbb_thread.h is deprecated. For details, please see Deprecated Features appendix in the TBB reference manual.")
+#endif
 
-
-*/
+#if defined(__TBB_show_deprecated_header_message)
+#undef __TBB_show_deprecated_header_message
+#endif
 
 #ifndef __TBB_tbb_thread_H
 #define __TBB_tbb_thread_H
 
+#define __TBB_tbb_thread_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #include "tbb_stddef.h"
 
 #if _WIN32||_WIN64
@@ -47,19 +57,9 @@ namespace tbb { namespace internal {
 #include "internal/_tbb_hash_compare_impl.h"
 #include "tick_count.h"
 
-#if !TBB_USE_EXCEPTIONS && _MSC_VER
-    // Suppress "C++ exception handler used, but unwind semantics are not enabled" warning in STL headers
-    #pragma warning (push)
-    #pragma warning (disable: 4530)
-#endif
-
 #include __TBB_STD_SWAP_HEADER
 #include <iosfwd>
 
-#if !TBB_USE_EXCEPTIONS && _MSC_VER
-    #pragma warning (pop)
-#endif
-
 namespace tbb {
 
 namespace internal {
@@ -256,7 +256,7 @@ namespace internal {
         friend tbb_thread_v3::id __TBB_EXPORTED_FUNC thread_get_id_v3();
 
         friend inline size_t tbb_hasher( const tbb_thread_v3::id& id ) {
-            __TBB_STATIC_ASSERT(sizeof(id.my_id) <= sizeof(size_t), "Implementaion assumes that thread_id_type fits into machine word");
+            __TBB_STATIC_ASSERT(sizeof(id.my_id) <= sizeof(size_t), "Implementation assumes that thread_id_type fits into machine word");
             return tbb::tbb_hasher(id.my_id);
         }
 
@@ -307,7 +307,7 @@ namespace internal {
 } // namespace internal;
 
 //! Users reference thread class by name tbb_thread
-typedef internal::tbb_thread_v3 tbb_thread;
+__TBB_DEPRECATED_IN_VERBOSE_MODE_MSG("tbb::thread is deprecated, use std::thread") typedef internal::tbb_thread_v3 tbb_thread;
 
 using internal::operator==;
 using internal::operator!=;
@@ -328,15 +328,18 @@ inline void swap( internal::tbb_thread_v3& t1, internal::tbb_thread_v3& t2 )  __
 }
 
 namespace this_tbb_thread {
-    inline tbb_thread::id get_id() { return internal::thread_get_id_v3(); }
+    __TBB_DEPRECATED_IN_VERBOSE_MODE inline tbb_thread::id get_id() { return internal::thread_get_id_v3(); }
     //! Offers the operating system the opportunity to schedule another thread.
-    inline void yield() { internal::thread_yield_v3(); }
+    __TBB_DEPRECATED_IN_VERBOSE_MODE inline void yield() { internal::thread_yield_v3(); }
     //! The current thread blocks at least until the time specified.
-    inline void sleep(const tick_count::interval_t &i) {
+    __TBB_DEPRECATED_IN_VERBOSE_MODE inline void sleep(const tick_count::interval_t &i) {
         internal::thread_sleep_v3(i);
     }
 }  // namespace this_tbb_thread
 
 } // namespace tbb
 
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_tbb_thread_H_include_area
+
 #endif /* __TBB_tbb_thread_H */
diff --git a/inst/include/tbb/tbbmalloc_proxy.h b/inst/include/tbb/tbbmalloc_proxy.h
index 76cbd6d7..28f6a405 100644
--- a/inst/include/tbb/tbbmalloc_proxy.h
+++ b/inst/include/tbb/tbbmalloc_proxy.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 /*
@@ -63,4 +59,7 @@ struct __TBB_malloc_proxy_caller {
 
 #endif // _MSC_VER
 
+/* Public Windows API */
+extern "C" int TBB_malloc_replacement_log(char *** function_replacement_log_ptr);
+
 #endif //__TBB_tbbmalloc_proxy_H
diff --git a/inst/include/tbb/tick_count.h b/inst/include/tbb/tick_count.h
index a7f4e0f3..bbc92476 100644
--- a/inst/include/tbb/tick_count.h
+++ b/inst/include/tbb/tick_count.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_tick_count_H
diff --git a/src/Makevars.in b/src/Makevars.in
index 56c601ee..31c8c99f 100644
--- a/src/Makevars.in
+++ b/src/Makevars.in
@@ -6,7 +6,7 @@ ifeq ($(OS), Windows_NT)
 
   USE_TBB=Windows
   TBB_COPY_PATTERN=tbb*.dll
-  
+
   MAKE = make
   MAKEFLAGS = -e -s -j1
   MAKE_CMD =                                  \
@@ -20,7 +20,7 @@ ifeq ($(OS), Windows_NT)
     $(MAKE)
 
 else
-  
+
   UNAME := $(shell uname)
   TBB_COPY_PATTERN=libtbb*.*
   ifeq ($(UNAME), Darwin)
@@ -49,7 +49,9 @@ endif
 
 ifdef USE_TBB
 
-PKG_CXXFLAGS += -DRCPP_PARALLEL_USE_TBB=1
+PKG_CXXFLAGS +=                         \
+	-DRCPP_PARALLEL_USE_TBB=1            \
+	-DTBB_SUPPRESS_DEPRECATED_MESSAGES=1
 
 MAKE_ARGS := tbb_release tbbmalloc_release tbb_build_prefix=lib
 
@@ -102,4 +104,3 @@ clean:
 	(cd tbb/src; make clean)
 
 endif
-
diff --git a/src/options.cpp b/src/options.cpp
index cf9ab7c4..b8b2fc05 100644
--- a/src/options.cpp
+++ b/src/options.cpp
@@ -8,7 +8,7 @@
 #include <string>
 #include <exception>
 
-#include <tbb/task_scheduler_init.h>
+#include <tbb/global_control.h>
 
 extern "C" SEXP setThreadOptions(SEXP numThreadsSEXP, SEXP stackSizeSEXP) {
 
@@ -48,7 +48,7 @@ extern "C" SEXP defaultNumThreads() {
 #include <tthread/tinythread.h>
 
 extern "C" SEXP setThreadOptions(SEXP numThreadsSEXP, SEXP stackSizeSEXP) {
-   return R_NilValue;   
+   return R_NilValue;
 }
 
 extern "C" SEXP defaultNumThreads() {
diff --git a/src/tbb/.gitattributes b/src/tbb/.gitattributes
new file mode 100644
index 00000000..039edb3a
--- /dev/null
+++ b/src/tbb/.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
diff --git a/src/tbb/.gitignore b/src/tbb/.gitignore
new file mode 100644
index 00000000..9b2411ec
--- /dev/null
+++ b/src/tbb/.gitignore
@@ -0,0 +1,88 @@
+# Ignore the debug and release directories created with Makefile builds #
+#########################################################################
+build/*_debug/
+build/*_release/
+
+# Compiled source #
+###################
+*.com
+*.class
+*.dll
+*.lib
+*.pdb
+*.exe
+*.o
+*.so
+*.so.1
+*.so.2
+*.dylib
+*.a
+*.obj
+*.pyc
+
+*.orig
+*.raw
+*.sample
+*.slo
+*.swp
+*.config
+*.la
+*.lai
+*.lo
+*.nhdr
+*.nii.gz
+*.nrrd
+
+# Packages #
+############
+# it's better to unpack these files and commit the raw source
+# git has its own built in compression methods
+*.7z
+*.dmg
+*.gz
+*.iso
+*.jar
+*.rar
+*.tar
+*.tgz
+*.zip
+
+# Logs and databases #
+######################
+*.log
+*.sql
+*.sqlite
+
+# OS generated files #
+######################
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# IDE generated files #
+######################
+/.ninja_deps
+/.ninja_log
+/build.ninja
+/rules.ninja
+*~
+.emacs.desktop
+.tags
+
+# Build system generated files #
+################################
+CMakeCache.txt
+CMakeFiles/
+
+# Other #
+#########
+.clang_complete
+.idea
+.svn
+crash*
+*.tmp
+/.vs
diff --git a/src/tbb/CHANGES b/src/tbb/CHANGES
index aa7f126f..e96a9699 100644
--- a/src/tbb/CHANGES
+++ b/src/tbb/CHANGES
@@ -2,6 +2,482 @@
 The list of most significant changes made over time in
 Intel(R) Threading Building Blocks (Intel(R) TBB).
 
+Intel TBB 2020 Update 3
+TBB_INTERFACE_VERSION == 11103
+
+Changes (w.r.t. Intel TBB 2020 Update 2):
+
+Changes affecting backward compatibility:
+
+- Changed body type concept of the flow::input_node.
+    Set TBB_DEPRECATED_INPUT_NODE_BODY to 1 to compile with the previous
+    concept of the body type.
+
+Bugs fixed:
+
+- Fixed compilation errors in C++20 mode due to ambiguity of comparison
+    operators. Inspired by Barry Revzin
+    (https://github.com/oneapi-src/oneTBB/pull/251).
+
+Open-source contributions integrated:
+
+- Fixed an issue in TBBBuild.cmake that causes the build with no arguments
+    to fail (https://github.com/oneapi-src/oneTBB/pull/233) by tttapa.
+- Added cmake/{TBBConfig,TBBConfigVersion}.cmake to Git ignore list
+    (https://github.com/oneapi-src/oneTBB/pull/239) by Eisuke Kawashima.
+
+------------------------------------------------------------------------
+Intel TBB 2020 Update 2
+TBB_INTERFACE_VERSION == 11102
+
+Changes (w.r.t. Intel TBB 2020 Update 1):
+
+- Cross-allocator copying constructor and copy assignment operator for
+    concurrent_vector are deprecated.
+- Added input_node to the flow graph API. It acts like a source_node 
+    except for being inactive by default; source_node is deprecated.
+- Allocator template parameter for flow graph nodes is deprecated. Set
+    TBB_DEPRECATED_FLOW_NODE_ALLOCATOR to 1 to avoid compilation errors.
+- Flow graph preview hetero-features are deprecated.
+
+Bugs fixed:
+
+- Fixed the task affinity mechanism to prevent unlimited memory
+    consumption in case the number of threads is explicitly decreased.
+- Fixed memory leak related NUMA support functionality in task_arena.
+
+------------------------------------------------------------------------
+Intel TBB 2020 Update 1
+TBB_INTERFACE_VERSION == 11101
+
+Changes (w.r.t. Intel TBB 2020):
+
+Preview features:
+
+- The NUMA support library (tbbbind) no more depends on the main
+    TBB library.
+
+Bugs fixed:
+
+- Fixed the issue of task_arena constraints not propagated on
+    copy construction.
+- Fixed TBBGet.cmake script broken by TBB package name changes
+    (https://github.com/intel/tbb/issues/209).
+
+------------------------------------------------------------------------
+Intel TBB 2020
+TBB_INTERFACE_VERSION == 11100
+
+Changes (w.r.t. Intel TBB 2019 Update 9):
+
+- Extended task_arena interface to simplify development of NUMA-aware
+    applications.
+- Added warning notifications when the deprecated functionality is used.
+
+Open-source contributions integrated:
+
+- Fixed various build warnings
+    (https://github.com/intel/tbb/pull/179) by Raf Schietekat.
+
+------------------------------------------------------------------------
+Intel TBB 2019 Update 9
+TBB_INTERFACE_VERSION == 11009
+
+Changes (w.r.t. Intel TBB 2019 Update 8):
+
+- Multiple APIs are deprecated. For details, please see
+    Deprecated Features appendix in the TBB reference manual.
+- Added C++17 deduction guides for flow graph nodes.
+
+Preview Features:
+
+- Added isolated_task_group class that allows multiple threads to add
+    and execute tasks sharing the same isolation.
+- Extended the flow graph API to simplify connecting nodes.
+- Added erase() by heterogeneous keys for concurrent ordered containers.
+- Added a possibility to suspend task execution at a specific point
+    and resume it later.
+
+Bugs fixed:
+
+- Fixed the emplace() method of concurrent unordered containers to
+    destroy a temporary element that was not inserted.
+- Fixed a bug in the merge() method of concurrent unordered
+    containers.
+- Fixed behavior of a continue_node that follows buffering nodes.
+- Fixed compilation error caused by missed stdlib.h when CMake
+    integration is used (https://github.com/intel/tbb/issues/195).
+    Inspired by Andrew Penkrat.
+
+Open-source contributions integrated:
+
+- Added support for move-only types to tbb::parallel_pipeline
+    (https://github.com/intel/tbb/pull/159) by Raf Schietekat.
+- Fixed detection of clang version when CUDA toolkit is installed
+    (https://github.com/intel/tbb/pull/150) by Guilherme Amadio.
+
+------------------------------------------------------------------------
+Intel TBB 2019 Update 8
+TBB_INTERFACE_VERSION == 11008
+
+Changes (w.r.t. Intel TBB 2019 Update 7):
+
+Bugs fixed:
+
+- Fixed a bug in TBB 2019 Update 7 that could lead to incorrect memory
+    reallocation on Linux (https://github.com/intel/tbb/issues/148).
+- Fixed enqueuing tbb::task into tbb::task_arena not to fail on threads
+    with no task scheduler initialized
+    (https://github.com/intel/tbb/issues/116).
+
+------------------------------------------------------------------------
+Intel TBB 2019 Update 7
+TBB_INTERFACE_VERSION == 11007
+
+Changes (w.r.t. Intel TBB 2019 Update 6):
+
+- Added TBBMALLOC_SET_HUGE_SIZE_THRESHOLD parameter to set the lower
+    bound for allocations that are not released back to OS unless
+    a cleanup is explicitly requested.
+- Added zip_iterator::base() method to get the tuple of underlying
+    iterators.
+- Improved async_node to never block a thread that sends a message
+    through its gateway.
+- Extended decrement port of the tbb::flow::limiter_node to accept
+    messages of integral types.
+- Added support of Windows* to the CMake module TBBInstallConfig.
+- Added packaging of CMake configuration files to TBB packages built
+    using build/build.py script
+    (https://github.com/intel/tbb/issues/141).
+
+Changes affecting backward compatibility:
+
+- Removed the number_of_decrement_predecessors parameter from the
+    constructor of flow::limiter_node. To allow its usage, set
+    TBB_DEPRECATED_LIMITER_NODE_CONSTRUCTOR macro to 1.
+
+Preview Features:
+
+- Added ordered associative containers:
+    concurrent_{map,multimap,set,multiset} (requires C++11).
+
+Open-source contributions integrated:
+
+- Fixed makefiles to properly obtain the GCC version for GCC 7
+    and later (https://github.com/intel/tbb/pull/147) by Timmmm.
+
+------------------------------------------------------------------------
+Intel TBB 2019 Update 6
+TBB_INTERFACE_VERSION == 11006
+
+Changes (w.r.t. Intel TBB 2019 Update 5):
+
+- Added support for Microsoft* Visual Studio* 2019.
+- Added support for enqueuing tbb::task into tbb::task_arena
+    (https://github.com/01org/tbb/issues/116).
+- Improved support for allocator propagation on concurrent_hash_map
+    assigning and swapping.
+- Improved scalable_allocation_command cleanup operations to release
+    more memory buffered by the calling thread.
+- Separated allocation of small and large objects into distinct memory
+    regions, which helps to reduce excessive memory caching inside the
+    TBB allocator.
+
+Preview Features:
+
+- Removed template class gfx_factory from the flow graph API.
+
+------------------------------------------------------------------------
+Intel TBB 2019 Update 5
+TBB_INTERFACE_VERSION == 11005
+
+Changes (w.r.t. Intel TBB 2019 Update 4):
+
+- Associating a task_scheduler_observer with an implicit or explicit
+    task arena is now a fully supported feature.
+- Added a CMake module TBBInstallConfig that allows to generate and
+    install CMake configuration files for TBB packages.
+    Inspired by Hans Johnson (https://github.com/01org/tbb/pull/119).
+- Added node handles, methods merge() and unsafe_extract() to concurrent
+    unordered containers.
+- Added constructors with Compare argument to concurrent_priority_queue
+    (https://github.com/01org/tbb/issues/109).
+- Controlling the stack size of worker threads is now supported for
+    Universal Windows Platform.
+- Improved tbb::zip_iterator to work with algorithms that swap values
+    via iterators.
+- Improved support for user-specified allocators in concurrent_hash_map,
+    including construction of allocator-aware data types.
+- For ReaderWriterMutex types, upgrades and downgrades now succeed if
+    the mutex is already in the requested state.
+    Inspired by Niadb (https://github.com/01org/tbb/pull/122).
+
+Preview Features:
+
+- The task_scheduler_observer::may_sleep() method has been removed.
+
+Bugs fixed:
+
+- Fixed the issue with a pipeline parallel filter executing serially if
+    it follows a thread-bound filter.
+- Fixed a performance regression observed when multiple parallel
+    algorithms start simultaneously.
+
+------------------------------------------------------------------------
+Intel TBB 2019 Update 4
+TBB_INTERFACE_VERSION == 11004
+
+Changes (w.r.t. Intel TBB 2019 Update 3):
+
+- global_control class is now a fully supported feature.
+- Added deduction guides for tbb containers: concurrent_hash_map,
+    concurrent_unordered_map, concurrent_unordered_set.
+- Added tbb::scalable_memory_resource function returning
+    std::pmr::memory_resource interface to the TBB memory allocator.
+- Added tbb::cache_aligned_resource class that implements
+    std::pmr::memory_resource with cache alignment and no false sharing.
+- Added rml::pool_msize function returning the usable size of a memory
+    block allocated from a given memory pool.
+- Added default and copy constructors for tbb::counting_iterator
+    and tbb::zip_iterator.
+- Added TBB_malloc_replacement_log function to obtain the status of
+    dynamic memory allocation replacement (Windows* only).
+- CMake configuration file now supports release-only and debug-only
+    configurations (https://github.com/01org/tbb/issues/113).
+- TBBBuild CMake module takes the C++ version from CMAKE_CXX_STANDARD.
+
+Bugs fixed:
+
+- Fixed compilation for tbb::concurrent_vector when used with
+    std::pmr::polymorphic_allocator.
+
+Open-source contributions integrated:
+
+- TBB_INTERFACE_VERSION is included into TBB version in CMake
+    configuration (https://github.com/01org/tbb/pull/100)
+    by Hans Johnson.
+- Fixed detection of C++17 deduction guides for Visual C++*
+    (https://github.com/01org/tbb/pull/112) by Marian Klymov.
+
+------------------------------------------------------------------------
+Intel TBB 2019 Update 3
+TBB_INTERFACE_VERSION == 11003
+
+Changes (w.r.t. Intel TBB 2019 Update 2):
+
+- Added tbb::transform_iterator.
+- Added new Makefile target 'profile' to flow graph examples enabling
+    additional support for Intel(R) Parallel Studio XE tools.
+- Added TBB_MALLOC_DISABLE_REPLACEMENT environment variable to switch off
+    dynamic memory allocation replacement on Windows*. Inspired by
+    a contribution from Edward Lam.
+
+Preview Features:
+
+- Extended flow graph API to support relative priorities for functional
+    nodes, specified as an optional parameter to the node constructors.
+
+Open-source contributions integrated:
+
+- Enabled using process-local futex operations
+    (https://github.com/01org/tbb/pull/58) by Andrey Semashev.
+
+------------------------------------------------------------------------
+Intel TBB 2019 Update 2
+TBB_INTERFACE_VERSION == 11002
+
+Changes (w.r.t. Intel TBB 2019 Update 1):
+
+- Added overloads for parallel_reduce with default partitioner and
+    user-supplied context.
+- Added deduction guides for tbb containers: concurrent_vector,
+    concurrent_queue, concurrent_bounded_queue,
+    concurrent_priority_queue.
+- Reallocation of memory objects >1MB now copies and frees memory if
+    the size is decreased twice or more, trading performance off for
+    reduced memory usage.
+- After a period of sleep, TBB worker threads now prefer returning to
+    their last used task arena.
+
+Bugs fixed:
+
+- Fixed compilation of task_group.h when targeting macOS* 10.11 or
+    earlier (https://github.com/conda-forge/tbb-feedstock/issues/42).
+
+Open-source contributions integrated:
+
+- Added constructors with HashCompare argument to concurrent_hash_map
+    (https://github.com/01org/tbb/pull/63) by arewedancer.
+
+------------------------------------------------------------------------
+Intel TBB 2019 Update 1
+TBB_INTERFACE_VERSION == 11001
+
+Changes (w.r.t. Intel TBB 2019):
+
+- Doxygen documentation could be built with 'make doxygen' command now.
+
+Changes affecting backward compatibility:
+
+- Enforced 8 byte alignment for tbb::atomic<long long> and
+    tbb::atomic<double>. On IA-32 architecture it may cause layout
+    changes in structures that use these types.
+
+Bugs fixed:
+
+- Fixed an issue with dynamic memory allocation replacement on Windows*
+    occurred for some versions of ucrtbase.dll.
+- Fixed possible deadlock in tbbmalloc cleanup procedure during process
+    shutdown. Inspired by a contribution from Edward Lam.
+- Fixed usage of std::uncaught_exception() deprecated in C++17
+   (https://github.com/01org/tbb/issues/67).
+- Fixed a crash when a local observer is activated after an arena
+    observer.
+- Fixed compilation of task_group.h by Visual C++* 15.7 with
+    /permissive- option (https://github.com/01org/tbb/issues/53).
+- Fixed tbb4py to avoid dependency on Intel(R) C++ Compiler shared
+    libraries.
+- Fixed compilation for Anaconda environment with GCC 7.3 and higher.
+
+Open-source contributions integrated:
+
+- Fix various warnings when building with Visual C++
+    (https://github.com/01org/tbb/pull/70) by Edward Lam.
+
+------------------------------------------------------------------------
+Intel TBB 2019
+TBB_INTERFACE_VERSION == 11000
+
+Changes (w.r.t. Intel TBB 2018 Update 5):
+
+- Lightweight policy for functional nodes in the flow graph is now
+    a fully supported feature.
+- Reservation support in flow::write_once_node and flow::overwrite_node
+    is now a fully supported feature.
+- Support for Flow Graph Analyzer and improvements for
+    Intel(R) VTune(TM) Amplifier become a regular feature enabled by
+    TBB_USE_THREADING_TOOLS macro.
+- Added support for std::new_handler in the replacement functions for
+    global operator new.
+- Added C++14 constructors to concurrent unordered containers.
+- Added tbb::counting_iterator and tbb::zip_iterator.
+- Fixed multiple -Wextra warnings in TBB source files.
+
+Preview Features:
+
+- Extracting nodes from a flow graph is deprecated and disabled by
+    default. To enable, use TBB_DEPRECATED_FLOW_NODE_EXTRACTION macro.
+
+Changes affecting backward compatibility:
+
+- Due to internal changes in the flow graph classes, recompilation is
+    recommended for all binaries that use the flow graph.
+
+Open-source contributions integrated:
+
+- Added support for OpenBSD by Anthony J. Bentley.
+
+------------------------------------------------------------------------
+Intel TBB 2018 Update 6
+TBB_INTERFACE_VERSION == 10006
+
+Changes (w.r.t. Intel TBB 2018 Update 5):
+
+Bugs fixed:
+
+- Fixed an issue with dynamic memory allocation replacement on Windows*
+    occurred for some versions of ucrtbase.dll.
+
+------------------------------------------------------------------------
+Intel TBB 2018 Update 5
+TBB_INTERFACE_VERSION == 10005
+
+Changes (w.r.t. Intel TBB 2018 Update 4):
+
+Preview Features:
+
+- Added user event tracing API for Intel(R) VTune(TM) Amplifier and
+    Flow Graph Analyzer.
+
+Bugs fixed:
+
+- Fixed the memory allocator to properly support transparent huge pages.
+- Removed dynamic exception specifications in tbbmalloc_proxy for C++11
+    and later (https://github.com/01org/tbb/issues/41).
+- Added -flifetime-dse=1 option when building with GCC on macOS*
+    (https://github.com/01org/tbb/issues/60).
+
+Open-source contributions integrated:
+
+- Added ARMv8 support by Siddhesh Poyarekar.
+- Avoid GCC warnings for clearing an object of non-trivial type
+    (https://github.com/01org/tbb/issues/54) by Daniel Arndt.
+
+------------------------------------------------------------------------
+Intel TBB 2018 Update 4
+TBB_INTERFACE_VERSION == 10004
+
+Changes (w.r.t. Intel TBB 2018 Update 3):
+
+Preview Features:
+
+- Improved support for Flow Graph Analyzer and Intel(R) VTune(TM)
+    Amplifier in the task scheduler and generic parallel algorithms.
+- Default device set for opencl_node now includes all the devices from
+    the first available OpenCL* platform.
+- Added lightweight policy for functional nodes in the flow graph. It
+    indicates that the node body has little work and should, if possible,
+    be executed immediately upon receiving a message, avoiding task
+    scheduling overhead.
+
+------------------------------------------------------------------------
+Intel TBB 2018 Update 3
+TBB_INTERFACE_VERSION == 10003
+
+Changes (w.r.t. Intel TBB 2018 Update 2):
+
+Preview Features:
+
+- Added template class blocked_rangeNd for a generic multi-dimensional
+    range (requires C++11). Inspired by a contribution from Jeff Hammond.
+
+Bugs fixed:
+
+- Fixed a crash with dynamic memory allocation replacement on
+    Windows* for applications using system() function.
+- Fixed parallel_deterministic_reduce to split range correctly when used
+     with static_partitioner.
+- Fixed a synchronization issue in task_group::run_and_wait() which
+    caused a simultaneous call to task_group::wait() to return
+    prematurely.
+
+------------------------------------------------------------------------
+Intel TBB 2018 Update 2
+TBB_INTERFACE_VERSION == 10002
+
+Changes (w.r.t. Intel TBB 2018 Update 1):
+
+- Added support for Android* NDK r16, macOS* 10.13, Fedora* 26.
+- Binaries for Universal Windows Driver (vc14_uwd) now link with static
+    Microsoft* runtime libraries, and are only available in commercial
+    releases.
+- Extended flow graph documentation with more code samples.
+
+Preview Features:
+
+- Added a Python* module for multi-processing computations in numeric
+    Python* libraries.
+
+Bugs fixed:
+
+- Fixed constructors of concurrent_hash_map to be exception-safe.
+- Fixed auto-initialization in the main thread to be cleaned up at
+    shutdown.
+- Fixed a crash when tbbmalloc_proxy is used together with dbghelp.
+- Fixed static_partitioner to assign tasks properly in case of nested
+    parallelism.
+
+------------------------------------------------------------------------
 Intel TBB 2018 Update 1
 TBB_INTERFACE_VERSION == 10001
 
@@ -235,7 +711,7 @@ Changes (w.r.t. Intel TBB 4.4 Update 5):
 - Added TBB_USE_GLIBCXX_VERSION macro to specify the version of GNU
     libstdc++ when it cannot be properly recognized, e.g. when used
     with Clang on Linux* OS. Inspired by a contribution from David A.
-- Added graph/stereo example to demostrate tbb::flow::async_msg.
+- Added graph/stereo example to demonstrate tbb::flow::async_msg.
 - Removed a few cases of excessive user data copying in the flow graph.
 - Reworked split_node to eliminate unnecessary overheads.
 - Added support for C++11 move semantics to the argument of
@@ -946,7 +1422,7 @@ Changes (w.r.t. Intel TBB 4.1 Update 4):
     were added on OS X*.
 - For OS X* exact exception propagation is supported with Clang;
     it requires use of libc++ and corresponding Intel TBB binaries.
-- Support for C++11 initializer lists in constructor and assigment
+- Support for C++11 initializer lists in constructor and assignment
     has been added to concurrent_hash_map, concurrent_unordered_set,
     concurrent_unordered_multiset, concurrent_unordered_map,
     concurrent_unordered_multimap.
@@ -1542,7 +2018,7 @@ Changes (w.r.t. 20100310 open-source release):
 - Reworked enumerable_thread_specific to use a custom implementation of
     hash map that is more efficient for ETS usage models.
 - Added example for class task_group; see examples/task_group/sudoku.
-- Removed two examples, as they were long outdated and superceded:
+- Removed two examples, as they were long outdated and superseded:
     pipeline/text_filter (use pipeline/square);
     parallel_while/parallel_preorder (use parallel_do/parallel_preorder).
 - PDF documentation updated.
@@ -1760,7 +2236,7 @@ Changes (w.r.t. Intel TBB 2.1 U3 commercial-aligned release):
 
 - Added tests for aligned memory allocations and malloc replacement.
 - Several improvements for better bundling with Intel(R) C++ Compiler.
-- A few other small changes in code and documentaion.
+- A few other small changes in code and documentation.
 
 Bugs fixed:
 
diff --git a/src/tbb/Doxyfile b/src/tbb/Doxyfile
new file mode 100644
index 00000000..3c7727f8
--- /dev/null
+++ b/src/tbb/Doxyfile
@@ -0,0 +1,1325 @@
+# Doxyfile 1.4.7
+
+# This file describes the settings to be used by the documentation system
+# doxygen (www.doxygen.org) for a project
+#
+# All text after a hash (#) is considered a comment and will be ignored
+# The format is:
+#       TAG = value [value, ...]
+# For lists items can also be appended using:
+#       TAG += value [value, ...]
+# Values that contain spaces should be placed between quotes (" ")
+
+#---------------------------------------------------------------------------
+# Project related configuration options
+#---------------------------------------------------------------------------
+
+# The PROJECT_NAME tag is a single word (or a sequence of words surrounded 
+# by quotes) that should identify the project.
+
+PROJECT_NAME           = "Intel(R) Threading Building Blocks Doxygen Documentation"
+
+# The PROJECT_NUMBER tag can be used to enter a project or revision number. 
+# This could be handy for archiving the generated documentation or 
+# if some version control system is used.
+
+PROJECT_NUMBER         = "version 4.2.3"
+
+# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) 
+# base path where the generated documentation will be put. 
+# If a relative path is entered, it will be relative to the location 
+# where doxygen was started. If left blank the current directory will be used.
+
+OUTPUT_DIRECTORY       =
+
+# If the CREATE_SUBDIRS tag is set to YES, then doxygen will create 
+# 4096 sub-directories (in 2 levels) under the output directory of each output 
+# format and will distribute the generated files over these directories. 
+# Enabling this option can be useful when feeding doxygen a huge amount of 
+# source files, where putting all generated files in the same directory would 
+# otherwise cause performance problems for the file system.
+
+CREATE_SUBDIRS         = NO
+
+# The OUTPUT_LANGUAGE tag is used to specify the language in which all 
+# documentation generated by doxygen is written. Doxygen will use this 
+# information to generate all constant output in the proper language. 
+# The default language is English, other supported languages are: 
+# Brazilian, Catalan, Chinese, Chinese-Traditional, Croatian, Czech, Danish, 
+# Dutch, Finnish, French, German, Greek, Hungarian, Italian, Japanese, 
+# Japanese-en (Japanese with English messages), Korean, Korean-en, Norwegian, 
+# Polish, Portuguese, Romanian, Russian, Serbian, Slovak, Slovene, Spanish, 
+# Swedish, and Ukrainian.
+
+OUTPUT_LANGUAGE        = English
+
+# This tag can be used to specify the encoding used in the generated output. 
+# The encoding is not always determined by the language that is chosen, 
+# but also whether or not the output is meant for Windows or non-Windows users. 
+# In case there is a difference, setting the USE_WINDOWS_ENCODING tag to YES 
+# forces the Windows encoding (this is the default for the Windows binary), 
+# whereas setting the tag to NO uses a Unix-style encoding (the default for 
+# all platforms other than Windows).
+
+USE_WINDOWS_ENCODING   = NO
+
+# If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will 
+# include brief member descriptions after the members that are listed in 
+# the file and class documentation (similar to JavaDoc). 
+# Set to NO to disable this.
+
+BRIEF_MEMBER_DESC      = YES
+
+# If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend 
+# the brief description of a member or function before the detailed description. 
+# Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the 
+# brief descriptions will be completely suppressed.
+
+REPEAT_BRIEF           = YES
+
+# This tag implements a quasi-intelligent brief description abbreviator 
+# that is used to form the text in various listings. Each string 
+# in this list, if found as the leading text of the brief description, will be 
+# stripped from the text and the result after processing the whole list, is 
+# used as the annotated text. Otherwise, the brief description is used as-is. 
+# If left blank, the following values are used ("$name" is automatically 
+# replaced with the name of the entity): "The $name class" "The $name widget" 
+# "The $name file" "is" "provides" "specifies" "contains" 
+# "represents" "a" "an" "the"
+
+ABBREVIATE_BRIEF       = 
+
+# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then 
+# Doxygen will generate a detailed section even if there is only a brief 
+# description.
+
+ALWAYS_DETAILED_SEC    = NO
+
+# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all 
+# inherited members of a class in the documentation of that class as if those 
+# members were ordinary class members. Constructors, destructors and assignment 
+# operators of the base classes will not be shown.
+
+INLINE_INHERITED_MEMB  = NO
+
+# If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full 
+# path before files name in the file list and in the header files. If set 
+# to NO the shortest path that makes the file name unique will be used.
+
+FULL_PATH_NAMES        = NO
+
+# If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag 
+# can be used to strip a user-defined part of the path. Stripping is 
+# only done if one of the specified strings matches the left-hand part of 
+# the path. The tag can be used to show relative paths in the file list. 
+# If left blank the directory from which doxygen is run is used as the 
+# path to strip.
+
+STRIP_FROM_PATH        = 
+
+# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of 
+# the path mentioned in the documentation of a class, which tells 
+# the reader which header file to include in order to use a class. 
+# If left blank only the name of the header file containing the class 
+# definition is used. Otherwise one should specify the include paths that 
+# are normally passed to the compiler using the -I flag.
+
+STRIP_FROM_INC_PATH    = 
+
+# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter 
+# (but less readable) file names. This can be useful is your file systems 
+# doesn't support long names like on DOS, Mac, or CD-ROM.
+
+SHORT_NAMES            = YES
+
+# If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen 
+# will interpret the first line (until the first dot) of a JavaDoc-style 
+# comment as the brief description. If set to NO, the JavaDoc 
+# comments will behave just like the Qt-style comments (thus requiring an 
+# explicit @brief command for a brief description.
+
+JAVADOC_AUTOBRIEF      = NO
+
+# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make Doxygen 
+# treat a multi-line C++ special comment block (i.e. a block of //! or /// 
+# comments) as a brief description. This used to be the default behaviour. 
+# The new default is to treat a multi-line C++ comment block as a detailed 
+# description. Set this tag to YES if you prefer the old behaviour instead.
+
+MULTILINE_CPP_IS_BRIEF = NO
+
+# If the DETAILS_AT_TOP tag is set to YES then Doxygen 
+# will output the detailed description near the top, like JavaDoc.
+# If set to NO, the detailed description appears after the member 
+# documentation.
+
+DETAILS_AT_TOP         = NO
+
+# If the INHERIT_DOCS tag is set to YES (the default) then an undocumented 
+# member inherits the documentation from any documented member that it 
+# re-implements.
+
+INHERIT_DOCS           = YES
+
+# If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce 
+# a new page for each member. If set to NO, the documentation of a member will 
+# be part of the file/class/namespace that contains it.
+
+SEPARATE_MEMBER_PAGES  = NO
+
+# The TAB_SIZE tag can be used to set the number of spaces in a tab. 
+# Doxygen uses this value to replace tabs by spaces in code fragments.
+
+TAB_SIZE               = 8
+
+# This tag can be used to specify a number of aliases that acts 
+# as commands in the documentation. An alias has the form "name=value". 
+# For example adding "sideeffect=\par Side Effects:\n" will allow you to 
+# put the command \sideeffect (or @sideeffect) in the documentation, which 
+# will result in a user-defined paragraph with heading "Side Effects:". 
+# You can put \n's in the value part of an alias to insert newlines.
+
+ALIASES                = 
+
+# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C 
+# sources only. Doxygen will then generate output that is more tailored for C. 
+# For instance, some of the names that are used will be different. The list 
+# of all members will be omitted, etc.
+
+OPTIMIZE_OUTPUT_FOR_C  = NO
+
+# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java 
+# sources only. Doxygen will then generate output that is more tailored for Java. 
+# For instance, namespaces will be presented as packages, qualified scopes 
+# will look different, etc.
+
+OPTIMIZE_OUTPUT_JAVA   = NO
+
+# If the MARKDOWN_SUPPORT tag is enabled then doxygen pre-processes all comments
+# according to the Markdown format, which allows for more readable
+# documentation. See http://daringfireball.net/projects/markdown/ for details.
+# The output of markdown processing is further processed by doxygen, so you can
+# mix doxygen, HTML, and XML commands with Markdown formatting. Disable only in
+# case of backward compatibilities issues.
+# The default value is: YES.
+
+MARKDOWN_SUPPORT       = YES
+
+# When the TOC_INCLUDE_HEADINGS tag is set to a non-zero value, all headings up
+# to that level are automatically included in the table of contents, even if
+# they do not have an id attribute.
+# Note: This feature currently applies only to Markdown headings.
+# Minimum value: 0, maximum value: 99, default value: 0.
+# This tag requires that the tag MARKDOWN_SUPPORT is set to YES.
+
+TOC_INCLUDE_HEADINGS   = 0
+
+# When enabled doxygen tries to link words that correspond to documented
+# classes, or namespaces to their corresponding documentation. Such a link can
+# be prevented in individual cases by putting a % sign in front of the word or
+# globally by setting AUTOLINK_SUPPORT to NO.
+# The default value is: YES.
+
+AUTOLINK_SUPPORT       = YES
+
+# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want to 
+# include (a tag file for) the STL sources as input, then you should 
+# set this tag to YES in order to let doxygen match functions declarations and 
+# definitions whose arguments contain STL classes (e.g. func(std::string); v.s. 
+# func(std::string) {}). This also make the inheritance and collaboration 
+# diagrams that involve STL classes more complete and accurate.
+
+BUILTIN_STL_SUPPORT    = YES
+
+# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC 
+# tag is set to YES, then doxygen will reuse the documentation of the first 
+# member in the group (if any) for the other members of the group. By default 
+# all members of a group must be documented explicitly.
+
+DISTRIBUTE_GROUP_DOC   = NO
+
+# Set the SUBGROUPING tag to YES (the default) to allow class member groups of 
+# the same type (for instance a group of public functions) to be put as a 
+# subgroup of that type (e.g. under the Public Functions section). Set it to 
+# NO to prevent subgrouping. Alternatively, this can be done per class using 
+# the \nosubgrouping command.
+
+SUBGROUPING            = YES
+
+#---------------------------------------------------------------------------
+# Build related configuration options
+#---------------------------------------------------------------------------
+
+# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in 
+# documentation are documented, even if no documentation was available. 
+# Private class members and static file members will be hidden unless 
+# the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES
+
+EXTRACT_ALL            = YES
+
+# If the EXTRACT_PRIVATE tag is set to YES all private members of a class 
+# will be included in the documentation.
+
+EXTRACT_PRIVATE        = YES
+
+# If the EXTRACT_STATIC tag is set to YES all static members of a file 
+# will be included in the documentation.
+
+EXTRACT_STATIC         = YES
+
+# If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs) 
+# defined locally in source files will be included in the documentation. 
+# If set to NO only classes defined in header files are included.
+
+EXTRACT_LOCAL_CLASSES  = YES
+
+# This flag is only useful for Objective-C code. When set to YES local 
+# methods, which are defined in the implementation section but not in 
+# the interface are included in the documentation. 
+# If set to NO (the default) only methods in the interface are included.
+
+EXTRACT_LOCAL_METHODS  = NO
+
+# If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all 
+# undocumented members of documented classes, files or namespaces. 
+# If set to NO (the default) these members will be included in the 
+# various overviews, but no documentation section is generated. 
+# This option has no effect if EXTRACT_ALL is enabled.
+
+HIDE_UNDOC_MEMBERS     = NO
+
+# If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all 
+# undocumented classes that are normally visible in the class hierarchy. 
+# If set to NO (the default) these classes will be included in the various 
+# overviews. This option has no effect if EXTRACT_ALL is enabled.
+
+HIDE_UNDOC_CLASSES     = NO
+
+# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, Doxygen will hide all 
+# friend (class|struct|union) declarations. 
+# If set to NO (the default) these declarations will be included in the 
+# documentation.
+
+HIDE_FRIEND_COMPOUNDS  = NO
+
+# If the HIDE_IN_BODY_DOCS tag is set to YES, Doxygen will hide any 
+# documentation blocks found inside the body of a function. 
+# If set to NO (the default) these blocks will be appended to the 
+# function's detailed documentation block.
+
+HIDE_IN_BODY_DOCS      = NO
+
+# The INTERNAL_DOCS tag determines if documentation 
+# that is typed after a \internal command is included. If the tag is set 
+# to NO (the default) then the documentation will be excluded. 
+# Set it to YES to include the internal documentation.
+
+INTERNAL_DOCS          = YES
+
+# If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate 
+# file names in lower-case letters. If set to YES upper-case letters are also 
+# allowed. This is useful if you have classes or files whose names only differ 
+# in case and if your file system supports case sensitive file names. Windows 
+# and Mac users are advised to set this option to NO.
+
+CASE_SENSE_NAMES       = YES
+
+# If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen 
+# will show members with their full class and namespace scopes in the 
+# documentation. If set to YES the scope will be hidden.
+
+HIDE_SCOPE_NAMES       = NO
+
+# If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen 
+# will put a list of the files that are included by a file in the documentation 
+# of that file.
+
+SHOW_INCLUDE_FILES     = YES
+
+# If the INLINE_INFO tag is set to YES (the default) then a tag [inline] 
+# is inserted in the documentation for inline members.
+
+INLINE_INFO            = YES
+
+# If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen 
+# will sort the (detailed) documentation of file and class members 
+# alphabetically by member name. If set to NO the members will appear in 
+# declaration order.
+
+SORT_MEMBER_DOCS       = YES
+
+# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the 
+# brief documentation of file, namespace and class members alphabetically 
+# by member name. If set to NO (the default) the members will appear in 
+# declaration order.
+
+SORT_BRIEF_DOCS        = NO
+
+# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be 
+# sorted by fully-qualified names, including namespaces. If set to 
+# NO (the default), the class list will be sorted only by class name, 
+# not including the namespace part. 
+# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES.
+# Note: This option applies only to the class list, not to the 
+# alphabetical list.
+
+SORT_BY_SCOPE_NAME     = NO
+
+# The GENERATE_TODOLIST tag can be used to enable (YES) or 
+# disable (NO) the todo list. This list is created by putting \todo 
+# commands in the documentation.
+
+GENERATE_TODOLIST      = NO
+
+# The GENERATE_TESTLIST tag can be used to enable (YES) or 
+# disable (NO) the test list. This list is created by putting \test 
+# commands in the documentation.
+
+GENERATE_TESTLIST      = NO
+
+# The GENERATE_BUGLIST tag can be used to enable (YES) or 
+# disable (NO) the bug list. This list is created by putting \bug 
+# commands in the documentation.
+
+GENERATE_BUGLIST       = NO
+
+# The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or 
+# disable (NO) the deprecated list. This list is created by putting 
+# \deprecated commands in the documentation.
+
+GENERATE_DEPRECATEDLIST= YES
+
+# The ENABLED_SECTIONS tag can be used to enable conditional 
+# documentation sections, marked by \if sectionname ... \endif.
+
+ENABLED_SECTIONS       = INTERNAL
+
+# The MAX_INITIALIZER_LINES tag determines the maximum number of lines 
+# the initial value of a variable or define consists of for it to appear in 
+# the documentation. If the initializer consists of more lines than specified 
+# here it will be hidden. Use a value of 0 to hide initializers completely. 
+# The appearance of the initializer of individual variables and defines in the 
+# documentation can be controlled using \showinitializer or \hideinitializer 
+# command in the documentation regardless of this setting.
+
+MAX_INITIALIZER_LINES  = 30
+
+# Set the SHOW_USED_FILES tag to NO to disable the list of files generated 
+# at the bottom of the documentation of classes and structs. If set to YES the 
+# list will mention the files that were used to generate the documentation.
+
+SHOW_USED_FILES        = YES
+
+# If the sources in your project are distributed over multiple directories 
+# then setting the SHOW_DIRECTORIES tag to YES will show the directory hierarchy 
+# in the documentation. The default is NO.
+
+SHOW_DIRECTORIES       = YES
+
+# The FILE_VERSION_FILTER tag can be used to specify a program or script that 
+# doxygen should invoke to get the current version for each file (typically from the 
+# version control system). Doxygen will invoke the program by executing (via 
+# popen()) the command <command> <input-file>, where <command> is the value of 
+# the FILE_VERSION_FILTER tag, and <input-file> is the name of an input file 
+# provided by doxygen. Whatever the program writes to standard output 
+# is used as the file version. See the manual for examples.
+
+FILE_VERSION_FILTER    = 
+
+#---------------------------------------------------------------------------
+# configuration options related to warning and progress messages
+#---------------------------------------------------------------------------
+
+# The QUIET tag can be used to turn on/off the messages that are generated 
+# by doxygen. Possible values are YES and NO. If left blank NO is used.
+
+QUIET                  = NO
+
+# The WARNINGS tag can be used to turn on/off the warning messages that are 
+# generated by doxygen. Possible values are YES and NO. If left blank 
+# NO is used.
+
+WARNINGS               = YES
+
+# If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings 
+# for undocumented members. If EXTRACT_ALL is set to YES then this flag will 
+# automatically be disabled.
+
+WARN_IF_UNDOCUMENTED   = YES
+
+# If WARN_IF_DOC_ERROR is set to YES, doxygen will generate warnings for 
+# potential errors in the documentation, such as not documenting some 
+# parameters in a documented function, or documenting parameters that 
+# don't exist or using markup commands wrongly.
+
+WARN_IF_DOC_ERROR      = YES
+
+# This WARN_NO_PARAMDOC option can be abled to get warnings for 
+# functions that are documented, but have no documentation for their parameters 
+# or return value. If set to NO (the default) doxygen will only warn about 
+# wrong or incomplete parameter documentation, but not about the absence of 
+# documentation.
+
+WARN_NO_PARAMDOC       = NO
+
+# The WARN_FORMAT tag determines the format of the warning messages that 
+# doxygen can produce. The string should contain the $file, $line, and $text 
+# tags, which will be replaced by the file and line number from which the 
+# warning originated and the warning text. Optionally the format may contain 
+# $version, which will be replaced by the version of the file (if it could 
+# be obtained via FILE_VERSION_FILTER)
+
+WARN_FORMAT            = "$file:$line: $text"
+
+# The WARN_LOGFILE tag can be used to specify a file to which warning 
+# and error messages should be written. If left blank the output is written 
+# to stderr.
+
+WARN_LOGFILE           = 
+
+#---------------------------------------------------------------------------
+# configuration options related to the input files
+#---------------------------------------------------------------------------
+
+# The INPUT tag can be used to specify the files and/or directories that contain 
+# documented source files. You may enter file names like "myfile.cpp" or 
+# directories like "/usr/src/myproject". Separate the files or directories 
+# with spaces.
+
+INPUT                  = include/ src/tbb/
+
+# If the value of the INPUT tag contains directories, you can use the 
+# FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp 
+# and *.h) to filter out the source-files in the directories. If left 
+# blank the following patterns are tested: 
+# *.c *.cc *.cxx *.cpp *.c++ *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh *.hxx 
+# *.hpp *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm *.py
+
+FILE_PATTERNS          = 
+
+# The RECURSIVE tag can be used to turn specify whether or not subdirectories 
+# should be searched for input files as well. Possible values are YES and NO. 
+# If left blank NO is used.
+
+RECURSIVE              = YES
+
+# The EXCLUDE tag can be used to specify files and/or directories that should 
+# excluded from the INPUT source files. This way you can easily exclude a 
+# subdirectory from a directory tree whose root is specified with the INPUT tag.
+
+EXCLUDE                = 
+
+# The EXCLUDE_SYMLINKS tag can be used select whether or not files or 
+# directories that are symbolic links (a Unix filesystem feature) are excluded 
+# from the input.
+
+EXCLUDE_SYMLINKS       = NO
+
+# If the value of the INPUT tag contains directories, you can use the 
+# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude 
+# certain files from those directories. Note that the wildcards are matched 
+# against the file with absolute path, so to exclude all test directories 
+# for example use the pattern */test/*
+
+EXCLUDE_PATTERNS       = 
+
+# The EXAMPLE_PATH tag can be used to specify one or more files or 
+# directories that contain example code fragments that are included (see 
+# the \include command).
+
+EXAMPLE_PATH           = 
+
+# If the value of the EXAMPLE_PATH tag contains directories, you can use the 
+# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp 
+# and *.h) to filter out the source-files in the directories. If left 
+# blank all files are included.
+
+EXAMPLE_PATTERNS       = 
+
+# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be 
+# searched for input files to be used with the \include or \dontinclude 
+# commands irrespective of the value of the RECURSIVE tag. 
+# Possible values are YES and NO. If left blank NO is used.
+
+EXAMPLE_RECURSIVE      = NO
+
+# The IMAGE_PATH tag can be used to specify one or more files or 
+# directories that contain image that are included in the documentation (see 
+# the \image command).
+
+IMAGE_PATH             = 
+
+# The INPUT_FILTER tag can be used to specify a program that doxygen should 
+# invoke to filter for each input file. Doxygen will invoke the filter program 
+# by executing (via popen()) the command <filter> <input-file>, where <filter> 
+# is the value of the INPUT_FILTER tag, and <input-file> is the name of an 
+# input file. Doxygen will then use the output that the filter program writes 
+# to standard output.  If FILTER_PATTERNS is specified, this tag will be 
+# ignored.
+
+INPUT_FILTER           = 
+
+# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern 
+# basis.  Doxygen will compare the file name with each pattern and apply the 
+# filter if there is a match.  The filters are a list of the form: 
+# pattern=filter (like *.cpp=my_cpp_filter). See INPUT_FILTER for further 
+# info on how filters are used. If FILTER_PATTERNS is empty, INPUT_FILTER 
+# is applied to all files.
+
+FILTER_PATTERNS        = 
+
+# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using 
+# INPUT_FILTER) will be used to filter the input files when producing source 
+# files to browse (i.e. when SOURCE_BROWSER is set to YES).
+
+FILTER_SOURCE_FILES    = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to source browsing
+#---------------------------------------------------------------------------
+
+# If the SOURCE_BROWSER tag is set to YES then a list of source files will 
+# be generated. Documented entities will be cross-referenced with these sources. 
+# Note: To get rid of all source code in the generated output, make sure also 
+# VERBATIM_HEADERS is set to NO.
+
+SOURCE_BROWSER         = YES
+
+# Setting the INLINE_SOURCES tag to YES will include the body 
+# of functions and classes directly in the documentation.
+
+INLINE_SOURCES         = YES
+
+# Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct 
+# doxygen to hide any special comment blocks from generated source code 
+# fragments. Normal C and C++ comments will always remain visible.
+
+STRIP_CODE_COMMENTS    = YES
+
+# If the REFERENCED_BY_RELATION tag is set to YES (the default) 
+# then for each documented function all documented 
+# functions referencing it will be listed.
+
+REFERENCED_BY_RELATION = YES
+
+# If the REFERENCES_RELATION tag is set to YES (the default) 
+# then for each documented function all documented entities 
+# called/used by that function will be listed.
+
+REFERENCES_RELATION    = YES
+
+# If the REFERENCES_LINK_SOURCE tag is set to YES (the default)
+# and SOURCE_BROWSER tag is set to YES, then the hyperlinks from
+# functions in REFERENCES_RELATION and REFERENCED_BY_RELATION lists will
+# link to the source code.  Otherwise they will link to the documentstion.
+
+REFERENCES_LINK_SOURCE = NO
+
+# If the USE_HTAGS tag is set to YES then the references to source code 
+# will point to the HTML generated by the htags(1) tool instead of doxygen 
+# built-in source browser. The htags tool is part of GNU's global source 
+# tagging system (see http://www.gnu.org/software/global/global.html). You 
+# will need version 4.8.6 or higher.
+
+USE_HTAGS              = NO
+
+# If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen 
+# will generate a verbatim copy of the header file for each class for 
+# which an include is specified. Set to NO to disable this.
+
+VERBATIM_HEADERS       = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the alphabetical class index
+#---------------------------------------------------------------------------
+
+# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index 
+# of all compounds will be generated. Enable this if the project 
+# contains a lot of classes, structs, unions or interfaces.
+
+ALPHABETICAL_INDEX     = YES
+
+# If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then 
+# the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns 
+# in which this list will be split (can be a number in the range [1..20])
+
+COLS_IN_ALPHA_INDEX    = 5
+
+# In case all classes in a project start with a common prefix, all 
+# classes will be put under the same header in the alphabetical index. 
+# The IGNORE_PREFIX tag can be used to specify one or more prefixes that 
+# should be ignored while generating the index headers.
+
+IGNORE_PREFIX          = 
+
+#---------------------------------------------------------------------------
+# configuration options related to the HTML output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_HTML tag is set to YES (the default) Doxygen will 
+# generate HTML output.
+
+GENERATE_HTML          = YES
+
+# The HTML_OUTPUT tag is used to specify where the HTML docs will be put. 
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be 
+# put in front of it. If left blank `html' will be used as the default path.
+
+HTML_OUTPUT            = html
+
+# The HTML_FILE_EXTENSION tag can be used to specify the file extension for 
+# each generated HTML page (for example: .htm,.php,.asp). If it is left blank 
+# doxygen will generate files with .html extension.
+
+HTML_FILE_EXTENSION    = .html
+
+# The HTML_HEADER tag can be used to specify a personal HTML header for 
+# each generated HTML page. If it is left blank doxygen will generate a 
+# standard header.
+
+HTML_HEADER            = 
+
+# The HTML_FOOTER tag can be used to specify a personal HTML footer for 
+# each generated HTML page. If it is left blank doxygen will generate a 
+# standard footer.
+
+HTML_FOOTER            = doc/copyright_brand_disclaimer_doxygen.txt
+
+# The HTML_STYLESHEET tag can be used to specify a user-defined cascading 
+# style sheet that is used by each HTML page. It can be used to 
+# fine-tune the look of the HTML output. If the tag is left blank doxygen 
+# will generate a default style sheet. Note that doxygen will try to copy 
+# the style sheet file to the HTML output directory, so don't put your own 
+# stylesheet in the HTML output directory as well, or it will be erased!
+
+HTML_STYLESHEET        = 
+
+# If the HTML_ALIGN_MEMBERS tag is set to YES, the members of classes, 
+# files or namespaces will be aligned in HTML using tables. If set to 
+# NO a bullet list will be used.
+
+HTML_ALIGN_MEMBERS     = YES
+
+# If the GENERATE_HTMLHELP tag is set to YES, additional index files 
+# will be generated that can be used as input for tools like the 
+# Microsoft HTML help workshop to generate a compressed HTML help file (.chm) 
+# of the generated HTML documentation.
+
+GENERATE_HTMLHELP      = NO
+
+# If the GENERATE_HTMLHELP tag is set to YES, the CHM_FILE tag can 
+# be used to specify the file name of the resulting .chm file. You 
+# can add a path in front of the file if the result should not be 
+# written to the html output directory.
+
+CHM_FILE               = 
+
+# If the GENERATE_HTMLHELP tag is set to YES, the HHC_LOCATION tag can 
+# be used to specify the location (absolute path including file name) of 
+# the HTML help compiler (hhc.exe). If non-empty doxygen will try to run 
+# the HTML help compiler on the generated index.hhp.
+
+HHC_LOCATION           = 
+
+# If the GENERATE_HTMLHELP tag is set to YES, the GENERATE_CHI flag 
+# controls if a separate .chi index file is generated (YES) or that 
+# it should be included in the master .chm file (NO).
+
+GENERATE_CHI           = NO
+
+# If the GENERATE_HTMLHELP tag is set to YES, the BINARY_TOC flag 
+# controls whether a binary table of contents is generated (YES) or a 
+# normal table of contents (NO) in the .chm file.
+
+BINARY_TOC             = NO
+
+# The TOC_EXPAND flag can be set to YES to add extra items for group members 
+# to the contents of the HTML help documentation and to the tree view.
+
+TOC_EXPAND             = NO
+
+# The DISABLE_INDEX tag can be used to turn on/off the condensed index at 
+# top of each HTML page. The value NO (the default) enables the index and 
+# the value YES disables it.
+
+DISABLE_INDEX          = NO
+
+# This tag can be used to set the number of enum values (range [1..20]) 
+# that doxygen will group on one line in the generated HTML documentation.
+
+ENUM_VALUES_PER_LINE   = 4
+
+# If the GENERATE_TREEVIEW tag is set to YES, a side panel will be
+# generated containing a tree-like index structure (just like the one that 
+# is generated for HTML Help). For this to work a browser that supports 
+# JavaScript, DHTML, CSS and frames is required (for instance Mozilla 1.0+, 
+# Netscape 6.0+, Internet explorer 5.0+, or Konqueror). Windows users are 
+# probably better off using the HTML help feature.
+
+GENERATE_TREEVIEW      = YES
+
+# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be 
+# used to set the initial width (in pixels) of the frame in which the tree 
+# is shown.
+
+TREEVIEW_WIDTH         = 250
+
+#---------------------------------------------------------------------------
+# configuration options related to the LaTeX output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_LATEX tag is set to YES (the default) Doxygen will 
+# generate Latex output.
+
+GENERATE_LATEX         = NO
+
+# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. 
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be 
+# put in front of it. If left blank `latex' will be used as the default path.
+
+LATEX_OUTPUT           = latex
+
+# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be 
+# invoked. If left blank `latex' will be used as the default command name.
+
+LATEX_CMD_NAME         = latex
+
+# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to 
+# generate index for LaTeX. If left blank `makeindex' will be used as the 
+# default command name.
+
+MAKEINDEX_CMD_NAME     = makeindex
+
+# If the COMPACT_LATEX tag is set to YES Doxygen generates more compact 
+# LaTeX documents. This may be useful for small projects and may help to 
+# save some trees in general.
+
+COMPACT_LATEX          = NO
+
+# The PAPER_TYPE tag can be used to set the paper type that is used 
+# by the printer. Possible values are: a4, a4wide, letter, legal and 
+# executive. If left blank a4wide will be used.
+
+PAPER_TYPE             = a4wide
+
+# The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX 
+# packages that should be included in the LaTeX output.
+
+EXTRA_PACKAGES         = 
+
+# The LATEX_HEADER tag can be used to specify a personal LaTeX header for 
+# the generated latex document. The header should contain everything until 
+# the first chapter. If it is left blank doxygen will generate a 
+# standard header. Notice: only use this tag if you know what you are doing!
+
+LATEX_HEADER           = 
+
+# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated 
+# is prepared for conversion to pdf (using ps2pdf). The pdf file will 
+# contain links (just like the HTML output) instead of page references 
+# This makes the output suitable for online browsing using a pdf viewer.
+
+PDF_HYPERLINKS         = NO
+
+# If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of 
+# plain latex in the generated Makefile. Set this option to YES to get a 
+# higher quality PDF documentation.
+
+USE_PDFLATEX           = NO
+
+# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\batchmode. 
+# command to the generated LaTeX files. This will instruct LaTeX to keep 
+# running if errors occur, instead of asking the user for help. 
+# This option is also used when generating formulas in HTML.
+
+LATEX_BATCHMODE        = NO
+
+# If LATEX_HIDE_INDICES is set to YES then doxygen will not 
+# include the index chapters (such as File Index, Compound Index, etc.) 
+# in the output.
+
+LATEX_HIDE_INDICES     = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the RTF output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output 
+# The RTF output is optimized for Word 97 and may not look very pretty with 
+# other RTF readers or editors.
+
+GENERATE_RTF           = NO
+
+# The RTF_OUTPUT tag is used to specify where the RTF docs will be put. 
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be 
+# put in front of it. If left blank `rtf' will be used as the default path.
+
+RTF_OUTPUT             = rtf
+
+# If the COMPACT_RTF tag is set to YES Doxygen generates more compact 
+# RTF documents. This may be useful for small projects and may help to 
+# save some trees in general.
+
+COMPACT_RTF            = NO
+
+# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated 
+# will contain hyperlink fields. The RTF file will 
+# contain links (just like the HTML output) instead of page references. 
+# This makes the output suitable for online browsing using WORD or other 
+# programs which support those fields. 
+# Note: wordpad (write) and others do not support links.
+
+RTF_HYPERLINKS         = NO
+
+# Load stylesheet definitions from file. Syntax is similar to doxygen's 
+# config file, i.e. a series of assignments. You only have to provide 
+# replacements, missing definitions are set to their default value.
+
+RTF_STYLESHEET_FILE    = 
+
+# Set optional variables used in the generation of an rtf document. 
+# Syntax is similar to doxygen's config file.
+
+RTF_EXTENSIONS_FILE    = 
+
+#---------------------------------------------------------------------------
+# configuration options related to the man page output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_MAN tag is set to YES (the default) Doxygen will 
+# generate man pages
+
+GENERATE_MAN           = NO
+
+# The MAN_OUTPUT tag is used to specify where the man pages will be put. 
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be 
+# put in front of it. If left blank `man' will be used as the default path.
+
+MAN_OUTPUT             = man
+
+# The MAN_EXTENSION tag determines the extension that is added to 
+# the generated man pages (default is the subroutine's section .3)
+
+MAN_EXTENSION          = .3
+
+# If the MAN_LINKS tag is set to YES and Doxygen generates man output, 
+# then it will generate one additional man file for each entity 
+# documented in the real man page(s). These additional files 
+# only source the real man page, but without them the man command 
+# would be unable to find the correct page. The default is NO.
+
+MAN_LINKS              = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the XML output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_XML tag is set to YES Doxygen will 
+# generate an XML file that captures the structure of 
+# the code including all documentation.
+
+GENERATE_XML           = NO
+
+# The XML_OUTPUT tag is used to specify where the XML pages will be put. 
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be 
+# put in front of it. If left blank `xml' will be used as the default path.
+
+XML_OUTPUT             = xml
+
+# The XML_SCHEMA tag can be used to specify an XML schema, 
+# which can be used by a validating XML parser to check the 
+# syntax of the XML files.
+
+XML_SCHEMA             = 
+
+# The XML_DTD tag can be used to specify an XML DTD, 
+# which can be used by a validating XML parser to check the 
+# syntax of the XML files.
+
+XML_DTD                = 
+
+# If the XML_PROGRAMLISTING tag is set to YES Doxygen will 
+# dump the program listings (including syntax highlighting 
+# and cross-referencing information) to the XML output. Note that 
+# enabling this will significantly increase the size of the XML output.
+
+XML_PROGRAMLISTING     = NO
+
+#---------------------------------------------------------------------------
+# configuration options for the AutoGen Definitions output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_AUTOGEN_DEF tag is set to YES Doxygen will 
+# generate an AutoGen Definitions (see autogen.sf.net) file 
+# that captures the structure of the code including all 
+# documentation. Note that this feature is still experimental 
+# and incomplete at the moment.
+
+GENERATE_AUTOGEN_DEF   = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the Perl module output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_PERLMOD tag is set to YES Doxygen will 
+# generate a Perl module file that captures the structure of 
+# the code including all documentation. Note that this 
+# feature is still experimental and incomplete at the 
+# moment.
+
+GENERATE_PERLMOD       = NO
+
+# If the PERLMOD_LATEX tag is set to YES Doxygen will generate 
+# the necessary Makefile rules, Perl scripts and LaTeX code to be able 
+# to generate PDF and DVI output from the Perl module output.
+
+PERLMOD_LATEX          = NO
+
+# If the PERLMOD_PRETTY tag is set to YES the Perl module output will be 
+# nicely formatted so it can be parsed by a human reader.  This is useful 
+# if you want to understand what is going on.  On the other hand, if this 
+# tag is set to NO the size of the Perl module output will be much smaller 
+# and Perl will parse it just the same.
+
+PERLMOD_PRETTY         = YES
+
+# The names of the make variables in the generated doxyrules.make file 
+# are prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX. 
+# This is useful so different doxyrules.make files included by the same 
+# Makefile don't overwrite each other's variables.
+
+PERLMOD_MAKEVAR_PREFIX = 
+
+#---------------------------------------------------------------------------
+# Configuration options related to the preprocessor   
+#---------------------------------------------------------------------------
+
+# If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will 
+# evaluate all C-preprocessor directives found in the sources and include 
+# files.
+
+ENABLE_PREPROCESSING   = YES
+
+# If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro 
+# names in the source code. If set to NO (the default) only conditional 
+# compilation will be performed. Macro expansion can be done in a controlled 
+# way by setting EXPAND_ONLY_PREDEF to YES.
+
+MACRO_EXPANSION        = NO
+
+# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES 
+# then the macro expansion is limited to the macros specified with the 
+# PREDEFINED and EXPAND_AS_DEFINED tags.
+
+EXPAND_ONLY_PREDEF     = NO
+
+# If the SEARCH_INCLUDES tag is set to YES (the default) the includes files 
+# in the INCLUDE_PATH (see below) will be search if a #include is found.
+
+SEARCH_INCLUDES        = YES
+
+# The INCLUDE_PATH tag can be used to specify one or more directories that 
+# contain include files that are not input files but should be processed by 
+# the preprocessor.
+
+INCLUDE_PATH           = 
+
+# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard 
+# patterns (like *.h and *.hpp) to filter out the header-files in the 
+# directories. If left blank, the patterns specified with FILE_PATTERNS will 
+# be used.
+
+INCLUDE_FILE_PATTERNS  = 
+
+# The PREDEFINED tag can be used to specify one or more macro names that 
+# are defined before the preprocessor is started (similar to the -D option of 
+# gcc). The argument of the tag is a list of macros of the form: name 
+# or name=definition (no spaces). If the definition and the = are 
+# omitted =1 is assumed. To prevent a macro definition from being 
+# undefined via #undef or recursively expanded use the := operator 
+# instead of the = operator.
+
+PREDEFINED             = TBB_PREVIEW_FLOW_GRAPH_FEATURES \
+                         TBB_PREVIEW_FLOW_GRAPH_NODES \
+                         __TBB_PREVIEW_OPENCL_NODE \
+                         __TBB_CPP11_RVALUE_REF_PRESENT \
+                         __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT \
+                         __TBB_IMPLICIT_MOVE_PRESENT \
+                         __TBB_EXCEPTION_PTR_PRESENT \
+                         __TBB_STATIC_ASSERT_PRESENT \
+                         __TBB_CPP11_TUPLE_PRESENT \
+                         __TBB_INITIALIZER_LISTS_PRESENT \
+                         __TBB_CONSTEXPR_PRESENT \
+                         __TBB_DEFAULTED_AND_DELETED_FUNC_PRESENT \
+                         __TBB_NOEXCEPT_PRESENT \
+                         __TBB_CPP11_STD_BEGIN_END_PRESENT \
+                         __TBB_CPP11_AUTO_PRESENT \
+                         __TBB_CPP11_DECLTYPE_PRESENT \
+                         __TBB_CPP11_LAMBDAS_PRESENT \
+                         __TBB_CPP11_DEFAULT_FUNC_TEMPLATE_ARGS_PRESENT \
+                         __TBB_OVERRIDE_PRESENT \
+                         __TBB_ALIGNAS_PRESENT \
+                         __TBB_CPP11_TEMPLATE_ALIASES_PRESENT \
+                         __TBB_FLOW_GRAPH_CPP11_FEATURES \
+                         __TBB_PREVIEW_STREAMING_NODE
+
+# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then 
+# this tag can be used to specify a list of macro names that should be expanded. 
+# The macro definition that is found in the sources will be used. 
+# Use the PREDEFINED tag if you want to use a different macro definition.
+
+EXPAND_AS_DEFINED      = 
+
+# If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then 
+# doxygen's preprocessor will remove all function-like macros that are alone 
+# on a line, have an all uppercase name, and do not end with a semicolon. Such 
+# function macros are typically used for boiler-plate code, and will confuse 
+# the parser if not removed.
+
+SKIP_FUNCTION_MACROS   = YES
+
+#---------------------------------------------------------------------------
+# Configuration::additions related to external references   
+#---------------------------------------------------------------------------
+
+# The TAGFILES option can be used to specify one or more tagfiles. 
+# Optionally an initial location of the external documentation 
+# can be added for each tagfile. The format of a tag file without 
+# this location is as follows: 
+#   TAGFILES = file1 file2 ... 
+# Adding location for the tag files is done as follows: 
+#   TAGFILES = file1=loc1 "file2 = loc2" ... 
+# where "loc1" and "loc2" can be relative or absolute paths or 
+# URLs. If a location is present for each tag, the installdox tool 
+# does not have to be run to correct the links.
+# Note that each tag file must have a unique name
+# (where the name does NOT include the path)
+# If a tag file is not located in the directory in which doxygen 
+# is run, you must also specify the path to the tagfile here.
+
+TAGFILES               = 
+
+# When a file name is specified after GENERATE_TAGFILE, doxygen will create 
+# a tag file that is based on the input files it reads.
+
+GENERATE_TAGFILE       = 
+
+# If the ALLEXTERNALS tag is set to YES all external classes will be listed 
+# in the class index. If set to NO only the inherited external classes 
+# will be listed.
+
+ALLEXTERNALS           = NO
+
+# If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed 
+# in the modules index. If set to NO, only the current project's groups will 
+# be listed.
+
+EXTERNAL_GROUPS        = YES
+
+# The PERL_PATH should be the absolute path and name of the perl script 
+# interpreter (i.e. the result of `which perl').
+
+PERL_PATH              = /usr/bin/perl
+
+#---------------------------------------------------------------------------
+# Configuration options related to the dot tool   
+#---------------------------------------------------------------------------
+
+# If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will 
+# generate a inheritance diagram (in HTML, RTF and LaTeX) for classes with base 
+# or super classes. Setting the tag to NO turns the diagrams off. Note that 
+# this option is superseded by the HAVE_DOT option below. This is only a 
+# fallback. It is recommended to install and use dot, since it yields more 
+# powerful graphs.
+
+CLASS_DIAGRAMS         = YES
+
+# If set to YES, the inheritance and collaboration graphs will hide 
+# inheritance and usage relations if the target is undocumented 
+# or is not a class.
+
+HIDE_UNDOC_RELATIONS   = YES
+
+# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is 
+# available from the path. This tool is part of Graphviz, a graph visualization 
+# toolkit from AT&T and Lucent Bell Labs. The other options in this section 
+# have no effect if this option is set to NO (the default)
+
+HAVE_DOT               = YES
+
+# If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen 
+# will generate a graph for each documented class showing the direct and 
+# indirect inheritance relations. Setting this tag to YES will force the 
+# the CLASS_DIAGRAMS tag to NO.
+
+CLASS_GRAPH            = YES
+
+# If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen 
+# will generate a graph for each documented class showing the direct and 
+# indirect implementation dependencies (inheritance, containment, and 
+# class references variables) of the class with other documented classes.
+
+COLLABORATION_GRAPH    = YES
+
+# If the GROUP_GRAPHS and HAVE_DOT tags are set to YES then doxygen 
+# will generate a graph for groups, showing the direct groups dependencies
+
+GROUP_GRAPHS           = YES
+
+# If the UML_LOOK tag is set to YES doxygen will generate inheritance and 
+# collaboration diagrams in a style similar to the OMG's Unified Modeling 
+# Language.
+
+UML_LOOK               = YES
+
+# If set to YES, the inheritance and collaboration graphs will show the 
+# relations between templates and their instances.
+
+TEMPLATE_RELATIONS     = YES
+
+# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDE_GRAPH, and HAVE_DOT 
+# tags are set to YES then doxygen will generate a graph for each documented 
+# file showing the direct and indirect include dependencies of the file with 
+# other documented files.
+
+INCLUDE_GRAPH          = YES
+
+# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDED_BY_GRAPH, and 
+# HAVE_DOT tags are set to YES then doxygen will generate a graph for each 
+# documented header file showing the documented files that directly or 
+# indirectly include this file.
+
+INCLUDED_BY_GRAPH      = YES
+
+# If the CALL_GRAPH and HAVE_DOT tags are set to YES then doxygen will 
+# generate a call dependency graph for every global function or class method. 
+# Note that enabling this option will significantly increase the time of a run. 
+# So in most cases it will be better to enable call graphs for selected 
+# functions only using the \callgraph command.
+
+CALL_GRAPH             = YES
+
+# If the CALLER_GRAPH and HAVE_DOT tags are set to YES then doxygen will 
+# generate a caller dependency graph for every global function or class method. 
+# Note that enabling this option will significantly increase the time of a run. 
+# So in most cases it will be better to enable caller graphs for selected 
+# functions only using the \callergraph command.
+
+CALLER_GRAPH           = YES
+
+# If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen 
+# will graphical hierarchy of all classes instead of a textual one.
+
+GRAPHICAL_HIERARCHY    = YES
+
+# If the DIRECTORY_GRAPH, SHOW_DIRECTORIES and HAVE_DOT tags are set to YES 
+# then doxygen will show the dependencies a directory has on other directories 
+# in a graphical way. The dependency relations are determined by the #include
+# relations between the files in the directories.
+
+DIRECTORY_GRAPH        = YES
+
+# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images 
+# generated by dot. Possible values are png, jpg, or gif
+# If left blank png will be used.
+
+DOT_IMAGE_FORMAT       = svg
+
+# If DOT_IMAGE_FORMAT is set to svg, then this option can be set to YES to
+# enable generation of interactive SVG images that allow zooming and panning.
+#
+# Note that this requires a modern browser other than Internet Explorer. Tested
+# and working are Firefox, Chrome, Safari, and Opera.
+# Note: For IE 9+ you need to set HTML_FILE_EXTENSION to xhtml in order to make
+# the SVG files visible. Older versions of IE do not have SVG support.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+INTERACTIVE_SVG        = YES
+
+# The tag DOT_PATH can be used to specify the path where the dot tool can be 
+# found. If left blank, it is assumed the dot tool can be found in the path.
+
+DOT_PATH               =
+
+# The DOTFILE_DIRS tag can be used to specify one or more directories that 
+# contain dot files that are included in the documentation (see the 
+# \dotfile command).
+
+DOTFILE_DIRS           = 
+
+# The MAX_DOT_GRAPH_WIDTH tag can be used to set the maximum allowed width 
+# (in pixels) of the graphs generated by dot. If a graph becomes larger than 
+# this value, doxygen will try to truncate the graph, so that it fits within 
+# the specified constraint. Beware that most browsers cannot cope with very 
+# large images.
+
+MAX_DOT_GRAPH_WIDTH    = 1024
+
+# The MAX_DOT_GRAPH_HEIGHT tag can be used to set the maximum allows height 
+# (in pixels) of the graphs generated by dot. If a graph becomes larger than 
+# this value, doxygen will try to truncate the graph, so that it fits within 
+# the specified constraint. Beware that most browsers cannot cope with very 
+# large images.
+
+MAX_DOT_GRAPH_HEIGHT   = 1024
+
+# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the 
+# graphs generated by dot. A depth value of 3 means that only nodes reachable 
+# from the root by following a path via at most 3 edges will be shown. Nodes 
+# that lay further from the root node will be omitted. Note that setting this 
+# option to 1 or 2 may greatly reduce the computation time needed for large 
+# code bases. Also note that a graph may be further truncated if the graph's 
+# image dimensions are not sufficient to fit the graph (see MAX_DOT_GRAPH_WIDTH 
+# and MAX_DOT_GRAPH_HEIGHT). If 0 is used for the depth value (the default), 
+# the graph is not depth-constrained.
+
+# The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of nodes
+# that will be shown in the graph. If the number of nodes in a graph becomes
+# larger than this value, doxygen will truncate the graph, which is visualized
+# by representing a node as a red box. Note that doxygen if the number of direct
+# children of the root node in a graph is already larger than
+# DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note that
+# the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH.
+# Minimum value: 0, maximum value: 10000, default value: 50.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_GRAPH_MAX_NODES    = 200
+
+MAX_DOT_GRAPH_DEPTH    = 0
+
+# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent 
+# background. This is disabled by default, which results in a white background. 
+# Warning: Depending on the platform used, enabling this option may lead to 
+# badly anti-aliased labels on the edges of a graph (i.e. they become hard to 
+# read).
+
+DOT_TRANSPARENT        = NO
+
+# Set the DOT_MULTI_TARGETS tag to YES allow dot to generate multiple output 
+# files in one run (i.e. multiple -o and -T options on the command line). This 
+# makes dot run faster, but since only newer versions of dot (>1.8.10) 
+# support this, this feature is disabled by default.
+
+DOT_MULTI_TARGETS      = YES
+
+# If the GENERATE_LEGEND tag is set to YES (the default) Doxygen will 
+# generate a legend page explaining the meaning of the various boxes and 
+# arrows in the dot generated graphs.
+
+GENERATE_LEGEND        = YES
+
+# If the DOT_CLEANUP tag is set to YES (the default) Doxygen will 
+# remove the intermediate dot files that are used to generate 
+# the various graphs.
+
+DOT_CLEANUP            = YES
+
+#---------------------------------------------------------------------------
+# Configuration::additions related to the search engine   
+#---------------------------------------------------------------------------
+
+# The SEARCHENGINE tag specifies whether or not a search engine should be 
+# used. If set to NO the values of all tags below this one will be ignored.
+
+SEARCHENGINE           = YES
diff --git a/src/tbb/COPYING b/src/tbb/LICENSE
similarity index 100%
rename from src/tbb/COPYING
rename to src/tbb/LICENSE
diff --git a/src/tbb/Makefile b/src/tbb/Makefile
index d7dd56f9..f0641893 100644
--- a/src/tbb/Makefile
+++ b/src/tbb/Makefile
@@ -1,4 +1,4 @@
-# Copyright (c) 2005-2017 Intel Corporation
+# Copyright (c) 2005-2020 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -11,12 +11,9 @@
 # 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.
-#
-#
-#
-#
 
 tbb_root?=.
+cfg?=release
 include $(tbb_root)/build/common.inc
 .PHONY: default all tbb tbbmalloc tbbproxy test examples
 
@@ -29,38 +26,38 @@ default: tbb tbbmalloc $(if $(use_proxy),tbbproxy)
 all: tbb tbbmalloc tbbproxy test examples
 
 tbb: mkdir
-	$(MAKE) -C "$(work_dir)_debug"  -r -f $(tbb_root)/build/Makefile.tbb cfg=debug
 	$(MAKE) -C "$(work_dir)_release"  -r -f $(tbb_root)/build/Makefile.tbb cfg=release
 
 tbbmalloc: mkdir
-	$(MAKE) -C "$(work_dir)_debug"  -r -f $(tbb_root)/build/Makefile.tbbmalloc cfg=debug malloc
 	$(MAKE) -C "$(work_dir)_release"  -r -f $(tbb_root)/build/Makefile.tbbmalloc cfg=release malloc
 
 tbbproxy: mkdir
-	$(MAKE) -C "$(work_dir)_debug"  -r -f $(tbb_root)/build/Makefile.tbbproxy cfg=debug tbbproxy
 	$(MAKE) -C "$(work_dir)_release"  -r -f $(tbb_root)/build/Makefile.tbbproxy cfg=release tbbproxy
 
+tbbbind: mkdir
+	$(MAKE) -C "$(work_dir)_release"  -r -f $(tbb_root)/build/Makefile.tbbbind cfg=release tbbbind
+
 test: tbb tbbmalloc $(if $(use_proxy),tbbproxy)
-	-$(MAKE) -C "$(work_dir)_debug"  -r -f $(tbb_root)/build/Makefile.tbbmalloc cfg=debug malloc_test
-	-$(MAKE) -C "$(work_dir)_debug"  -r -f $(tbb_root)/build/Makefile.test cfg=debug
 	-$(MAKE) -C "$(work_dir)_release"  -r -f $(tbb_root)/build/Makefile.tbbmalloc cfg=release malloc_test
 	-$(MAKE) -C "$(work_dir)_release"  -r -f $(tbb_root)/build/Makefile.test cfg=release
 
 rml: mkdir
-	$(MAKE) -C "$(work_dir)_debug"  -r -f $(tbb_root)/build/Makefile.rml cfg=debug
 	$(MAKE) -C "$(work_dir)_release"  -r -f $(tbb_root)/build/Makefile.rml cfg=release
 
-
 examples: tbb tbbmalloc
 	$(MAKE) -C examples -r -f Makefile tbb_root=.. release test
 
+python: tbb
+	$(MAKE) -C "$(work_dir)_release" -rf $(tbb_root)/python/Makefile install
+
+doxygen:
+	doxygen Doxyfile
+
 .PHONY: clean clean_examples mkdir info
 
 clean: clean_examples
 	$(shell $(RM) $(work_dir)_release$(SLASH)*.* >$(NUL) 2>$(NUL))
 	$(shell $(RD) $(work_dir)_release >$(NUL) 2>$(NUL))
-	$(shell $(RM) $(work_dir)_debug$(SLASH)*.* >$(NUL) 2>$(NUL))
-	$(shell $(RD) $(work_dir)_debug >$(NUL) 2>$(NUL))
 	@echo clean done
 
 clean_examples:
@@ -68,8 +65,7 @@ clean_examples:
 
 mkdir:
 	$(shell $(MD) "$(work_dir)_release" >$(NUL) 2>$(NUL))
-	$(shell $(MD) "$(work_dir)_debug" >$(NUL) 2>$(NUL))
-	@echo Created $(work_dir)_release and ..._debug directories
+	@echo Created the $(work_dir)_release directory
 
 info:
 	@echo OS: $(tbb_os)
@@ -77,4 +73,3 @@ info:
 	@echo compiler=$(compiler)
 	@echo runtime=$(runtime)
 	@echo tbb_build_prefix=$(tbb_build_prefix)
-
diff --git a/src/tbb/README.md b/src/tbb/README.md
new file mode 100644
index 00000000..15fc3f5e
--- /dev/null
+++ b/src/tbb/README.md
@@ -0,0 +1,33 @@
+# Threading Building Blocks 2020
+[![Stable release](https://img.shields.io/badge/version-2020.3-green.svg)](https://github.com/intel/tbb/releases/tag/v2020.3)
+[![Apache License Version 2.0](https://img.shields.io/badge/license-Apache_2.0-green.svg)](LICENSE)
+
+Threading Building Blocks (TBB) lets you easily write parallel C++ programs that take
+full advantage of multicore performance, that are portable, composable and have future-proof scalability.
+
+## Release Information
+Here are the latest [Changes](CHANGES) and [Release Notes](doc/Release_Notes.txt) (contains system requirements and known issues).
+
+Since [2018 U5](https://github.com/intel/tbb/releases/tag/2018_U5) TBB binary packages include [Parallel STL](https://github.com/intel/parallelstl) as a high-level component.
+
+## Documentation
+* TBB [tutorial](https://software.intel.com/en-us/tbb-tutorial)
+* TBB general documentation: [stable](https://software.intel.com/en-us/tbb-documentation). For latest documentation please refer to the [latest](https://github.com/intel/tbb/releases/latest) release assets.
+
+## Support
+Please report issues and suggestions via
+[GitHub issues](https://github.com/intel/tbb/issues) or start a topic on the
+[TBB forum](http://software.intel.com/en-us/forums/intel-threading-building-blocks/).
+
+## How to Contribute
+To contribute to TBB, please open a GitHub pull request (preferred) or send us a patch by e-mail.
+Threading Building Blocks is licensed under [Apache License, Version 2.0](LICENSE).
+By its terms, contributions submitted to the project are also done under that license.
+
+## 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.
diff --git a/src/tbb/build/.gitignore b/src/tbb/build/.gitignore
deleted file mode 100644
index 53dc09fc..00000000
--- a/src/tbb/build/.gitignore
+++ /dev/null
@@ -1 +0,0 @@
-lib_*/
diff --git a/src/tbb/build/AIX.gcc.inc b/src/tbb/build/AIX.gcc.inc
index 18e6e6ad..2f45d739 100644
--- a/src/tbb/build/AIX.gcc.inc
+++ b/src/tbb/build/AIX.gcc.inc
@@ -1,4 +1,4 @@
-# Copyright (c) 2005-2017 Intel Corporation
+# Copyright (c) 2005-2020 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -11,10 +11,6 @@
 # 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.
-#
-#
-#
-#
 
 COMPILE_ONLY = -c -MMD
 PREPROC_ONLY = -E -x c++
diff --git a/src/tbb/build/AIX.inc b/src/tbb/build/AIX.inc
index abe12d52..e02a6d31 100644
--- a/src/tbb/build/AIX.inc
+++ b/src/tbb/build/AIX.inc
@@ -1,4 +1,4 @@
-# Copyright (c) 2005-2017 Intel Corporation
+# Copyright (c) 2005-2020 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -11,10 +11,6 @@
 # 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.
-#
-#
-#
-#
 
 ifndef arch
         arch:=$(shell uname -p)
@@ -22,7 +18,7 @@ ifndef arch
 endif
 
 ifndef runtime
-        gcc_version:=$(shell gcc -dumpversion)
+        gcc_version:=$(shell gcc -dumpfullversion -dumpversion)
         os_version:=$(shell uname -r)
         os_kernel_version:=$(shell uname -r | sed -e 's/-.*$$//')
         export runtime:=cc$(gcc_version)_kernel$(os_kernel_version)
diff --git a/src/tbb/build/BSD.clang.inc b/src/tbb/build/BSD.clang.inc
new file mode 100644
index 00000000..7e9e4ebc
--- /dev/null
+++ b/src/tbb/build/BSD.clang.inc
@@ -0,0 +1,106 @@
+# Copyright (c) 2005-2020 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.
+
+COMPILE_ONLY = -c -MMD
+PREPROC_ONLY = -E -x c++
+INCLUDE_KEY = -I
+DEFINE_KEY = -D
+OUTPUT_KEY = -o #
+OUTPUTOBJ_KEY = -o #
+PIC_KEY = -fPIC
+WARNING_AS_ERROR_KEY = -Werror
+WARNING_KEY = -Wall
+TEST_WARNING_KEY = -Wextra -Wshadow -Wcast-qual -Woverloaded-virtual -Wnon-virtual-dtor
+WARNING_SUPPRESS = -Wno-parentheses -Wno-non-virtual-dtor -Wno-dangling-else
+DYLIB_KEY = -shared
+EXPORT_KEY = -Wl,--version-script,
+LIBDL =
+
+CPLUS = clang++
+CONLY = clang
+LIB_LINK_FLAGS = $(DYLIB_KEY) -Wl,-soname=$(BUILDING_LIBRARY)
+LIBS += -lpthread
+LINK_FLAGS = -Wl,-rpath-link=. -Wl,-rpath=. -rdynamic
+C_FLAGS = $(CPLUS_FLAGS)
+
+ifeq ($(cfg), release)
+        CPLUS_FLAGS = $(ITT_NOTIFY) -g -O2 -DUSE_PTHREAD
+endif
+ifeq ($(cfg), debug)
+        CPLUS_FLAGS = -DTBB_USE_DEBUG $(ITT_NOTIFY) -g -O0 -DUSE_PTHREAD
+endif
+
+ifneq (,$(stdlib))
+    CPLUS_FLAGS    += -stdlib=$(stdlib)
+    LIB_LINK_FLAGS += -stdlib=$(stdlib)
+endif
+
+TBB_ASM.OBJ=
+MALLOC_ASM.OBJ=
+
+ifeq (intel64,$(arch))
+    ITT_NOTIFY = -DDO_ITT_NOTIFY
+    CPLUS_FLAGS += -m64
+    LIB_LINK_FLAGS += -m64
+endif
+
+ifeq (ia32,$(arch))
+    ITT_NOTIFY = -DDO_ITT_NOTIFY
+    CPLUS_FLAGS += -m32 -march=pentium4
+    LIB_LINK_FLAGS += -m32
+endif
+
+ifeq (ppc64,$(arch))
+    CPLUS_FLAGS += -m64
+    LIB_LINK_FLAGS += -m64
+endif
+
+ifeq (ppc32,$(arch))
+    CPLUS_FLAGS += -m32
+    LIB_LINK_FLAGS += -m32
+endif
+
+ifeq (bg,$(arch))
+    CPLUS = bgclang++
+    CONLY = bgclang
+endif
+
+#------------------------------------------------------------------------------
+# Setting assembler data.
+#------------------------------------------------------------------------------
+ASM = as
+ifeq (intel64,$(arch))
+    ASM_FLAGS += --64
+endif
+ifeq (ia32,$(arch))
+    ASM_FLAGS += --32
+endif
+ifeq ($(cfg),debug)
+    ASM_FLAGS += -g
+endif
+
+ASSEMBLY_SOURCE=$(arch)-gas
+#------------------------------------------------------------------------------
+# End of setting assembler data.
+#------------------------------------------------------------------------------
+
+#------------------------------------------------------------------------------
+# Setting tbbmalloc data.
+#------------------------------------------------------------------------------
+
+M_CPLUS_FLAGS = $(CPLUS_FLAGS) -fno-rtti -fno-exceptions
+
+#------------------------------------------------------------------------------
+# End of setting tbbmalloc data.
+#------------------------------------------------------------------------------
diff --git a/src/tbb/build/BSD.inc b/src/tbb/build/BSD.inc
new file mode 100644
index 00000000..e5ea784d
--- /dev/null
+++ b/src/tbb/build/BSD.inc
@@ -0,0 +1,70 @@
+# Copyright (c) 2005-2020 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.
+
+ifndef arch
+        ifeq ($(shell uname -m),i386)
+                export arch:=ia32
+        endif
+        ifeq ($(shell uname -m),ia64)
+                export arch:=ia64
+        endif
+        ifeq ($(shell uname -m),amd64)
+                export arch:=intel64
+        endif
+endif
+
+ifndef runtime
+        clang_version:=$(shell clang --version | sed -n "1s/.*version \(.*[0-9]\) .*/\1/p")
+        os_version:=$(shell uname -r)
+        os_kernel_version:=$(shell uname -r | sed -e 's/-.*$$//')
+        export runtime:=cc$(clang_version)_kernel$(os_kernel_version)
+endif
+
+native_compiler := clang
+export compiler ?= clang
+debugger ?= gdb
+
+CMD=$(SHELL) -c
+CWD=$(shell pwd)
+RM?=rm -f
+RD?=rmdir
+MD?=mkdir -p
+NUL= /dev/null
+SLASH=/
+MAKE_VERSIONS=sh $(tbb_root)/build/version_info_linux.sh $(VERSION_FLAGS) >version_string.ver
+MAKE_TBBVARS=sh $(tbb_root)/build/generate_tbbvars.sh
+
+ifdef LD_LIBRARY_PATH
+        export LD_LIBRARY_PATH := .:$(LD_LIBRARY_PATH)
+else
+        export LD_LIBRARY_PATH := .
+endif
+
+####### Build settings ########################################################
+
+OBJ = o
+DLL = so
+LIBEXT=so
+
+TBB.LST =
+TBB.DEF =
+TBB.DLL = libtbb$(CPF_SUFFIX)$(DEBUG_SUFFIX).$(DLL)
+TBB.LIB = $(TBB.DLL)
+LINK_TBB.LIB = $(TBB.LIB)
+
+MALLOC.DLL = libtbbmalloc$(DEBUG_SUFFIX).$(DLL)
+MALLOC.LIB = $(MALLOC.DLL)
+LINK_MALLOC.LIB = $(MALLOC.LIB)
+
+TEST_LAUNCHER=sh $(tbb_root)/build/test_launcher.sh $(largs)
diff --git a/src/tbb/build/FreeBSD.clang.inc b/src/tbb/build/FreeBSD.clang.inc
index 3579603d..f4cdf128 100644
--- a/src/tbb/build/FreeBSD.clang.inc
+++ b/src/tbb/build/FreeBSD.clang.inc
@@ -1,4 +1,4 @@
-# Copyright (c) 2005-2017 Intel Corporation
+# Copyright (c) 2005-2020 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -11,100 +11,7 @@
 # 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.
-#
-#
-#
-#
-
-COMPILE_ONLY = -c -MMD
-PREPROC_ONLY = -E -x c++
-INCLUDE_KEY = -I
-DEFINE_KEY = -D
-OUTPUT_KEY = -o #
-OUTPUTOBJ_KEY = -o #
-PIC_KEY = -fPIC
-WARNING_AS_ERROR_KEY = -Werror
-WARNING_KEY = -Wall
-TEST_WARNING_KEY = -Wextra -Wshadow -Wcast-qual -Woverloaded-virtual -Wnon-virtual-dtor
-WARNING_SUPPRESS = -Wno-parentheses -Wno-non-virtual-dtor -Wno-dangling-else
-DYLIB_KEY = -shared
-EXPORT_KEY = -Wl,--version-script,
-LIBDL =
-
-CPLUS = clang++
-CONLY = clang
-LIB_LINK_FLAGS = $(DYLIB_KEY) -Wl,-soname=$(BUILDING_LIBRARY)
-LIBS += -lpthread -lrt
-LINK_FLAGS = -Wl,-rpath-link=. -Wl,-rpath=. -rdynamic
-C_FLAGS = $(CPLUS_FLAGS)
-
-ifeq ($(cfg), release)
-        CPLUS_FLAGS = $(ITT_NOTIFY) -g -O2 -DUSE_PTHREAD
-endif
-ifeq ($(cfg), debug)
-        CPLUS_FLAGS = -DTBB_USE_DEBUG $(ITT_NOTIFY) -g -O0 -DUSE_PTHREAD
-endif
-
-ifneq (,$(stdlib))
-    CPLUS_FLAGS    += -stdlib=$(stdlib)
-    LIB_LINK_FLAGS += -stdlib=$(stdlib)
-endif
-
-TBB_ASM.OBJ=
-MALLOC_ASM.OBJ=
-
-ifeq (intel64,$(arch))
-    ITT_NOTIFY = -DDO_ITT_NOTIFY
-    CPLUS_FLAGS += -m64
-    LIB_LINK_FLAGS += -m64
-endif
-
-ifeq (ia32,$(arch))
-    ITT_NOTIFY = -DDO_ITT_NOTIFY
-    CPLUS_FLAGS += -m32 -march=pentium4
-    LIB_LINK_FLAGS += -m32
-endif
-
-ifeq (ppc64,$(arch))
-    CPLUS_FLAGS += -m64
-    LIB_LINK_FLAGS += -m64
-endif
-
-ifeq (ppc32,$(arch))
-    CPLUS_FLAGS += -m32
-    LIB_LINK_FLAGS += -m32
-endif
-
-ifeq (bg,$(arch))
-    CPLUS = bgclang++
-    CONLY = bgclang
-endif
-
-#------------------------------------------------------------------------------
-# Setting assembler data.
-#------------------------------------------------------------------------------
-ASM = as
-ifeq (intel64,$(arch))
-    ASM_FLAGS += --64
-endif
-ifeq (ia32,$(arch))
-    ASM_FLAGS += --32
-endif
-ifeq ($(cfg),debug)
-    ASM_FLAGS += -g
-endif
-
-ASSEMBLY_SOURCE=$(arch)-gas
-#------------------------------------------------------------------------------
-# End of setting assembler data.
-#------------------------------------------------------------------------------
-
-#------------------------------------------------------------------------------
-# Setting tbbmalloc data.
-#------------------------------------------------------------------------------
 
-M_CPLUS_FLAGS = $(CPLUS_FLAGS) -fno-rtti -fno-exceptions
+include $(tbb_root)/build/BSD.clang.inc
 
-#------------------------------------------------------------------------------
-# End of setting tbbmalloc data.
-#------------------------------------------------------------------------------
+LIBS += -lrt
diff --git a/src/tbb/build/FreeBSD.gcc.inc b/src/tbb/build/FreeBSD.gcc.inc
index 794cb7c4..7bd8b073 100644
--- a/src/tbb/build/FreeBSD.gcc.inc
+++ b/src/tbb/build/FreeBSD.gcc.inc
@@ -1,4 +1,4 @@
-# Copyright (c) 2005-2017 Intel Corporation
+# Copyright (c) 2005-2020 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -11,10 +11,6 @@
 # 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.
-#
-#
-#
-#
 
 COMPILE_ONLY = -c -MMD
 PREPROC_ONLY = -E -x c++
@@ -36,7 +32,7 @@ C_FLAGS = $(CPLUS_FLAGS)
 
 # gcc 6.0 and later have -flifetime-dse option that controls
 # elimination of stores done outside the object lifetime
-ifneq (,$(shell gcc -dumpversion | egrep  "^([6-9])"))
+ifneq (,$(shell gcc -dumpfullversion -dumpversion | egrep  "^([6-9]|1[0-9])"))
     # keep pre-contruction stores for zero initialization
     DSE_KEY = -flifetime-dse=1
 endif
diff --git a/src/tbb/build/FreeBSD.inc b/src/tbb/build/FreeBSD.inc
index 3bd6a064..8b85bf02 100644
--- a/src/tbb/build/FreeBSD.inc
+++ b/src/tbb/build/FreeBSD.inc
@@ -1,4 +1,4 @@
-# Copyright (c) 2005-2017 Intel Corporation
+# Copyright (c) 2005-2020 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -11,64 +11,5 @@
 # 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.
-#
-#
-#
-#
-
-ifndef arch
-        ifeq ($(shell uname -m),i386)
-                export arch:=ia32
-        endif
-        ifeq ($(shell uname -m),ia64)
-                export arch:=ia64
-        endif
-        ifeq ($(shell uname -m),amd64)
-                export arch:=intel64
-        endif
-endif
-
-ifndef runtime
-        clang_version:=$(shell clang -v 2>&1 | grep version | sed "s/.*version \([0-9]*\.[0-9]*\).*/\1/")
-        os_version:=$(shell uname -r)
-        os_kernel_version:=$(shell uname -r | sed -e 's/-.*$$//')
-        export runtime:=cc$(clang_version)_kernel$(os_kernel_version)
-endif
-
-native_compiler := clang
-export compiler ?= clang
-debugger ?= gdb
-
-CMD=$(SHELL) -c
-CWD=$(shell pwd)
-RM?=rm -f
-RD?=rmdir
-MD?=mkdir -p
-NUL= /dev/null
-SLASH=/
-MAKE_VERSIONS=sh $(tbb_root)/build/version_info_linux.sh $(VERSION_FLAGS) >version_string.ver
-MAKE_TBBVARS=sh $(tbb_root)/build/generate_tbbvars.sh
-
-ifdef LD_LIBRARY_PATH
-        export LD_LIBRARY_PATH := .:$(LD_LIBRARY_PATH)
-else
-        export LD_LIBRARY_PATH := .
-endif
-
-####### Build settings ########################################################
-
-OBJ = o
-DLL = so
-LIBEXT=so
-
-TBB.LST =
-TBB.DEF =
-TBB.DLL = libtbb$(CPF_SUFFIX)$(DEBUG_SUFFIX).$(DLL)
-TBB.LIB = $(TBB.DLL)
-LINK_TBB.LIB = $(TBB.LIB)
-
-MALLOC.DLL = libtbbmalloc$(DEBUG_SUFFIX).$(DLL)
-MALLOC.LIB = $(MALLOC.DLL)
-LINK_MALLOC.LIB = $(MALLOC.LIB)
 
-TEST_LAUNCHER=sh $(tbb_root)/build/test_launcher.sh $(largs)
+include $(tbb_root)/build/BSD.inc
diff --git a/src/tbb/build/Makefile.rml b/src/tbb/build/Makefile.rml
index 241d4bfb..fc0cb774 100644
--- a/src/tbb/build/Makefile.rml
+++ b/src/tbb/build/Makefile.rml
@@ -1,4 +1,4 @@
-# Copyright (c) 2005-2017 Intel Corporation
+# Copyright (c) 2005-2020 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -11,10 +11,6 @@
 # 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.
-#
-#
-#
-#
 
 # TODO: investigate why version_string.ver is not complete when $(RML_SERVER.OBJ) is being compiled.
 .NOTPARALLEL:
@@ -64,6 +60,13 @@ TBB_DEP_NON_RML_TEST?= cache_aligned_allocator_rml.$(OBJ) dynamic_link_rml.$(OBJ
 ifeq ($(cfg),debug)
 RML_TBB_DEP+= spin_mutex_rml.$(OBJ)
 TBB_DEP_RML_TEST?= $(RML_ASM.OBJ) tbb_misc_rml.$(OBJ)
+
+ifeq (windows icl,$(tbb_os) $(compiler_name))
+# Some versions of ICC link to the wrong version of the vc runtime
+# libcpmtd.lib should be used instead of libcpmt.lib
+LIB_LINK_FLAGS += /nodefaultlib:libcpmt.lib
+endif
+
 else
 TBB_DEP_RML_TEST?= $(RML_ASM.OBJ)
 endif
diff --git a/src/tbb/build/Makefile.tbb b/src/tbb/build/Makefile.tbb
index b66c309b..a656087d 100644
--- a/src/tbb/build/Makefile.tbb
+++ b/src/tbb/build/Makefile.tbb
@@ -1,4 +1,4 @@
-# Copyright (c) 2005-2017 Intel Corporation
+# Copyright (c) 2005-2020 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -11,10 +11,6 @@
 # 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.
-#
-#
-#
-#
 
 #------------------------------------------------------------------------------
 # Define rules for making the TBB shared library.
@@ -74,14 +70,6 @@ TBB_CPLUS.OBJ = concurrent_hash_map.$(OBJ) \
 		tbb_statistics.$(OBJ) \
 		tbb_main.$(OBJ)
 
-# OLD/Legacy object files for backward binary compatibility
-ifeq (,$(findstring $(DEFINE_KEY)TBB_NO_LEGACY,$(CXXFLAGS)))
-TBB_CPLUS_OLD.OBJ = \
-		concurrent_vector_v2.$(OBJ) \
-		concurrent_queue_v2.$(OBJ) \
-		spin_rw_mutex_v2.$(OBJ) \
-		task_v2.$(OBJ)
-endif
 
 # Object files that gmake up TBB (TBB_ASM.OBJ is platform-specific)
 TBB.OBJ = $(TBB_CPLUS.OBJ) $(TBB_CPLUS_OLD.OBJ) $(TBB_ASM.OBJ)
diff --git a/src/tbb/build/Makefile.tbbbind b/src/tbb/build/Makefile.tbbbind
new file mode 100644
index 00000000..821009a3
--- /dev/null
+++ b/src/tbb/build/Makefile.tbbbind
@@ -0,0 +1,69 @@
+# Copyright (c) 2005-2020 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.
+
+#------------------------------------------------------------------------------
+# Define rules for making the tbbbind shared library.
+#------------------------------------------------------------------------------
+
+tbb_root ?= "$(TBBROOT)"
+BUILDING_PHASE=1
+include $(tbb_root)/build/common.inc
+CPLUS_FLAGS += $(SDL_FLAGS)
+DEBUG_SUFFIX=$(findstring _debug,_$(cfg))
+
+#------------------------------------------------------------
+# Define static pattern rules dealing with .cpp source files
+#------------------------------------------------------------
+$(warning CONFIG: cfg=$(cfg) arch=$(arch) compiler=$(compiler) target=$(target) runtime=$(runtime))
+
+.PHONY: tbbbind
+.PRECIOUS: %.$(OBJ)
+
+VPATH = $(tbb_root)/src/tbb/$(ASSEMBLY_SOURCE) $(tbb_root)/src/tbb $(tbb_root)/src/old $(tbb_root)/src/rml/client
+
+CPLUS_FLAGS += $(PIC_KEY) $(DSE_KEY) $(DEFINE_KEY)__TBBBIND_BUILD=1
+
+# Suppress superfluous warnings for tbbbind compilation
+WARNING_KEY += $(WARNING_SUPPRESS)
+
+include $(tbb_root)/build/common_rules.inc
+
+TBBBIND.OBJ = tbb_bind.$(OBJ)
+
+ifneq (,$(TBBBIND.DEF))
+tbbbind.def: $(TBBBIND.DEF)
+	$(CPLUS) $(PREPROC_ONLY) $< $(CPLUS_FLAGS) $(INCLUDES) > $@
+
+LIB_LINK_FLAGS += $(EXPORT_KEY)tbbbind.def
+$(TBBBIND.DLL): tbbbind.def
+endif
+
+ifneq (,$(TBBBIND.DLL))
+$(TBBBIND.DLL): BUILDING_LIBRARY = $(TBBBIND.DLL)
+$(TBBBIND.DLL): $(TBBBIND.OBJ) $(TBBBIND_NO_VERSION.DLL)
+	$(LIB_LINK_CMD) $(LIB_OUTPUT_KEY)$(TBBBIND.DLL) $(TBBBIND.OBJ) $(HWLOC.LIB) $(LIB_LINK_FLAGS)
+endif
+
+ifneq (,$(TBBBIND_NO_VERSION.DLL))
+$(TBBBIND_NO_VERSION.DLL):
+	echo "INPUT ($(TBBBIND.DLL))" > $(TBBBIND_NO_VERSION.DLL)
+endif
+
+tbbbind: $(TBBBIND.DLL)
+
+#clean:
+#	$(RM) *.$(OBJ) *.$(DLL) *.res *.map *.ilk *.pdb *.exp *.manifest *.tmp *.d core core.*[0-9][0-9] *.ver
+
+# Include automatically generated dependencies
+-include *.d
diff --git a/src/tbb/build/Makefile.tbbmalloc b/src/tbb/build/Makefile.tbbmalloc
index dedcfa56..4ba504f8 100644
--- a/src/tbb/build/Makefile.tbbmalloc
+++ b/src/tbb/build/Makefile.tbbmalloc
@@ -1,4 +1,4 @@
-# Copyright (c) 2005-2017 Intel Corporation
+# Copyright (c) 2005-2020 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -11,10 +11,6 @@
 # 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.
-#
-#
-#
-#
 
 # default target
 default_malloc: malloc malloc_test
@@ -51,11 +47,11 @@ ORIG_LINK_MALLOC.LIB:=$(LINK_MALLOC.LIB)
 MALLOC_CPLUS.OBJ = backend.$(OBJ) large_objects.$(OBJ) backref.$(OBJ)  tbbmalloc.$(OBJ)
 MALLOC.OBJ := $(MALLOC_CPLUS.OBJ) $(MALLOC_ASM.OBJ) itt_notify_malloc.$(OBJ) frontend.$(OBJ)
 PROXY.OBJ := proxy.$(OBJ) tbb_function_replacement.$(OBJ)
-M_CPLUS_FLAGS := $(subst $(WARNING_KEY),,$(M_CPLUS_FLAGS)) $(DEFINE_KEY)__TBBMALLOC_BUILD=1
+M_CPLUS_FLAGS += $(DEFINE_KEY)__TBBMALLOC_BUILD=1
 M_INCLUDES := $(INCLUDES) $(INCLUDE_KEY)$(MALLOC_ROOT) $(INCLUDE_KEY)$(MALLOC_SOURCE_ROOT)
 
 # Suppress superfluous warnings for TBBMalloc compilation
-$(MALLOC.OBJ): M_CPLUS_FLAGS += $(WARNING_SUPPRESS)
+$(MALLOC.OBJ): M_CPLUS_FLAGS := $(subst $(WARNING_KEY),,$(M_CPLUS_FLAGS)) $(WARNING_SUPPRESS)
 # Suppress superfluous warnings for TBBMalloc proxy compilation
 $(PROXY.OBJ): CPLUS_FLAGS += $(WARNING_SUPPRESS)
 
@@ -138,11 +134,14 @@ MALLOC_TESTS = test_ScalableAllocator.$(TEST_EXT) \
                test_malloc_pure_c.$(TEST_EXT) \
                test_malloc_whitebox.$(TEST_EXT) \
                test_malloc_used_by_lib.$(TEST_EXT) \
-               test_malloc_lib_unload.$(TEST_EXT)
+               test_malloc_lib_unload.$(TEST_EXT) \
+               test_malloc_shutdown_hang.$(TEST_EXT)
 ifneq (,$(MALLOCPROXY.DLL))
 MALLOC_TESTS += test_malloc_overload.$(TEST_EXT) \
                 test_malloc_overload_proxy.$(TEST_EXT) \
-                test_malloc_atexit.$(TEST_EXT)
+                test_malloc_overload_disable.$(TEST_EXT) \
+                test_malloc_atexit.$(TEST_EXT) \
+                test_malloc_new_handler.$(TEST_EXT)
 endif
 # -----------------------------------------------------
 
@@ -161,11 +160,14 @@ MALLOC_M_CPLUS_TESTS =    test_malloc_whitebox.$(TEST_EXT) test_malloc_lib_unloa
         test_malloc_used_by_lib.$(TEST_EXT)
 MALLOC_NO_LIB_TESTS =     test_malloc_whitebox.$(TEST_EXT) test_malloc_lib_unload.$(TEST_EXT) \
         test_malloc_used_by_lib.$(TEST_EXT) test_malloc_overload.$(TEST_EXT)
-MALLOC_LINK_PROXY_TESTS = test_malloc_overload_proxy.$(TEST_EXT)
+MALLOC_LINK_PROXY_TESTS = test_malloc_overload_proxy.$(TEST_EXT) test_malloc_new_handler.$(TEST_EXT)
 MALLOC_ADD_DLL_TESTS =    test_malloc_lib_unload.$(TEST_EXT) test_malloc_used_by_lib.$(TEST_EXT) \
         test_malloc_atexit.$(TEST_EXT)
+MALLOC_SUPPRESS_WARNINGS =  test_malloc_whitebox.$(TEST_EXT) test_malloc_pure_c.$(TEST_EXT)
 
-$(MALLOC_M_CPLUS_TESTS): CPLUS_FLAGS=$(M_CPLUS_FLAGS)
+$(MALLOC_SUPPRESS_WARNINGS): WARNING_KEY=
+$(MALLOC_SUPPRESS_WARNINGS): TEST_WARNING_KEY=
+$(MALLOC_M_CPLUS_TESTS): CPLUS_FLAGS:=$(M_CPLUS_FLAGS)
 $(MALLOC_M_CPLUS_TESTS): INCLUDES=$(M_INCLUDES)
 $(MALLOC_NO_LIB_TESTS): LINK_MALLOC.LIB=
 $(MALLOC_NO_LIB_TESTS): LINK_FLAGS+=$(LIBDL)
@@ -175,12 +177,12 @@ $(MALLOC_ADD_DLL_TESTS): %.$(TEST_EXT): %_dll.$(DLL)
 $(MALLOC_ADD_DLL_TESTS): TEST_LIBS+=$(@:.$(TEST_EXT)=_dll.$(LIBEXT))
 endif
 
-test_malloc_over%.$(TEST_EXT): CPLUS_FLAGS=$(subst /MT,/MD,$(M_CPLUS_FLAGS))
+test_malloc_over%.$(TEST_EXT): CPLUS_FLAGS:=$(subst /MT,/MD,$(M_CPLUS_FLAGS))
 test_malloc_over%.$(TEST_EXT): INCLUDES=$(M_INCLUDES)
 test_malloc_overload_proxy.$(TEST_EXT): LINK_FLAGS+=$(LIBDL)
 
-test_malloc_atexit_dll.$(DLL): CPLUS_FLAGS=$(subst /MT,/MD,$(M_CPLUS_FLAGS))
-test_malloc_atexit.$(TEST_EXT): CPLUS_FLAGS=$(subst /MT,/MD,$(M_CPLUS_FLAGS))
+test_malloc_atexit_dll.$(DLL): CPLUS_FLAGS:=$(subst /MT,/MD,$(M_CPLUS_FLAGS))
+test_malloc_atexit.$(TEST_EXT): CPLUS_FLAGS:=$(subst /MT,/MD,$(M_CPLUS_FLAGS))
 test_malloc_atexit.$(TEST_EXT): LINK_FLAGS+=$(LIBDL)
 # on Ubuntu 11.10 linker called with --as-needed, so dependency on libtbbmalloc_proxy
 # is not created, and malloc overload via linking with -ltbbmalloc_proxy is not working.
@@ -205,9 +207,20 @@ test_malloc_whitebox.$(TEST_EXT): LINK_FILES+=$(MALLOC_ASM.OBJ)
 test_malloc_lib_unload_dll.$(DLL): CPLUS_FLAGS=$(ORIG_CPLUS_FLAGS) $(if $(no_exceptions),$(DEFINE_KEY)__TBB_TEST_NO_EXCEPTIONS=1)
 test_malloc_lib_unload_dll.$(DLL): INCLUDES=$(ORIG_INCLUDES) $(INCLUDE_TEST_HEADERS)
 
-test_malloc_used_by_lib_dll.$(DLL): CPLUS_FLAGS=$(subst /MT,/LD,$(M_CPLUS_FLAGS))
+test_malloc_used_by_lib_dll.$(DLL): CPLUS_FLAGS:=$(subst /MT,/LD,$(M_CPLUS_FLAGS))
 test_malloc_used_by_lib_dll.$(DLL): LINK_FILES+=$(ORIG_LINK_MALLOC.LIB)
 test_malloc_used_by_lib_dll.$(DLL): LIBDL=
+
+# The test needs both tbb and tbbmalloc.
+# For static build LINK_TBB.LIB is resolved in tbb.a static lib name (Linux), which cannot be found (dynamic tbb is used only).
+# In order to link properly, have to define LINK_TBB.LIB ourselves except for Windows where linkage with *.lib file expected.
+ifdef extra_inc
+ifneq ($(tbb_os),windows)
+DYNAMIC_TBB_LIB=$(LIBPREF)tbb$(CPF_SUFFIX)$(DEBUG_SUFFIX).$(DLL)
+endif
+endif
+test_malloc_shutdown_hang.$(TEST_EXT): LINK_FILES += $(if $(DYNAMIC_TBB_LIB), $(DYNAMIC_TBB_LIB), $(LINK_TBB.LIB))
+
 # -----------------------------------------------------
 
 # ---- The list of TBBMalloc test running commands ----
@@ -220,6 +233,8 @@ ifneq (,$(MALLOCPROXY.DLL))
 	$(run_cmd) ./test_malloc_atexit.$(TEST_EXT) $(args)
 	$(run_cmd) $(TEST_LAUNCHER) -l $(MALLOCPROXY.DLL) ./test_malloc_overload.$(TEST_EXT) $(args)
 	$(run_cmd) $(TEST_LAUNCHER) ./test_malloc_overload_proxy.$(TEST_EXT) $(args)
+	$(run_cmd) ./test_malloc_overload_disable.$(TEST_EXT) $(args)
+	$(run_cmd) $(TEST_LAUNCHER) ./test_malloc_new_handler.$(TEST_EXT) $(args)
 endif
 	$(run_cmd) $(TEST_LAUNCHER) ./test_malloc_lib_unload.$(TEST_EXT) $(args)
 	$(run_cmd) $(TEST_LAUNCHER) ./test_malloc_used_by_lib.$(TEST_EXT)
@@ -230,6 +245,7 @@ endif
 	$(run_cmd) ./test_malloc_regression.$(TEST_EXT) $(args)
 	$(run_cmd) ./test_malloc_init_shutdown.$(TEST_EXT) $(args)
 	$(run_cmd) ./test_malloc_pure_c.$(TEST_EXT) $(args)
+	$(run_cmd) ./test_malloc_shutdown_hang.$(TEST_EXT)
 # -----------------------------------------------------
 
 #------------------------------------------------------
diff --git a/src/tbb/build/Makefile.tbbproxy b/src/tbb/build/Makefile.tbbproxy
index eb2e0fd6..54f5e9cd 100644
--- a/src/tbb/build/Makefile.tbbproxy
+++ b/src/tbb/build/Makefile.tbbproxy
@@ -1,4 +1,4 @@
-# Copyright (c) 2005-2017 Intel Corporation
+# Copyright (c) 2005-2020 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -11,10 +11,6 @@
 # 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.
-#
-#
-#
-#
 
 # default target
 default_tbbproxy: tbbproxy tbbproxy_test
diff --git a/src/tbb/build/Makefile.test b/src/tbb/build/Makefile.test
index 9de7860d..eb2c7053 100644
--- a/src/tbb/build/Makefile.test
+++ b/src/tbb/build/Makefile.test
@@ -1,4 +1,4 @@
-# Copyright (c) 2005-2017 Intel Corporation
+# Copyright (c) 2005-2020 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -11,10 +11,6 @@
 # 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.
-#
-#
-#
-#
 
 #------------------------------------------------------------------------------
 # Define rules for making the TBB tests.
@@ -107,6 +103,9 @@ test_dynamic_link.$(TEST_EXT): LIBS += $(LIBDL)
 ifneq (,$(BIGOBJ_KEY))
 TEST_BIGOBJ = test_opencl_node.$(TEST_EXT)      \
     test_atomic.$(TEST_EXT)                     \
+    test_concurrent_hash_map.$(TEST_EXT)        \
+    test_concurrent_set.$(TEST_EXT)             \
+    test_concurrent_map.$(TEST_EXT)             \
     test_concurrent_unordered_set.$(TEST_EXT)   \
     test_concurrent_unordered_map.$(TEST_EXT)   \
     test_join_node_key_matching.$(TEST_EXT)     \
@@ -115,7 +114,7 @@ TEST_BIGOBJ = test_opencl_node.$(TEST_EXT)      \
 $(TEST_BIGOBJ): override CXXFLAGS += $(BIGOBJ_KEY)
 endif
 
-# TODO: remove repetition of .$(TEST_EXT) in the list bellow
+# TODO: remove repetition of .$(TEST_EXT) in the list below
 # The main list of TBB tests
 TEST_TBB_PLAIN.EXE = test_assembly.$(TEST_EXT)   \
 	test_global_control.$(TEST_EXT)              \
@@ -128,11 +127,14 @@ TEST_TBB_PLAIN.EXE = test_assembly.$(TEST_EXT)   \
 	test_blocked_range.$(TEST_EXT)               \
 	test_blocked_range2d.$(TEST_EXT)             \
 	test_blocked_range3d.$(TEST_EXT)             \
+	test_blocked_rangeNd.$(TEST_EXT)             \
 	test_concurrent_queue.$(TEST_EXT)            \
 	test_concurrent_vector.$(TEST_EXT)           \
 	test_concurrent_unordered_set.$(TEST_EXT)    \
 	test_concurrent_unordered_map.$(TEST_EXT)    \
 	test_concurrent_hash_map.$(TEST_EXT)         \
+	test_concurrent_set.$(TEST_EXT)              \
+	test_concurrent_map.$(TEST_EXT)              \
 	test_enumerable_thread_specific.$(TEST_EXT)  \
 	test_handle_perror.$(TEST_EXT)               \
 	test_halt.$(TEST_EXT)                        \
@@ -197,6 +199,7 @@ TEST_TBB_PLAIN.EXE = test_assembly.$(TEST_EXT)   \
 	test_priority_queue_node.$(TEST_EXT)         \
 	test_sequencer_node.$(TEST_EXT)              \
 	test_source_node.$(TEST_EXT)                 \
+	test_input_node.$(TEST_EXT)                  \
 	test_overwrite_node.$(TEST_EXT)              \
 	test_write_once_node.$(TEST_EXT)             \
 	test_indexer_node.$(TEST_EXT)                \
@@ -214,12 +217,12 @@ TEST_TBB_PLAIN.EXE = test_assembly.$(TEST_EXT)   \
 	test_composite_node.$(TEST_EXT)              \
 	test_async_node.$(TEST_EXT)                  \
 	test_async_msg.$(TEST_EXT)                   \
+	test_resumable_tasks.$(TEST_EXT)             \
 	test_tbb_version.$(TEST_EXT)                 # insert new files right above
 
 # These tests depend on other technologies
 TEST_TBB_SPECIAL.EXE = test_openmp.$(TEST_EXT) \
     test_cilk_interop.$(TEST_EXT)              \
-    test_gfx_factory.$(TEST_EXT)               \
     test_opencl_node.$(TEST_EXT)
 
 # skip mode_plugin for now
@@ -240,7 +243,6 @@ ifdef CILK_AVAILABLE
 # The issue reveals itself if a version of binutils is prior to 2.17
 ifeq (linux_icc,$(tbb_os)_$(compiler))
 test_cilk_interop.$(TEST_EXT): LIBS += -lcilkrts
-test_gfx_factory.$(TEST_EXT): LIBS += -lcilkrts
 endif
 test_tbb_cilk: test_cilk_interop.$(TEST_EXT)
 	$(run_cmd) ./test_cilk_interop.$(TEST_EXT) $(args)
@@ -251,6 +253,8 @@ endif
 
 test_opencl_node.$(TEST_EXT): LIBS += $(OPENCL.LIB)
 
+test_arena_constraints_hwloc.$(TEST_EXT): LIBS += $(HWLOC.LIB)
+
 $(TEST_TBB_PLAIN.EXE) $(TEST_TBB_SPECIAL.EXE): WARNING_KEY += $(TEST_WARNING_KEY)
 
 # Run tests that are in SCHEDULER_DIRECTLY_INCLUDED and TEST_TBB_PLAIN.EXE but not in skip_tests (which is specified by user)
@@ -272,7 +276,7 @@ test_tbb_plain: $(TEST_PREREQUISITE) $(TESTS_TO_RUN)
 
 # For deprecated files, we don't mind warnings etc., thus compilation rules are most relaxed
 CPLUS_FLAGS_DEPRECATED = $(DEFINE_KEY)__TBB_TEST_DEPRECATED=1 $(subst $(WARNING_KEY),,$(CPLUS_FLAGS)) $(WARNING_SUPPRESS) $(INCLUDE_KEY)$(tbb_root)/src/test
-TEST_TBB_OLD.OBJ = test_concurrent_vector_v2.$(OBJ) test_concurrent_queue_v2.$(OBJ) test_mutex_v2.$(OBJ) test_task_scheduler_observer_v3.$(OBJ) 
+TEST_TBB_OLD.OBJ = test_concurrent_vector_v2.$(OBJ) test_concurrent_queue_v2.$(OBJ) test_mutex_v2.$(OBJ) test_task_scheduler_observer_v3.$(OBJ)
 
 $(TEST_TBB_OLD.OBJ): CPLUS_FLAGS := $(CPLUS_FLAGS_DEPRECATED)
 
diff --git a/src/tbb/build/OpenBSD.clang.inc b/src/tbb/build/OpenBSD.clang.inc
new file mode 100644
index 00000000..0acc5eb2
--- /dev/null
+++ b/src/tbb/build/OpenBSD.clang.inc
@@ -0,0 +1,15 @@
+# Copyright (c) 2005-2020 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 $(tbb_root)/build/BSD.clang.inc
diff --git a/src/tbb/build/OpenBSD.inc b/src/tbb/build/OpenBSD.inc
new file mode 100644
index 00000000..8b85bf02
--- /dev/null
+++ b/src/tbb/build/OpenBSD.inc
@@ -0,0 +1,15 @@
+# Copyright (c) 2005-2020 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 $(tbb_root)/build/BSD.inc
diff --git a/src/tbb/build/SunOS.gcc.inc b/src/tbb/build/SunOS.gcc.inc
index 2ebed62f..2af7a682 100644
--- a/src/tbb/build/SunOS.gcc.inc
+++ b/src/tbb/build/SunOS.gcc.inc
@@ -1,4 +1,4 @@
-# Copyright (c) 2005-2017 Intel Corporation
+# Copyright (c) 2005-2020 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -11,10 +11,6 @@
 # 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.
-#
-#
-#
-#
 
 COMPILE_ONLY = -c -MMD
 PREPROC_ONLY = -E -x c++
@@ -25,8 +21,8 @@ OUTPUTOBJ_KEY = -o #
 PIC_KEY = -fPIC
 WARNING_AS_ERROR_KEY = -Werror
 WARNING_KEY = -Wall
-TEST_WARNING_KEY = -Wshadow -Wcast-qual -Woverloaded-virtual -Wnon-virtual-dtor $(if $(findstring cc4., $(runtime)),-Wextra)
-WARNING_SUPPRESS = -Wno-parentheses -Wno-non-virtual-dtor   
+TEST_WARNING_KEY = -Wshadow -Wcast-qual -Woverloaded-virtual -Wnon-virtual-dtor -Wextra
+WARNING_SUPPRESS = -Wno-parentheses -Wno-non-virtual-dtor
 DYLIB_KEY = -shared
 LIBDL = -ldl
 
@@ -64,12 +60,9 @@ ifeq (ia32,$(arch))
 endif 
 
 # for some gcc versions on Solaris, -m64 may imply V9, but perhaps not everywhere (TODO: verify)
-# RcppParallel: CRAN uses 32-bit SPARC so we force that here
 ifeq (sparc,$(arch))
-    CPLUS_FLAGS += -m32
-    LIB_LINK_FLAGS += -m32
-#   CPLUS_FLAGS    += -mcpu=v9 -m64
-#   LIB_LINK_FLAGS += -mcpu=v9 -m64
+    CPLUS_FLAGS    += -mcpu=v9 -m64
+    LIB_LINK_FLAGS += -mcpu=v9 -m64
 endif 
 
 #------------------------------------------------------------------------------
diff --git a/src/tbb/build/SunOS.inc b/src/tbb/build/SunOS.inc
index 447e059e..30a2e684 100644
--- a/src/tbb/build/SunOS.inc
+++ b/src/tbb/build/SunOS.inc
@@ -1,4 +1,4 @@
-# Copyright (c) 2005-2017 Intel Corporation
+# Copyright (c) 2005-2020 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -11,10 +11,6 @@
 # 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.
-#
-#
-#
-#
 
 ifndef arch
         arch:=$(shell uname -p)
@@ -31,7 +27,7 @@ ifndef arch
 endif
 
 ifndef runtime
-        gcc_version:=$(shell gcc -dumpversion)
+        gcc_version:=$(shell gcc -dumpfullversion -dumpversion)
         os_version:=$(shell uname -r)
         os_kernel_version:=$(shell uname -r | sed -e 's/-.*$$//')
         export runtime:=cc$(gcc_version)_kernel$(os_kernel_version)
diff --git a/src/tbb/build/SunOS.suncc.inc b/src/tbb/build/SunOS.suncc.inc
index b9cc946e..b0dfa484 100644
--- a/src/tbb/build/SunOS.suncc.inc
+++ b/src/tbb/build/SunOS.suncc.inc
@@ -1,4 +1,4 @@
-# Copyright (c) 2005-2017 Intel Corporation
+# Copyright (c) 2005-2020 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -11,10 +11,6 @@
 # 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.
-#
-#
-#
-#
 
 COMPILE_ONLY = -c -xMMD -errtags
 PREPROC_ONLY = -E -xMMD
@@ -31,8 +27,7 @@ WARNING_AS_ERROR_KEY = Warning as error
 WARNING_SUPPRESS = -erroff=unassigned,attrskipunsup,badargtype2w,badbinaryopw,wbadasg,wvarhidemem,inlasmpnu
 tbb_strict=0
 
-# RcppParallel patch: -library=stlport4
-CPLUS = CC -library=stlport4
+CPLUS = CC
 CONLY = cc
 
 OPENMP_FLAG = -xopenmp
diff --git a/src/tbb/build/android.clang.inc b/src/tbb/build/android.clang.inc
index a935968c..6edc48f7 100644
--- a/src/tbb/build/android.clang.inc
+++ b/src/tbb/build/android.clang.inc
@@ -1,4 +1,4 @@
-# Copyright (c) 2005-2017 Intel Corporation
+# Copyright (c) 2005-2020 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -11,10 +11,6 @@
 # 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.
-#
-#
-#
-#
 
 
 COMPILE_ONLY = -c -MMD
@@ -68,8 +64,20 @@ ifeq (0, $(dynamic_load))
 endif
 
 # Paths to the NDK prebuilt tools and libraries
-CPLUS_FLAGS    += --sysroot=$(SYSROOT)
+ifeq (,$(findstring $(ndk_version), $(foreach v, 7 8 9 10 11 12 13 14 15,r$(v) r$(v)b r$(v)c r$(v)d r$(v)e)))
+    # Since Android* NDK r16 another sysroot and isystem paths have to be specified
+    CPLUS_FLAGS += --sysroot=$(NDK_ROOT)/sysroot -isystem $(NDK_ROOT)/sysroot/usr/include/$(TRIPLE)
+    # Android* version flag required since r16
+    CPLUS_FLAGS += -D__ANDROID_API__=$(API_LEVEL)
+else
+    CPLUS_FLAGS += --sysroot=$(SYSROOT)
+endif
+
+# Library sysroot flag
 LIB_LINK_FLAGS += --sysroot=$(SYSROOT)
+# Flag for test executables
+LINK_FLAGS     += --sysroot=$(SYSROOT)
+
 LIBS           = -L$(CPLUS_LIB_PATH) -lc++_shared
 ifeq (,$(findstring $(ndk_version),$(foreach v, 7 8 9 10 11,r$(v) r$(v)b r$(v)c r$(v)d r$(v)e)))
     LIBS +=  -lc++abi
diff --git a/src/tbb/build/android.gcc.inc b/src/tbb/build/android.gcc.inc
index 973ca3f0..980a8cac 100644
--- a/src/tbb/build/android.gcc.inc
+++ b/src/tbb/build/android.gcc.inc
@@ -1,4 +1,4 @@
-# Copyright (c) 2005-2017 Intel Corporation
+# Copyright (c) 2005-2020 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -11,10 +11,6 @@
 # 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.
-#
-#
-#
-#
 
 
 COMPILE_ONLY = -c -MMD
diff --git a/src/tbb/build/android.icc.inc b/src/tbb/build/android.icc.inc
index 64da9fd1..6ba64d19 100644
--- a/src/tbb/build/android.icc.inc
+++ b/src/tbb/build/android.icc.inc
@@ -1,4 +1,4 @@
-# Copyright (c) 2005-2017 Intel Corporation
+# Copyright (c) 2005-2020 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -11,10 +11,6 @@
 # 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.
-#
-#
-#
-#
 
 
 COMPILE_ONLY = -c -MMD
diff --git a/src/tbb/build/android.inc b/src/tbb/build/android.inc
index aeeb68c5..3832ee53 100644
--- a/src/tbb/build/android.inc
+++ b/src/tbb/build/android.inc
@@ -1,4 +1,4 @@
-# Copyright (c) 2005-2017 Intel Corporation
+# Copyright (c) 2005-2020 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -11,10 +11,6 @@
 # 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.
-#
-#
-#
-#
 
 #
 # Extra gmake command-line parameters for use with Android:
diff --git a/src/tbb/build/android.linux.inc b/src/tbb/build/android.linux.inc
index 7d022434..a7d2b183 100644
--- a/src/tbb/build/android.linux.inc
+++ b/src/tbb/build/android.linux.inc
@@ -1,4 +1,4 @@
-# Copyright (c) 2005-2017 Intel Corporation
+# Copyright (c) 2005-2020 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -11,10 +11,6 @@
 # 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.
-#
-#
-#
-#
 
 ####### Detections and Commands ###############################################
 
diff --git a/src/tbb/build/android.linux.launcher.sh b/src/tbb/build/android.linux.launcher.sh
index b3cf8764..2643d3e0 100644
--- a/src/tbb/build/android.linux.launcher.sh
+++ b/src/tbb/build/android.linux.launcher.sh
@@ -1,6 +1,6 @@
 #!/bin/sh
 #
-# Copyright (c) 2005-2017 Intel Corporation
+# Copyright (c) 2005-2020 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -13,10 +13,6 @@
 # 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.
-#
-#
-#
-#
 
 # Usage:
 # android.linux.launcher.sh [-v] [-q] [-s] [-r <repeats>] [-u] [-l <library>] <executable> <arg1> <arg2> <argN>
diff --git a/src/tbb/build/android.macos.inc b/src/tbb/build/android.macos.inc
index bf84578a..a48ee32b 100644
--- a/src/tbb/build/android.macos.inc
+++ b/src/tbb/build/android.macos.inc
@@ -1,4 +1,4 @@
-# Copyright (c) 2005-2017 Intel Corporation
+# Copyright (c) 2005-2020 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -11,10 +11,6 @@
 # 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.
-#
-#
-#
-#
 
 ####### Detections and Commands ###############################################
 
diff --git a/src/tbb/build/android.windows.inc b/src/tbb/build/android.windows.inc
index f58e5d52..a56f9a98 100644
--- a/src/tbb/build/android.windows.inc
+++ b/src/tbb/build/android.windows.inc
@@ -1,4 +1,4 @@
-# Copyright (c) 2005-2017 Intel Corporation
+# Copyright (c) 2005-2020 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -11,10 +11,6 @@
 # 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.
-#
-#
-#
-#
 
 ####### Detections and Commands ###############################################
 
diff --git a/src/tbb/build/big_iron.inc b/src/tbb/build/big_iron.inc
index efed2125..abe6accc 100644
--- a/src/tbb/build/big_iron.inc
+++ b/src/tbb/build/big_iron.inc
@@ -1,4 +1,4 @@
-# Copyright (c) 2005-2017 Intel Corporation
+# Copyright (c) 2005-2020 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -11,10 +11,6 @@
 # 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.
-#
-#
-#
-#
 
 #------------------------------------------------------------------------------
 # Defines settings for building the TBB run-time as a static library.
diff --git a/src/tbb/build/build.py b/src/tbb/build/build.py
new file mode 100644
index 00000000..c0ab1519
--- /dev/null
+++ b/src/tbb/build/build.py
@@ -0,0 +1,204 @@
+#!/usr/bin/env python
+#
+# Copyright (c) 2017-2020 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.
+
+# Provides unified tool for preparing TBB for packaging
+
+from __future__ import print_function
+import os
+import re
+import sys
+import shutil
+import platform
+import argparse
+from glob import glob
+from collections import OrderedDict
+
+jp = os.path.join
+is_win = (platform.system() == 'Windows')
+is_lin = (platform.system() == 'Linux')
+is_mac = (platform.system() == 'Darwin')
+
+default_prefix = os.getenv('PREFIX', 'install_prefix')
+if is_win:
+    default_prefix = jp(default_prefix, 'Library') # conda-specific by default on Windows
+
+parser = argparse.ArgumentParser()
+parser.add_argument('--tbbroot',        default='.', help='Take Intel TBB from here')
+parser.add_argument('--prefix',         default=default_prefix, help='Prefix')
+parser.add_argument('--prebuilt',       default=[],    action='append', help='Directories to find prebuilt files')
+parser.add_argument('--no-rebuild',     default=False, action='store_true', help='do not rebuild')
+parser.add_argument('--install',        default=False, action='store_true', help='install all')
+parser.add_argument('--install-libs',   default=False, action='store_true', help='install libs')
+parser.add_argument('--install-devel',  default=False, action='store_true', help='install devel')
+parser.add_argument('--install-docs',   default=False, action='store_true', help='install docs')
+parser.add_argument('--install-python', default=False, action='store_true', help='install python module')
+parser.add_argument('--make-tool',      default='make', help='Use different make command instead')
+parser.add_argument('--copy-tool',      default=None, help='Use this command for copying ($ tool file dest-dir)')
+parser.add_argument('--build-args',     default="", help='specify extra build args')
+parser.add_argument('--build-prefix',   default='local', help='build dir prefix')
+parser.add_argument('--cmake-dir',      help='directory to install CMake configuration files. Default: <prefix>/lib/cmake/tbb')
+if is_win:
+    parser.add_argument('--msbuild',   default=False, action='store_true', help='Use msbuild')
+    parser.add_argument('--vs',          default="2012", help='select VS version for build')
+    parser.add_argument('--vs-platform', default="x64",  help='select VS platform for build')
+parser.add_argument('ignore', nargs='?', help="workaround conda-build issue #2512")
+
+args = parser.parse_args()
+
+if args.install:
+    args.install_libs  = True
+    args.install_devel = True
+    args.install_docs  = True
+    args.install_python= True
+
+def custom_cp(src, dst):
+     assert os.system(' '.join([args.copy_tool, src, dst])) == 0
+
+if args.copy_tool:
+    install_cp = custom_cp # e.g. to use install -p -D -m 755 on Linux
+else:
+    install_cp = shutil.copy
+
+bin_dir   = jp(args.prefix, "bin")
+lib_dir   = jp(args.prefix, "lib")
+inc_dir   = jp(args.prefix, 'include')
+doc_dir   = jp(args.prefix, 'share', 'doc', 'tbb')
+cmake_dir = jp(args.prefix, "lib", "cmake", "tbb") if args.cmake_dir is None else args.cmake_dir
+
+if is_win:
+    os.environ["OS"] = "Windows_NT" # make sure TBB will interpret it correctly
+    libext = '.dll'
+    libpref = ''
+    dll_dir = bin_dir
+else:
+    libext = '.dylib' if is_mac else '.so.2'
+    libpref = 'lib'
+    dll_dir = lib_dir
+
+tbb_names = ["tbb", "tbbmalloc", "tbbmalloc_proxy"]
+
+##############################################################
+
+def system(arg):
+    print('$ ', arg)
+    return os.system(arg)
+
+def run_make(arg):
+    if system('%s -j %s'% (args.make_tool, arg)) != 0:
+       print("\nBummer. Running serial build in order to recover the log and have a chance to fix the build")
+       assert system('%s %s'% (args.make_tool, arg)) == 0
+
+os.chdir(args.tbbroot)
+if args.prebuilt:
+    release_dirs = sum([glob(d) for d in args.prebuilt], [])
+    print("Using pre-built files from ", release_dirs)
+else:
+    if is_win and args.msbuild:
+        preview_release_dir = release_dir = jp(args.tbbroot, 'build', 'vs'+args.vs, args.vs_platform, 'Release')
+        if not args.no_rebuild or not os.path.isdir(release_dir):
+            assert os.system('msbuild /m /p:Platform=%s /p:Configuration=Release %s build/vs%s/makefile.sln'% \
+                            (args.vs_platform, args.build_args, args.vs)) == 0
+        preview_debug_dir = debug_dir = jp(args.tbbroot, 'build', 'vs'+args.vs, args.vs_platform, 'Debug')
+        if not args.no_rebuild or not os.path.isdir(debug_dir):
+            assert os.system('msbuild /m /p:Platform=%s /p:Configuration=Debug %s build/vs%s/makefile.sln'% \
+                            (args.vs_platform, args.build_args, args.vs)) == 0
+    else:
+        release_dir = jp(args.tbbroot, 'build', args.build_prefix+'_release')
+        debug_dir = jp(args.tbbroot, 'build', args.build_prefix+'_debug')
+        if not args.no_rebuild or not (os.path.isdir(release_dir) and os.path.isdir(debug_dir)):
+            run_make('tbb_build_prefix=%s %s'% (args.build_prefix, args.build_args))
+        preview_release_dir = jp(args.tbbroot, 'build', args.build_prefix+'_preview_release')
+        preview_debug_dir = jp(args.tbbroot, 'build', args.build_prefix+'_preview_debug')
+        if not args.no_rebuild or not (os.path.isdir(preview_release_dir) and os.path.isdir(preview_debug_dir)):
+            run_make('tbb_build_prefix=%s_preview %s tbb_cpf=1 tbb'% (args.build_prefix, args.build_args))
+    release_dirs = [release_dir, debug_dir, preview_release_dir, preview_debug_dir]
+
+filemap = OrderedDict()
+def append_files(names, dst, paths=release_dirs):
+    global filemap
+    files = sum([glob(jp(d, f)) for d in paths for f in names], [])
+    filemap.update(dict(zip(files, [dst]*len(files))))
+
+
+if args.install_libs:
+    append_files([libpref+f+libext for f in tbb_names], dll_dir)
+
+if args.install_devel:
+    dll_files = [libpref+f+'_debug'+libext for f in tbb_names]          # adding debug libraries
+    if not is_win or not args.msbuild:
+        dll_files += [libpref+"tbb_preview"+libext, libpref+"tbb_preview_debug"+libext]
+    if is_win:
+        dll_files += ['tbb*.pdb']                                       # copying debug info
+    if is_lin:
+        dll_files += ['libtbb*.so']                                     # copying linker scripts
+        # symlinks .so -> .so.2 should not be created instead
+        # since linking with -ltbb when using links can result in
+        # incorrect dependence upon unversioned .so files
+    append_files(dll_files, dll_dir)
+    if is_win:
+        append_files(['*.lib', '*.def'], lib_dir)                       # copying linker libs and defs
+    for rootdir, dirnames, filenames in os.walk(jp(args.tbbroot,'include')):
+        files = [f for f in filenames if not '.html' in f]
+        append_files(files, jp(inc_dir, rootdir.split('include')[1][1:]), paths=(rootdir,))
+
+    # Preparing CMake configuration files
+    cmake_build_dir = jp(args.tbbroot, 'build', args.build_prefix+'_release', 'cmake_configs')
+    assert system('cmake -DINSTALL_DIR=%s -DSYSTEM_NAME=%s -DTBB_VERSION_FILE=%s -DINC_REL_PATH=%s -DLIB_REL_PATH=%s -DBIN_REL_PATH=%s -P %s' % \
+                  (cmake_build_dir,
+                   platform.system(),
+                   jp(args.tbbroot, 'include', 'tbb', 'tbb_stddef.h'),
+                   os.path.relpath(inc_dir, cmake_dir),
+                   os.path.relpath(lib_dir, cmake_dir),
+                   os.path.relpath(bin_dir, cmake_dir),
+                   jp(args.tbbroot, 'cmake', 'tbb_config_installer.cmake'))) == 0
+    append_files(['TBBConfig.cmake', 'TBBConfigVersion.cmake'], cmake_dir, paths=[cmake_build_dir])
+
+if args.install_python: # RML part
+    irml_dir = jp(args.tbbroot, 'build', args.build_prefix+'_release')
+    run_make('-C src tbb_build_prefix=%s %s python_rml'% (args.build_prefix, args.build_args))
+    if is_lin:
+        append_files(['libirml.so.1'], dll_dir, paths=[irml_dir])
+
+if args.install_docs:
+    files = [
+            'CHANGES',
+            'LICENSE',
+            'README',
+            'README.md',
+            'Release_Notes.txt',
+            ]
+    append_files(files, doc_dir, paths=release_dirs+[jp(args.tbbroot, d) for d in ('.', 'doc')])
+
+for f in filemap.keys():
+    assert os.path.exists(f)
+    assert os.path.isfile(f)
+
+if filemap:
+    print("Copying to prefix =", args.prefix)
+for f, dest in filemap.items():
+    if not os.path.isdir(dest):
+        os.makedirs(dest)
+    print("+ %s to $prefix%s"%(f,dest.replace(args.prefix, '')))
+    install_cp(f, dest)
+
+if args.install_python: # Python part
+    paths = [os.path.abspath(d) for d in [args.prefix, inc_dir, irml_dir, lib_dir]+release_dirs]
+    os.environ["TBBROOT"] = paths[0]
+    # all the paths must be relative to python/ directory or be absolute
+    assert system('python python/setup.py build -b%s build_ext -I%s -L%s install -f'% \
+        (paths[2], paths[1], ':'.join(paths[2:]))) == 0
+
+print("done")
diff --git a/src/tbb/build/common.inc b/src/tbb/build/common.inc
index b2c20de6..815fa682 100644
--- a/src/tbb/build/common.inc
+++ b/src/tbb/build/common.inc
@@ -1,4 +1,4 @@
-# Copyright (c) 2005-2017 Intel Corporation
+# Copyright (c) 2005-2020 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -11,10 +11,6 @@
 # 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.
-#
-#
-#
-#
 
 ifndef tbb_os
 
@@ -54,6 +50,14 @@ ifdef cpp0x
     override cpp0x=
 endif
 
+# Define C & C++ compilers according to platform defaults or CXX & CC environment variables
+ifneq (,$(findstring environment, $(origin CXX)))
+    CPLUS = $(CXX)
+endif
+ifneq (,$(findstring environment, $(origin CC)))
+    CONLY = $(CC)
+endif
+
 ifneq (,$(stdver))
     ifeq (,$(findstring ++, $(stdver)))
         $(warning "Warning: unexpected stdver=$(stdver) is used.")
@@ -152,8 +156,8 @@ ifndef BUILDING_PHASE
 
 .DELETE_ON_ERROR:    # Make will delete target if error occurred when building it.
 
-# MAKEOVERRIDES contains the command line variable definitions. Reseting it to
-# empty allows propogating all exported overridden variables to nested makes.
+# MAKEOVERRIDES contains the command line variable definitions. Resetting it to
+# empty allows propagating all exported overridden variables to nested makes.
 # NOTEs:
 #   1. All variable set in command line are propagated to nested makes.
 #   2. All variables declared with the "export" keyword are propagated to
diff --git a/src/tbb/build/common_rules.inc b/src/tbb/build/common_rules.inc
index faf6546f..64bd74ab 100644
--- a/src/tbb/build/common_rules.inc
+++ b/src/tbb/build/common_rules.inc
@@ -1,4 +1,4 @@
-# Copyright (c) 2005-2017 Intel Corporation
+# Copyright (c) 2005-2020 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -11,10 +11,6 @@
 # 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.
-#
-#
-#
-#
 
 
 ifeq ($(tbb_strict),1)
@@ -46,6 +42,10 @@ endif
 INCLUDES += $(INCLUDE_KEY)$(tbb_root)/src $(INCLUDE_KEY)$(tbb_root)/src/rml/include $(INCLUDE_KEY)$(tbb_root)/include
 
 CPLUS_FLAGS += $(WARNING_KEY) $(CXXFLAGS)
+
+# Suppress warnings about usage of deprecated content
+CPLUS_FLAGS += $(DEFINE_KEY)TBB_SUPPRESS_DEPRECATED_MESSAGES=1
+
 ifeq (1,$(tbb_cpf))
 CPLUS_FLAGS += $(DEFINE_KEY)__TBB_CPF_BUILD=1
 endif
@@ -63,6 +63,7 @@ ifeq ($(origin LIB_LINK_LIBS), undefined)
     LIB_LINK_LIBS = $(LIBDL) $(LIBS)
 endif
 
+# some platforms do not provide separate C-only compiler
 CONLY ?= $(CPLUS)
 
 # The most generic rules
@@ -88,7 +89,7 @@ $(foreach t,%.$(OBJ) $(TEST_AFFIXES_OBJS),$(eval $(call make-cxx-obj,$(t))))
 #$(2) - is the input obj files and libraries
 define make-test-binary
 	$(CPLUS) $(OUTPUT_KEY)$(strip $1) $(CPLUS_FLAGS) $(2) $(LIBS) $(LINK_FLAGS)
-endef 
+endef
 
 # LINK_FILES the list of options to link test specific files (libraries and object files)
 LINK_FILES+=$(TEST_LIBS)
@@ -100,7 +101,7 @@ LINK_FILES+=$(TEST_LIBS)
 %_dll.$(DLL): LINK_FLAGS += $(PIC_KEY) $(DYLIB_KEY)
 %_dll.$(DLL): TEST_LIBS := $(subst %_dll.$(DLL),,$(TEST_LIBS))
 %_dll.$(DLL): %_dll.$(OBJ)
-	$(call make-test-binary,$@,$< $(subst %_dll.$(DLL),,$(LINK_FILES)))
+	$(call make-test-binary,$@,$< $(LINK_FILES))
 .PRECIOUS: %_dll.$(OBJ) %_dll.$(DLL)
 
 %.$(OBJ): %.c
@@ -113,12 +114,6 @@ LINK_FILES+=$(TEST_LIBS)
 	cpp <$< | grep -v '^#' >$*.tmp
 	$(ASM) $(ASM_FLAGS) -o $@ $*.tmp
 
-ifdef rtools
-# Line 70 doesn't work with rtool's version of make. The symptom being that the asm rule kicks off instead, and these rules are cl only
-%.$(OBJ): %.cpp
-	$(CPLUS) $(OUTPUTOBJ_KEY)$@ $(COMPILE_ONLY) $(CPLUS_FLAGS) $(CXX_ONLY_FLAGS) $(CXX_WARN_SUPPRESS) $(INCLUDES) $<
-endif
-
 # Rule for generating .E file if needed for visual inspection
 # Note that ICL treats an argument after PREPROC_ONLY as a file to open,
 # so all uses of PREPROC_ONLY should be immediately followed by a file name
diff --git a/src/tbb/build/detect.js b/src/tbb/build/detect.js
index b2a0943b..ef8ccc15 100644
--- a/src/tbb/build/detect.js
+++ b/src/tbb/build/detect.js
@@ -1,4 +1,4 @@
-// Copyright (c) 2005-2017 Intel Corporation
+// Copyright (c) 2005-2020 Intel Corporation
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -11,10 +11,6 @@
 // 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.
-//
-//
-//
-//
 
 function readAllFromFile(fname) {
     var fso = new ActiveXObject("Scripting.FileSystemObject");
@@ -55,18 +51,24 @@ function doWork() {
                     WScript.Echo("unknown");
                 }
             } else {
-                tmpExec = WshShell.Exec(compilerPath + " -dumpversion");
+                tmpExec = WshShell.Exec(compilerPath + " -dumpfullversion -dumpversion");
                 var gccVersion = tmpExec.StdOut.ReadLine();
                 if (WScript.Arguments(0) == "/runtime") {
                     WScript.Echo("mingw" + gccVersion);
                 }
                 else if (WScript.Arguments(0) == "/minversion") {
-                    // Comparing strings, not numbers; will not work for two-digit versions
-                    if (gccVersion >= WScript.Arguments(2)) {
-                        WScript.Echo("ok");
-                    } else {
-                        WScript.Echo("fail");
+                    for (var i = 0; i < 3; i++) {
+                        v1 = parseInt(gccVersion.split('.')[i]);
+                        v2 = parseInt(WScript.Arguments(2).split('.')[i]);
+
+                        if (v1 > v2) {
+                            break;
+                        } else if (v1 < v2) {
+                            WScript.Echo("fail");
+                            return;
+                        }
                     }
+                    WScript.Echo("ok");
                 }
             }
             return;
@@ -125,6 +127,8 @@ function doWork() {
         } else if (mapContext.match(vc140)) {
             if (WshShell.ExpandEnvironmentStrings("%VisualStudioVersion%") == "15.0")
                 WScript.Echo("vc14.1");
+            else if (WshShell.ExpandEnvironmentStrings("%VisualStudioVersion%") == "16.0")
+                WScript.Echo("vc14.2");
             else
                 WScript.Echo("vc14");
         } else {
diff --git a/src/tbb/build/generate_tbbvars.bat b/src/tbb/build/generate_tbbvars.bat
index 8925f577..12173280 100644
--- a/src/tbb/build/generate_tbbvars.bat
+++ b/src/tbb/build/generate_tbbvars.bat
@@ -1,6 +1,6 @@
 @echo off
 REM
-REM Copyright (c) 2005-2017 Intel Corporation
+REM Copyright (c) 2005-2020 Intel Corporation
 REM
 REM Licensed under the Apache License, Version 2.0 (the "License");
 REM you may not use this file except in compliance with the License.
@@ -14,10 +14,6 @@ REM WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 REM See the License for the specific language governing permissions and
 REM limitations under the License.
 REM
-REM
-REM
-REM
-REM
 setlocal
 for %%D in ("%tbb_root%") do set actual_root=%%~fD
 set fslash_root=%actual_root:\=/%
diff --git a/src/tbb/build/generate_tbbvars.sh b/src/tbb/build/generate_tbbvars.sh
index 0ca0965a..4106ed3f 100644
--- a/src/tbb/build/generate_tbbvars.sh
+++ b/src/tbb/build/generate_tbbvars.sh
@@ -1,6 +1,6 @@
 #!/bin/bash
 #
-# Copyright (c) 2005-2017 Intel Corporation
+# Copyright (c) 2005-2020 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -13,10 +13,6 @@
 # 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.
-#
-#
-#
-#
 
 # Script used to generate tbbvars.[c]sh scripts
 bin_dir="$PWD"  # 
diff --git a/src/tbb/build/index.html b/src/tbb/build/index.html
index 4d0ac7c8..0aeafa73 100644
--- a/src/tbb/build/index.html
+++ b/src/tbb/build/index.html
@@ -18,6 +18,9 @@ <H2>Files</H2>
 <DT><A HREF="Makefile.tbbmalloc">Makefile.tbbmalloc</A>
 <DD>Main Makefile to build the Intel TBB scalable memory allocator library as well as its tests.
     Invoked via 'make tbbmalloc' from <A HREF="../Makefile">top-level Makefile</A>.
+<DT><A HREF="Makefile.tbbbind">Makefile.tbbbind</A>
+<DD>Main Makefile to build the tbbbind library.
+    Invoked via 'make tbbbind' from <A HREF="../Makefile">top-level Makefile</A>
 <DT><A HREF="Makefile.test">Makefile.test</A>
 <DD>Main Makefile to build and run the tests for the Intel TBB library.
     Invoked via 'make test' from <A HREF="../Makefile">top-level Makefile</A>.
@@ -73,7 +76,7 @@ <H3>Software prerequisites:</H3>
 <LI>Explicitly specify the architecture when invoking GNU make, e.g. <TT>make arch=ia32</TT>.
 </OL>
 
-<P>The default make target will build the release and debug versions of the Intel TBB library.</P>
+<P>The default make target will build the release version of the Intel TBB library.</P>
 <P>Other targets are available in the top-level Makefile. You might find the following targets useful:
 <UL>
 <LI><TT>make test</TT> will build and run Intel TBB <A HREF="../src/test">unit-tests</A>;
@@ -111,13 +114,15 @@ <H3>Software prerequisites:</H3>
     <DT><TT>cd src;make debug</TT>
     <DD>Build and test debug libraries only. 
     <DT><TT>make tbb</TT>
-    <DD>Make Intel TBB release and debug libraries.
+    <DD>Make Intel TBB release libraries.
     <DT><TT>make tbbmalloc</TT>
     <DD>Make Intel TBB scalable memory allocator libraries.
+    <DT><TT>make tbbbind</TT>
+    <DD>Make the tbbbind library.
     <DT><TT>make test</TT>
     <DD>Compile and run unit-tests
     <DT><TT>make examples</TT>
-    <DD>Build libraries and run all examples, like doing <TT>make debug clean release</TT> from <A HREF="../examples/Makefile">the general example Makefile</A>.
+    <DD>Build libraries and run all examples, like doing <TT>make clean release</TT> from <A HREF="../examples/Makefile">the general example Makefile</A>.
         Available in the open-source version only.
     <DT><TT>make python</TT>
     <DD>Build, install, and test Python* API for Intel TBB. See <A HREF="../python/index.html">details here</A>.
@@ -134,8 +139,8 @@ <H3>Software prerequisites:</H3>
     <DD>Build and run as above, but additionally specify the version of the C++ standard or dialect to be used by
       the compiler. The specified value of <TT>stdver</TT> will be used as a parameter to the appropriate
       compiler option (such as <TT>-std</TT>); the behavior in case of unsupported value is compiler-specific.
-    <DT><TT>make target_app=<B>{</B>win8ui, uwp<B>}</B> [target_mode=store] <B>[</B>(above options or targets)<B>]</B></TT>
-    <DD>Build and run as above, but use API that is compliant with Universal Windows* applications. Use <TT>win8ui</TT> option, if you want to use Intel TBB in Windows* 8 Universal application and <TT>uwp</TT> in case of Windows* 10 Universal Windows application.
+    <DT><TT>make target_app=<B>{</B>win8ui, uwp, uwd<B>}</B> [target_mode=store] <B>[</B>(above options or targets)<B>]</B></TT>
+    <DD>Build and run as above, but use API that is compliant with Universal Windows* applications. Use <TT>win8ui</TT> option, if you want to use Intel TBB in Windows* 8 Universal application, <TT>uwp</TT> in case of Windows* 10 Universal Windows application and <TT>uwd</TT> for the usage inside Universal Windows* driver.
     <TT>target_mode=store</TT> is used to produce binaries that are compliant with Windows Store* application container. In later case they won't work with Intel TBB unit tests but work only with Windows Store* applications.
     <DT><TT>ndk-build target=android <B>[</B>(above options or targets)<B>]</B></TT>
     <DD>Build and run as above, but build libraries for Android* OS by Android NDK that should be installed. Makefiles were tested with revision 8.
@@ -233,7 +238,7 @@ <H4>To port the Makefile infrastructure:</H4>
 <HR>
 <A HREF="../index.html">Up to parent directory</A>
 <P></P>
-Copyright &copy; 2005-2017 Intel Corporation.  All Rights Reserved.
+Copyright &copy; 2005-2020 Intel Corporation.  All Rights Reserved.
 <P></P>
 Intel, the Intel logo and Itanium are trademarks of Intel Corporation or its subsidiaries in the U.S. and/or other countries.
 <p></p>
diff --git a/src/tbb/build/ios.clang.inc b/src/tbb/build/ios.clang.inc
index 265e9fa1..a97aad59 100644
--- a/src/tbb/build/ios.clang.inc
+++ b/src/tbb/build/ios.clang.inc
@@ -1,4 +1,4 @@
-# Copyright (c) 2005-2017 Intel Corporation
+# Copyright (c) 2005-2020 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -11,13 +11,5 @@
 # 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 $(tbb_root)/build/macos.clang.inc
-
-CPLUS_FLAGS += -miphoneos-version-min=8.0
-LINK_FLAGS += -miphoneos-version-min=8.0
-LIB_LINK_FLAGS += -miphoneos-version-min=8.0
diff --git a/src/tbb/build/ios.macos.inc b/src/tbb/build/ios.macos.inc
index ae723bd5..04f0c090 100644
--- a/src/tbb/build/ios.macos.inc
+++ b/src/tbb/build/ios.macos.inc
@@ -1,4 +1,4 @@
-# Copyright (c) 2005-2017 Intel Corporation
+# Copyright (c) 2005-2020 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -11,10 +11,6 @@
 # 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.
-#
-#
-#
-#
 
 ifneq ($(arch),$(filter $(arch),ia32 intel64 armv7 armv7s arm64))
   $(error $(arch) is unknown architecture. Known arhitechtures are ia32 intel64 armv7 armv7s arm64)
@@ -34,3 +30,5 @@ endif
 
 ios_version:=$(shell echo $(SDKROOT) | sed -e "s/.*[a-z,A-Z]\(.*\).sdk/\1/")
 runtime:=cc$(clang_version)_ios$(ios_version)
+
+IPHONEOS_DEPLOYMENT_TARGET ?= 8.0
diff --git a/src/tbb/build/linux.clang.inc b/src/tbb/build/linux.clang.inc
index edabab26..fe9b5c98 100644
--- a/src/tbb/build/linux.clang.inc
+++ b/src/tbb/build/linux.clang.inc
@@ -1,4 +1,4 @@
-# Copyright (c) 2005-2017 Intel Corporation
+# Copyright (c) 2005-2020 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -11,11 +11,9 @@
 # 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.
-#
-#
-#
-#
 
+CPLUS ?= clang++
+CONLY ?= clang
 COMPILE_ONLY = -c -MMD
 PREPROC_ONLY = -E -x c++
 INCLUDE_KEY = -I
@@ -24,27 +22,29 @@ OUTPUT_KEY = -o #
 OUTPUTOBJ_KEY = -o #
 PIC_KEY = -fPIC
 WARNING_AS_ERROR_KEY = -Werror
-WARNING_KEY = -Wall
-TEST_WARNING_KEY = -Wextra -Wshadow -Wcast-qual -Woverloaded-virtual -Wnon-virtual-dtor
+WARNING_KEY = -Wall -Wextra
+TEST_WARNING_KEY = -Wshadow -Wcast-qual -Woverloaded-virtual -Wnon-virtual-dtor
 WARNING_SUPPRESS = -Wno-parentheses -Wno-non-virtual-dtor -Wno-dangling-else
 DYLIB_KEY = -shared
 EXPORT_KEY = -Wl,--version-script,
 LIBDL = -ldl
 
-CPLUS = clang++
-CONLY = clang
 LIB_LINK_FLAGS = $(DYLIB_KEY) -Wl,-soname=$(BUILDING_LIBRARY)
-LIBS += -lpthread -lrt
+LIBS += -lrt
 LINK_FLAGS = -Wl,-rpath-link=. -rdynamic
 C_FLAGS = $(CPLUS_FLAGS)
 
 ifeq ($(cfg), release)
-        CPLUS_FLAGS = $(ITT_NOTIFY) -g -O2 -DUSE_PTHREAD
+        # -g is set intentionally in the release mode. It should not affect performance.
+        CPLUS_FLAGS = -O2 -g
 endif
 ifeq ($(cfg), debug)
-        CPLUS_FLAGS = -DTBB_USE_DEBUG $(ITT_NOTIFY) -g -O0 -DUSE_PTHREAD
+        CPLUS_FLAGS = -DTBB_USE_DEBUG -O0 -g
 endif
 
+CPLUS_FLAGS += $(ITT_NOTIFY) -DUSE_PTHREAD -pthread
+LIB_LINK_FLAGS += -pthread
+
 ifneq (,$(stdlib))
     CPLUS_FLAGS    += -stdlib=$(stdlib)
     LIB_LINK_FLAGS += -stdlib=$(stdlib)
diff --git a/src/tbb/build/linux.gcc.inc b/src/tbb/build/linux.gcc.inc
index 348bac0f..d820c15d 100644
--- a/src/tbb/build/linux.gcc.inc
+++ b/src/tbb/build/linux.gcc.inc
@@ -1,4 +1,4 @@
-# Copyright (c) 2005-2017 Intel Corporation
+# Copyright (c) 2005-2020 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -11,11 +11,9 @@
 # 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.
-#
-#
-#
-#
 
+CPLUS ?= g++
+CONLY ?= gcc
 COMPILE_ONLY = -c -MMD
 PREPROC_ONLY = -E -x c++
 INCLUDE_KEY = -I
@@ -27,53 +25,56 @@ WARNING_AS_ERROR_KEY = -Werror
 WARNING_KEY = -Wall
 TEST_WARNING_KEY = -Wshadow -Wcast-qual -Woverloaded-virtual -Wnon-virtual-dtor
 
-WARNING_SUPPRESS = -Wno-parentheses -Wno-non-virtual-dtor
+WARNING_SUPPRESS = -Wno-parentheses
 DYLIB_KEY = -shared
 EXPORT_KEY = -Wl,--version-script,
 LIBDL = -ldl
 
-CPLUS = g++
-CONLY = gcc
 LIB_LINK_FLAGS = $(DYLIB_KEY) -Wl,-soname=$(BUILDING_LIBRARY)
-LIBS += -lpthread -lrt
+LIBS += -lrt
 LINK_FLAGS = -Wl,-rpath-link=. -rdynamic
 C_FLAGS = $(CPLUS_FLAGS)
 
 # gcc 4.2 and higher support OpenMP
-ifneq (,$(shell gcc -dumpversion | egrep  "^(4\.[2-9]|[5-9])"))
+ifneq (,$(shell $(CONLY) -dumpfullversion -dumpversion | egrep  "^(4\.[2-9]|[5-9]|1[0-9])"))
     OPENMP_FLAG = -fopenmp
 endif
 
 # gcc 4.8 and later support RTM intrinsics, but require command line switch to enable them
-ifneq (,$(shell gcc -dumpversion | egrep  "^(4\.[8-9]|[5-9])"))
+ifneq (,$(shell $(CONLY) -dumpfullversion -dumpversion | egrep  "^(4\.[8-9]|[5-9]|1[0-9])"))
     RTM_KEY = -mrtm
 endif
 
 # gcc 4.0 and later have -Wextra that is used by some our customers.
-ifneq (,$(shell gcc -dumpversion | egrep  "^([4-9])"))
-    TEST_WARNING_KEY += -Wextra
+ifneq (,$(shell $(CONLY) -dumpfullversion -dumpversion | egrep  "^([4-9]|1[0-9])"))
+    WARNING_KEY += -Wextra
 endif
 
-# gcc 5.0 and later have -Wsuggest-override option
-# enable it via a pre-included header in order to limit to C++11 and above
-ifneq (,$(shell gcc -dumpversion | egrep  "^([5-9])"))
+# gcc 5.0 and later have -Wsuggest-override and -Wno-sized-deallocation options
+ifneq (,$(shell $(CONLY) -dumpfullversion -dumpversion | egrep  "^([5-9]|1[0-9])"))
+    # enable -Wsuggest-override via a pre-included header in order to limit to C++11 and above
     INCLUDE_TEST_HEADERS = -include $(tbb_root)/src/test/harness_preload.h
+    WARNING_SUPPRESS += -Wno-sized-deallocation
 endif
 
 # gcc 6.0 and later have -flifetime-dse option that controls
 # elimination of stores done outside the object lifetime
-ifneq (,$(shell gcc -dumpversion | egrep  "^([6-9])"))
+ifneq (,$(shell $(CONLY) -dumpfullversion -dumpversion | egrep  "^([6-9]|1[0-9])"))
     # keep pre-contruction stores for zero initialization
     DSE_KEY = -flifetime-dse=1
 endif
 
 ifeq ($(cfg), release)
-        CPLUS_FLAGS = $(ITT_NOTIFY) -g -O2 -DUSE_PTHREAD
+        # -g is set intentionally in the release mode. It should not affect performance.
+        CPLUS_FLAGS = -O2 -g
 endif
 ifeq ($(cfg), debug)
-        CPLUS_FLAGS = -DTBB_USE_DEBUG $(ITT_NOTIFY) -g -O0 -DUSE_PTHREAD
+        CPLUS_FLAGS = -DTBB_USE_DEBUG -O0 -g
 endif
 
+CPLUS_FLAGS += $(ITT_NOTIFY) -DUSE_PTHREAD -pthread
+LIB_LINK_FLAGS += -pthread
+
 TBB_ASM.OBJ=
 MALLOC_ASM.OBJ=
 
diff --git a/src/tbb/build/linux.icc.inc b/src/tbb/build/linux.icc.inc
index c1830f57..c61d0e45 100644
--- a/src/tbb/build/linux.icc.inc
+++ b/src/tbb/build/linux.icc.inc
@@ -1,4 +1,4 @@
-# Copyright (c) 2005-2017 Intel Corporation
+# Copyright (c) 2005-2020 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -11,11 +11,9 @@
 # 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.
-#
-#
-#
-#
 
+CPLUS ?= icpc
+CONLY ?= icc
 COMPILE_ONLY = -c -MMD
 PREPROC_ONLY = -E -x c++
 INCLUDE_KEY = -I
@@ -33,22 +31,23 @@ ifneq (,$(shell icc -dumpversion | egrep "1[2-9]\."))
 SDL_FLAGS = -fstack-protector -Wformat -Wformat-security
 endif
 
-CPLUS = icpc
-CONLY = icc
-
 ITT_NOTIFY = -DDO_ITT_NOTIFY
 ifeq (release,$(cfg))
 SDL_FLAGS += -D_FORTIFY_SOURCE=2
-CPLUS_FLAGS = $(ITT_NOTIFY) -O2 -g -DUSE_PTHREAD
+# -g is set intentionally in the release mode. It should not affect performance.
+CPLUS_FLAGS = -O2 -g -qno-opt-report-embed
 else
-CPLUS_FLAGS = $(ITT_NOTIFY) -O0 -g -DUSE_PTHREAD -DTBB_USE_DEBUG
+CPLUS_FLAGS = -O0 -g -DTBB_USE_DEBUG
 endif
 
 LIB_LINK_FLAGS = -shared -static-intel -Wl,-soname=$(BUILDING_LIBRARY) -z relro -z now
-LIBS += -lpthread -lrt
+LIBS += -lrt
 LINK_FLAGS = -rdynamic
 C_FLAGS = $(CPLUS_FLAGS)
 
+CPLUS_FLAGS += $(ITT_NOTIFY) -DUSE_PTHREAD -pthread
+LIB_LINK_FLAGS += -pthread
+
 ifneq (,$(shell icc -dumpversion | egrep  "^1[6-9]\."))
 OPENMP_FLAG = -qopenmp
 else
diff --git a/src/tbb/build/linux.inc b/src/tbb/build/linux.inc
index daeaaf9a..ad1841cb 100644
--- a/src/tbb/build/linux.inc
+++ b/src/tbb/build/linux.inc
@@ -1,4 +1,4 @@
-# Copyright (c) 2005-2017 Intel Corporation
+# Copyright (c) 2005-2020 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -11,10 +11,6 @@
 # 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.
-#
-#
-#
-#
 
 ####### Detections and Commands ###############################################
 
@@ -59,7 +55,7 @@ ifndef arch
 endif
 
 ifndef runtime
-        export gcc_version:=$(shell gcc -dumpversion)
+        export gcc_version:=$(shell gcc -dumpfullversion -dumpversion)
         os_version:=$(shell uname -r)
         os_kernel_version:=$(shell uname -r | sed -e 's/-.*$$//')
         export os_glibc_version_full:=$(shell getconf GNU_LIBC_VERSION | grep glibc | sed -e 's/^glibc //')
@@ -120,6 +116,13 @@ TBB.LIB = $(TBB.DLL)
 TBB_NO_VERSION.DLL=libtbb$(CPF_SUFFIX)$(DEBUG_SUFFIX).$(DLL)
 LINK_TBB.LIB = $(TBB_NO_VERSION.DLL)
 
+TBBBIND_NO_VERSION.DLL = libtbbbind$(DEBUG_SUFFIX).$(DLL)
+TBBBIND.DEF = $(tbb_root)/src/tbb/$(def_prefix)-tbbbind-export.def
+TBBBIND.DLL = $(TBBBIND_NO_VERSION.DLL).$(SONAME_SUFFIX)
+TBBBIND.LIB = $(TBBBIND_NO_VERSION.DLL)
+LINK_TBBBIND.LIB = $(TBBBIND.LIB)
+HWLOC.LIB = -lhwloc
+
 MALLOC_NO_VERSION.DLL = libtbbmalloc$(DEBUG_SUFFIX).$(MALLOC_DLL)
 MALLOC.DEF = $(MALLOC_ROOT)/$(def_prefix)-tbbmalloc-export.def
 MALLOC.DLL = $(MALLOC_NO_VERSION.DLL).$(SONAME_SUFFIX)
diff --git a/src/tbb/build/linux.pathcc.inc b/src/tbb/build/linux.pathcc.inc
index 948f2316..e6290134 100644
--- a/src/tbb/build/linux.pathcc.inc
+++ b/src/tbb/build/linux.pathcc.inc
@@ -1,4 +1,4 @@
-# Copyright (c) 2005-2017 Intel Corporation
+# Copyright (c) 2005-2020 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -11,11 +11,9 @@
 # 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.
-#
-#
-#
-#
 
+CPLUS ?= pathCC
+CONLY ?= pathcc
 COMPILE_ONLY = -c -MMD
 PREPROC_ONLY = -E -x c++
 INCLUDE_KEY = -I
@@ -32,8 +30,6 @@ DYLIB_KEY = -shared
 EXPORT_KEY = -Wl,--version-script,
 LIBDL = -ldl
 
-CPLUS = pathCC
-CONLY = pathcc
 LIB_LINK_FLAGS = $(DYLIB_KEY) -Wl,-soname=$(BUILDING_LIBRARY)
 LIBS += -lstl -lpthread -lrt
 LINK_FLAGS = -Wl,-rpath-link=. -rdynamic
diff --git a/src/tbb/build/linux.xl.inc b/src/tbb/build/linux.xl.inc
index fccb559f..81dbc6f3 100644
--- a/src/tbb/build/linux.xl.inc
+++ b/src/tbb/build/linux.xl.inc
@@ -1,4 +1,4 @@
-# Copyright (c) 2005-2017 Intel Corporation
+# Copyright (c) 2005-2020 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -11,13 +11,11 @@
 # 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.
-#
-#
-#
-#
 
 ####### Detections and Commands ###############################################
 
+CPLUS ?= xlc++_r
+CONLY ?= xlc_r
 COMPILE_ONLY = -c
 PREPROC_ONLY = -E -qsourcetype=c
 INCLUDE_KEY = -I
@@ -34,8 +32,6 @@ DYLIB_KEY = -qmkshrobj
 EXPORT_KEY = -Wl,--version-script,
 LIBDL = -ldl
 
-CPLUS = xlc++_r
-CONLY = xlc_r
 LIB_LINK_FLAGS = $(DYLIB_KEY) -Wl,-soname=$(BUILDING_LIBRARY)
 LIBS = -lpthread -lrt
 C_FLAGS = $(CPLUS_FLAGS)
diff --git a/src/tbb/build/macos.clang.inc b/src/tbb/build/macos.clang.inc
index 32377053..5721a611 100644
--- a/src/tbb/build/macos.clang.inc
+++ b/src/tbb/build/macos.clang.inc
@@ -1,4 +1,4 @@
-# Copyright (c) 2005-2017 Intel Corporation
+# Copyright (c) 2005-2020 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -11,13 +11,9 @@
 # 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.
-#
-#
-#
-#
 
-CPLUS = clang++
-CONLY = clang
+CPLUS ?= clang++
+CONLY ?= clang
 COMPILE_ONLY = -c -MMD
 PREPROC_ONLY = -E -x c++
 INCLUDE_KEY = -I
@@ -44,10 +40,15 @@ else
     CPLUS_FLAGS = -g -O0 -DTBB_USE_DEBUG
 endif
 
-CPLUS_FLAGS += -DUSE_PTHREAD
+CPLUS_FLAGS += -DUSE_PTHREAD $(ITT_NOTIFY)
+
+ifeq (1,$(tbb_cpf))
+# For correct ucontext.h structures layout
+CPLUS_FLAGS += -D_XOPEN_SOURCE
+endif
 
 # For Clang, we add the option to support RTM intrinsics *iff* xtest is found in <immintrin.h>
-ifneq (,$(shell grep xtest `echo "\#include<immintrin.h>" | clang -E -M - 2>&1 | grep immintrin.h` 2>/dev/null))
+ifneq (,$(shell grep xtest `echo "\#include<immintrin.h>" | $(CONLY) -E -M - 2>&1 | grep immintrin.h` 2>/dev/null))
     RTM_KEY = -mrtm
 endif
 
@@ -57,12 +58,14 @@ ifneq (,$(stdlib))
 endif
 
 ifeq (intel64,$(arch))
+    ITT_NOTIFY = -DDO_ITT_NOTIFY
     CPLUS_FLAGS += -m64 $(RTM_KEY)
     LINK_FLAGS += -m64
     LIB_LINK_FLAGS += -m64
 endif
 
 ifeq (ia32,$(arch))
+    ITT_NOTIFY = -DDO_ITT_NOTIFY
     CPLUS_FLAGS += -m32 $(RTM_KEY)
     LINK_FLAGS += -m32
     LIB_LINK_FLAGS += -m32
@@ -92,6 +95,16 @@ ifdef SDKROOT
     LIB_LINK_FLAGS += -L$(SDKROOT)/usr/lib/system -L$(SDKROOT)/usr/lib/
 endif
 
+ifeq (ios,$(target))
+    CPLUS_FLAGS += -miphoneos-version-min=$(IPHONEOS_DEPLOYMENT_TARGET)
+    LINK_FLAGS += -miphoneos-version-min=$(IPHONEOS_DEPLOYMENT_TARGET)
+    LIB_LINK_FLAGS += -miphoneos-version-min=$(IPHONEOS_DEPLOYMENT_TARGET)
+else
+    CPLUS_FLAGS += -mmacosx-version-min=$(MACOSX_DEPLOYMENT_TARGET)
+    LINK_FLAGS += -mmacosx-version-min=$(MACOSX_DEPLOYMENT_TARGET)
+    LIB_LINK_FLAGS += -mmacosx-version-min=$(MACOSX_DEPLOYMENT_TARGET)
+endif
+
 #------------------------------------------------------------------------------
 # Setting assembler data.
 #------------------------------------------------------------------------------
diff --git a/src/tbb/build/macos.gcc.inc b/src/tbb/build/macos.gcc.inc
index 65c7047c..ff3311b5 100644
--- a/src/tbb/build/macos.gcc.inc
+++ b/src/tbb/build/macos.gcc.inc
@@ -1,4 +1,4 @@
-# Copyright (c) 2005-2017 Intel Corporation
+# Copyright (c) 2005-2020 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -11,13 +11,9 @@
 # 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.
-#
-#
-#
-#
 
-CPLUS = g++
-CONLY = gcc
+CPLUS ?= g++
+CONLY ?= gcc
 COMPILE_ONLY = -c -MMD
 PREPROC_ONLY = -E -x c++
 INCLUDE_KEY = -I
@@ -38,21 +34,41 @@ LINK_FLAGS =
 LIB_LINK_FLAGS = -dynamiclib -install_name @rpath/$(BUILDING_LIBRARY)
 C_FLAGS = $(CPLUS_FLAGS)
 
+# gcc 4.8 and later support RTM intrinsics, but require command line switch to enable them
+ifneq (,$(shell $(CONLY) -dumpfullversion -dumpversion | egrep  "^(4\.[8-9]|[5-9]|1[0-9])"))
+    RTM_KEY = -mrtm
+endif
+
+# gcc 5.0 and later have -Wsuggest-override option
+# enable it via a pre-included header in order to limit to C++11 and above
+ifneq (,$(shell $(CONLY) -dumpfullversion -dumpversion | egrep  "^([5-9]|1[0-9])"))
+    INCLUDE_TEST_HEADERS = -include $(tbb_root)/src/test/harness_preload.h
+endif
+
+# gcc 6.0 and later have -flifetime-dse option that controls
+# elimination of stores done outside the object lifetime
+ifneq (,$(shell $(CONLY) -dumpfullversion -dumpversion | egrep  "^([6-9]|1[0-9])"))
+    # keep pre-contruction stores for zero initialization
+    DSE_KEY = -flifetime-dse=1
+endif
+
 ifeq ($(cfg), release)
     CPLUS_FLAGS = -g -O2
 else
     CPLUS_FLAGS = -g -O0 -DTBB_USE_DEBUG
 endif
 
-CPLUS_FLAGS += -DUSE_PTHREAD
+CPLUS_FLAGS += -DUSE_PTHREAD $(ITT_NOTIFY)
 
 ifeq (intel64,$(arch))
+    ITT_NOTIFY = -DDO_ITT_NOTIFY
     CPLUS_FLAGS += -m64
     LINK_FLAGS += -m64
     LIB_LINK_FLAGS += -m64
 endif
 
 ifeq (ia32,$(arch))
+    ITT_NOTIFY = -DDO_ITT_NOTIFY
     CPLUS_FLAGS += -m32
     LINK_FLAGS += -m32
     LIB_LINK_FLAGS += -m32
diff --git a/src/tbb/build/macos.icc.inc b/src/tbb/build/macos.icc.inc
index 92a339b2..7c263d7b 100644
--- a/src/tbb/build/macos.icc.inc
+++ b/src/tbb/build/macos.icc.inc
@@ -1,4 +1,4 @@
-# Copyright (c) 2005-2017 Intel Corporation
+# Copyright (c) 2005-2020 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -11,13 +11,9 @@
 # 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.
-#
-#
-#
-#
 
-CPLUS = icpc
-CONLY = icc
+CPLUS ?= icpc
+CONLY ?= icc
 COMPILE_ONLY = -c -MMD
 PREPROC_ONLY = -E -x c++
 INCLUDE_KEY = -I
@@ -53,19 +49,24 @@ endif
 
 ifeq ($(cfg), release)
     SDL_FLAGS += -D_FORTIFY_SOURCE=2
-    CPLUS_FLAGS = -g -O2 -fno-omit-frame-pointer
+    CPLUS_FLAGS = -g -O2 -fno-omit-frame-pointer -qno-opt-report-embed
 else
     CPLUS_FLAGS = -g -O0 -DTBB_USE_DEBUG
 endif
 
-CPLUS_FLAGS += -DUSE_PTHREAD
+ITT_NOTIFY = -DDO_ITT_NOTIFY
+CPLUS_FLAGS += -DUSE_PTHREAD $(ITT_NOTIFY)
+
+ifeq (1,$(tbb_cpf))
+# For correct ucontext.h structures layout
+CPLUS_FLAGS += -D_XOPEN_SOURCE
+endif
 
 ifneq (,$(codecov))
     CPLUS_FLAGS += -prof-gen=srcpos
 endif
 
 # ICC 14.0 and higher support usage of libc++, clang standard library
-MACOSX_DEPLOYMENT_TARGET ?= 10.11
 ifneq (,$(shell icc -dumpversion | egrep  "^1[4-9]\."))
 ifneq (,$(stdlib))
     CPLUS_FLAGS    += -stdlib=$(stdlib) -mmacosx-version-min=$(MACOSX_DEPLOYMENT_TARGET)
diff --git a/src/tbb/build/macos.inc b/src/tbb/build/macos.inc
index 8df5bbda..dde93216 100644
--- a/src/tbb/build/macos.inc
+++ b/src/tbb/build/macos.inc
@@ -1,4 +1,4 @@
-# Copyright (c) 2005-2017 Intel Corporation
+# Copyright (c) 2005-2020 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -11,10 +11,6 @@
 # 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.
-#
-#
-#
-#
 
 ####### Detections and Commands ###############################################
 
@@ -49,7 +45,7 @@ ifndef arch
 endif
 
 ifndef runtime
-  clang_version:=$(shell clang -v 2>&1 >/dev/null | grep version | sed -e "s/.*version \(.*[0-9]\) .*/\1/")
+  clang_version:=$(shell clang --version | sed -n "1s/.*version \(.*[0-9]\) .*/\1/p")
   ifndef os_version
     os_version:=$(shell /usr/bin/sw_vers -productVersion)
   endif
@@ -105,3 +101,5 @@ LINK_MALLOCPROXY.LIB = $(MALLOCPROXY.LIB)
 TEST_LAUNCHER=sh $(tbb_root)/build/test_launcher.sh $(largs)
 
 OPENCL.LIB = -framework OpenCL
+
+MACOSX_DEPLOYMENT_TARGET ?= 10.11
diff --git a/src/tbb/build/mic.icc.inc b/src/tbb/build/mic.icc.inc
index 5574a8dc..e91d58c7 100644
--- a/src/tbb/build/mic.icc.inc
+++ b/src/tbb/build/mic.icc.inc
@@ -1,4 +1,4 @@
-# Copyright (c) 2005-2017 Intel Corporation
+# Copyright (c) 2005-2020 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -11,11 +11,9 @@
 # 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.
-#
-#
-#
-#
 
+CPLUS ?= icpc
+CONLY ?= icc
 COMPILE_ONLY = -c -MMD
 PREPROC_ONLY = -E -x c++
 INCLUDE_KEY = -I
@@ -30,8 +28,6 @@ EXPORT_KEY = -Wl,--version-script,
 NOINTRINSIC_KEY = -fno-builtin
 LIBDL = -ldl
 SDL_FLAGS = -fstack-protector -Wformat -Wformat-security
-CPLUS = icpc
-CONLY = icc
 
 ifeq (release,$(cfg))
     SDL_FLAGS += -D_FORTIFY_SOURCE=2
diff --git a/src/tbb/build/mic.linux.inc b/src/tbb/build/mic.linux.inc
index b739d617..32d5be5b 100644
--- a/src/tbb/build/mic.linux.inc
+++ b/src/tbb/build/mic.linux.inc
@@ -1,4 +1,4 @@
-# Copyright (c) 2005-2017 Intel Corporation
+# Copyright (c) 2005-2020 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -11,10 +11,6 @@
 # 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.
-#
-#
-#
-#
 
 ifeq ($(tbb_os),mic)
   $(error MIC supports only cross-compilation.  Specify "target=mic" instead.)
diff --git a/src/tbb/build/mic.linux.launcher.sh b/src/tbb/build/mic.linux.launcher.sh
index ac69a43f..bb09afc1 100644
--- a/src/tbb/build/mic.linux.launcher.sh
+++ b/src/tbb/build/mic.linux.launcher.sh
@@ -1,6 +1,6 @@
 #!/bin/bash
 #
-# Copyright (c) 2005-2017 Intel Corporation
+# Copyright (c) 2005-2020 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -13,10 +13,6 @@
 # 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.
-#
-#
-#
-#
 
 # Usage:
 # mic.linux.launcher.sh [-v] [-q] [-s] [-r <repeats>] [-u] [-l <library>] <executable> <arg1> <arg2> <argN>
diff --git a/src/tbb/build/mic.offload.inc b/src/tbb/build/mic.offload.inc
index 96f0800f..2428166e 100644
--- a/src/tbb/build/mic.offload.inc
+++ b/src/tbb/build/mic.offload.inc
@@ -1,4 +1,4 @@
-# Copyright (c) 2005-2017 Intel Corporation
+# Copyright (c) 2005-2020 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -11,10 +11,6 @@
 # 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.
-#
-#
-#
-#
 
 ifneq (mic,$(offload))
   $(error File mic.offload.inc should not be included directly. Use offload=mic instead.)
diff --git a/src/tbb/build/test_launcher.bat b/src/tbb/build/test_launcher.bat
index 88c43dc4..83627b12 100644
--- a/src/tbb/build/test_launcher.bat
+++ b/src/tbb/build/test_launcher.bat
@@ -1,6 +1,6 @@
 @echo off
 REM
-REM Copyright (c) 2005-2017 Intel Corporation
+REM Copyright (c) 2005-2020 Intel Corporation
 REM
 REM Licensed under the Apache License, Version 2.0 (the "License");
 REM you may not use this file except in compliance with the License.
@@ -14,10 +14,6 @@ REM WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 REM See the License for the specific language governing permissions and
 REM limitations under the License.
 REM
-REM
-REM
-REM
-REM
 
 set cmd_line=
 if DEFINED run_prefix set cmd_line=%run_prefix%
diff --git a/src/tbb/build/test_launcher.sh b/src/tbb/build/test_launcher.sh
index 831136f0..224ed507 100644
--- a/src/tbb/build/test_launcher.sh
+++ b/src/tbb/build/test_launcher.sh
@@ -1,6 +1,6 @@
 #!/bin/sh
 #
-# Copyright (c) 2005-2017 Intel Corporation
+# Copyright (c) 2005-2020 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -13,10 +13,6 @@
 # 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.
-#
-#
-#
-#
 
 # Usage:
 # test_launcher.sh [-v] [-q] [-s] [-r <repeats>] [-u] [-l <library>] <executable> <arg1> <arg2> <argN>
diff --git a/src/tbb/build/version_info_aix.sh b/src/tbb/build/version_info_aix.sh
index 622a22ed..793cad11 100644
--- a/src/tbb/build/version_info_aix.sh
+++ b/src/tbb/build/version_info_aix.sh
@@ -1,6 +1,6 @@
 #!/bin/sh
 #
-# Copyright (c) 2005-2017 Intel Corporation
+# Copyright (c) 2005-2020 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -13,10 +13,6 @@
 # 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.
-#
-#
-#
-#
 
 # Script used to generate version info string
 echo "#define __TBB_VERSION_STRINGS(N) \\"
diff --git a/src/tbb/build/version_info_android.sh b/src/tbb/build/version_info_android.sh
index 2439207f..8d828b84 100644
--- a/src/tbb/build/version_info_android.sh
+++ b/src/tbb/build/version_info_android.sh
@@ -1,6 +1,6 @@
 #!/bin/sh
 #
-# Copyright (c) 2005-2017 Intel Corporation
+# Copyright (c) 2005-2020 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -13,10 +13,6 @@
 # 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.
-#
-#
-#
-#
 
 # Script used to generate version info string
 echo "#define __TBB_VERSION_STRINGS(N) \\"
diff --git a/src/tbb/build/version_info_linux.sh b/src/tbb/build/version_info_linux.sh
index 622a22ed..793cad11 100644
--- a/src/tbb/build/version_info_linux.sh
+++ b/src/tbb/build/version_info_linux.sh
@@ -1,6 +1,6 @@
 #!/bin/sh
 #
-# Copyright (c) 2005-2017 Intel Corporation
+# Copyright (c) 2005-2020 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -13,10 +13,6 @@
 # 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.
-#
-#
-#
-#
 
 # Script used to generate version info string
 echo "#define __TBB_VERSION_STRINGS(N) \\"
diff --git a/src/tbb/build/version_info_macos.sh b/src/tbb/build/version_info_macos.sh
index 397b1081..b43c0e6b 100644
--- a/src/tbb/build/version_info_macos.sh
+++ b/src/tbb/build/version_info_macos.sh
@@ -1,6 +1,6 @@
 #!/bin/sh
 #
-# Copyright (c) 2005-2017 Intel Corporation
+# Copyright (c) 2005-2020 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -13,17 +13,13 @@
 # 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.
-#
-#
-#
-#
 
 # Script used to generate version info string
 echo "#define __TBB_VERSION_STRINGS(N) \\"
 echo '#N": BUILD_HOST'"\t\t"`hostname -s`" ("`arch`")"'" ENDL \'
 echo '#N": BUILD_OS'"\t\t"`sw_vers -productName`" version "`sw_vers -productVersion`'" ENDL \'
 echo '#N": BUILD_KERNEL'"\t"`uname -v`'" ENDL \'
-echo '#N": BUILD_CLANG'"\t"`clang --version </dev/null 2>&1 | grep 'version '`'" ENDL \'
+echo '#N": BUILD_CLANG'"\t"`clang --version | sed -n "1p"`'" ENDL \'
 echo '#N": BUILD_XCODE'"\t"`xcodebuild -version </dev/null 2>&1 | grep 'Xcode'`'" ENDL \'
 [ -z "$COMPILER_VERSION" ] || echo '#N": BUILD_COMPILER'"\t"$COMPILER_VERSION'" ENDL \'
 echo '#N": BUILD_TARGET'"\t$arch on $runtime"'" ENDL \'
diff --git a/src/tbb/build/version_info_sunos.sh b/src/tbb/build/version_info_sunos.sh
index 96cd9ba7..335fb419 100644
--- a/src/tbb/build/version_info_sunos.sh
+++ b/src/tbb/build/version_info_sunos.sh
@@ -1,6 +1,6 @@
 #!/bin/sh
 #
-# Copyright (c) 2005-2017 Intel Corporation
+# Copyright (c) 2005-2020 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -13,10 +13,6 @@
 # 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.
-#
-#
-#
-#
 
 # Script used to generate version info string
 echo "#define __TBB_VERSION_STRINGS(N) \\"
diff --git a/src/tbb/build/version_info_windows.js b/src/tbb/build/version_info_windows.js
index 57483b3c..d3f4c0fb 100644
--- a/src/tbb/build/version_info_windows.js
+++ b/src/tbb/build/version_info_windows.js
@@ -1,4 +1,4 @@
-// Copyright (c) 2005-2017 Intel Corporation
+// Copyright (c) 2005-2020 Intel Corporation
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -11,10 +11,6 @@
 // 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.
-//
-//
-//
-//
 
 var WshShell = WScript.CreateObject("WScript.Shell");
 
@@ -93,4 +89,3 @@ WScript.echo( "#define __TBB_DATETIME \"" + date.toUTCString() + "\"" );
 WScript.echo( "#define __TBB_VERSION_YMD " + date.getUTCFullYear() + ", " + 
               (date.getUTCMonth() > 8 ? (date.getUTCMonth()+1):("0"+(date.getUTCMonth()+1))) + 
               (date.getUTCDate() > 9 ? date.getUTCDate():("0"+date.getUTCDate())) );
-WScript.echo( "" )
diff --git a/src/tbb/build/vs2013/index.html b/src/tbb/build/vs2013/index.html
index 4e597b66..5c584adb 100644
--- a/src/tbb/build/vs2013/index.html
+++ b/src/tbb/build/vs2013/index.html
@@ -20,7 +20,7 @@ <H2>Files</H2>
 <HR>
 <A HREF="../index.html">Up to parent directory</A>
 <P></P>
-Copyright &copy; 2017 Intel Corporation.  All Rights Reserved.
+Copyright &copy; 2017-2020 Intel Corporation.  All Rights Reserved.
 <P></P>
 Intel and the Intel logo are trademarks of Intel Corporation
 or its subsidiaries in the U.S. and/or other countries.
diff --git a/src/tbb/build/vs2013/tbb.vcxproj b/src/tbb/build/vs2013/tbb.vcxproj
index 7329d81b..e1aa9b54 100644
--- a/src/tbb/build/vs2013/tbb.vcxproj
+++ b/src/tbb/build/vs2013/tbb.vcxproj
@@ -170,7 +170,7 @@
   </PropertyGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <ClCompile>
-      <AdditionalOptions>  /c /MDd /Od /Ob0 /Zi /EHsc /GR /Zc:forScope /Zc:wchar_t /DTBB_USE_DEBUG /D__TBB_LIB_NAME=tbb_debug.lib /DDO_ITT_NOTIFY /GS /DUSE_WINTHREAD /D_CRT_SECURE_NO_DEPRECATE /D_WIN32_WINNT=0x0502 /D__TBB_BUILD=1 /W4 /I../../src /I../../src/rml/include /I../../include</AdditionalOptions>
+      <AdditionalOptions>  /c /MDd /Od /Ob0 /Zi /EHsc /GR /Zc:forScope /Zc:wchar_t /DTBB_SUPPRESS_DEPRECATED_MESSAGES=1 /DTBB_USE_DEBUG /D__TBB_LIB_NAME=tbb_debug.lib /DDO_ITT_NOTIFY /GS /DUSE_WINTHREAD /D_CRT_SECURE_NO_DEPRECATE /D_WIN32_WINNT=0x0502 /D__TBB_BUILD=1 /W4 /I../../src /I../../src/rml/include /I../../include</AdditionalOptions>
       <Optimization>Disabled</Optimization>
       <AdditionalIncludeDirectories>.;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>%(PreprocessorDefinitions)</PreprocessorDefinitions>
@@ -198,7 +198,7 @@
       <TargetEnvironment>X64</TargetEnvironment>
     </Midl>
     <ClCompile>
-      <AdditionalOptions>  /c /MDd /Od /Ob0 /Zi /EHsc /GR /Zc:forScope /Zc:wchar_t /DTBB_USE_DEBUG /D__TBB_LIB_NAME=tbb_debug.lib /DDO_ITT_NOTIFY /GS /DUSE_WINTHREAD /D_CRT_SECURE_NO_DEPRECATE /D_WIN32_WINNT=0x0502 /D__TBB_BUILD=1 /W4 /I../../src /I../../src/rml/include /I../../include</AdditionalOptions>
+      <AdditionalOptions>  /c /MDd /Od /Ob0 /Zi /EHsc /GR /Zc:forScope /Zc:wchar_t /DTBB_SUPPRESS_DEPRECATED_MESSAGES=1 /DTBB_USE_DEBUG /D__TBB_LIB_NAME=tbb_debug.lib /DDO_ITT_NOTIFY /GS /DUSE_WINTHREAD /D_CRT_SECURE_NO_DEPRECATE /D_WIN32_WINNT=0x0502 /D__TBB_BUILD=1 /W4 /I../../src /I../../src/rml/include /I../../include</AdditionalOptions>
       <Optimization>Disabled</Optimization>
       <AdditionalIncludeDirectories>.;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>%(PreprocessorDefinitions)</PreprocessorDefinitions>
@@ -223,7 +223,7 @@
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
     <ClCompile>
-      <AdditionalOptions>  /c /MD /O2 /Zi /EHsc /GR /Zc:forScope /Zc:wchar_t /D__TBB_LIB_NAME=tbb.lib /DDO_ITT_NOTIFY /GS /DUSE_WINTHREAD /D_CRT_SECURE_NO_DEPRECATE /D_WIN32_WINNT=0x0502 /D__TBB_BUILD=1 /W4 /I../../src /I../../src/rml/include /I../../include</AdditionalOptions>
+      <AdditionalOptions>  /c /MD /O2 /Zi /EHsc /GR /Zc:forScope /Zc:wchar_t /DTBB_SUPPRESS_DEPRECATED_MESSAGES=1 /D__TBB_LIB_NAME=tbb.lib /DDO_ITT_NOTIFY /GS /DUSE_WINTHREAD /D_CRT_SECURE_NO_DEPRECATE /D_WIN32_WINNT=0x0502 /D__TBB_BUILD=1 /W4 /I../../src /I../../src/rml/include /I../../include</AdditionalOptions>
       <AdditionalIncludeDirectories>.;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
@@ -250,7 +250,7 @@
       <TargetEnvironment>X64</TargetEnvironment>
     </Midl>
     <ClCompile>
-      <AdditionalOptions>  /c /MD /O2 /Zi /EHsc /GR /Zc:forScope /Zc:wchar_t /D__TBB_LIB_NAME=tbb.lib /DDO_ITT_NOTIFY /GS /DUSE_WINTHREAD /D_CRT_SECURE_NO_DEPRECATE /D_WIN32_WINNT=0x0502 /D__TBB_BUILD=1 /W4 /I../../src /I../../src/rml/include /I../../include</AdditionalOptions>
+      <AdditionalOptions>  /c /MD /O2 /Zi /EHsc /GR /Zc:forScope /Zc:wchar_t /DTBB_SUPPRESS_DEPRECATED_MESSAGES=1 /D__TBB_LIB_NAME=tbb.lib /DDO_ITT_NOTIFY /GS /DUSE_WINTHREAD /D_CRT_SECURE_NO_DEPRECATE /D_WIN32_WINNT=0x0502 /D__TBB_BUILD=1 /W4 /I../../src /I../../src/rml/include /I../../include</AdditionalOptions>
       <AdditionalIncludeDirectories>.;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
@@ -273,7 +273,7 @@
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug-MT|Win32'">
     <ClCompile>
-      <AdditionalOptions>  /c /MTd /Od /Ob0 /Zi /EHsc /GR /Zc:forScope /Zc:wchar_t /DTBB_USE_DEBUG /D__TBB_LIB_NAME=tbb_debug.lib /DDO_ITT_NOTIFY /GS /DUSE_WINTHREAD /D_CRT_SECURE_NO_DEPRECATE /D_WIN32_WINNT=0x0502 /D__TBB_BUILD=1 /W4 /I../../src /I../../src/rml/include /I../../include</AdditionalOptions>
+      <AdditionalOptions>  /c /MTd /Od /Ob0 /Zi /EHsc /GR /Zc:forScope /Zc:wchar_t /DTBB_SUPPRESS_DEPRECATED_MESSAGES=1 /DTBB_USE_DEBUG /D__TBB_LIB_NAME=tbb_debug.lib /DDO_ITT_NOTIFY /GS /DUSE_WINTHREAD /D_CRT_SECURE_NO_DEPRECATE /D_WIN32_WINNT=0x0502 /D__TBB_BUILD=1 /W4 /I../../src /I../../src/rml/include /I../../include</AdditionalOptions>
       <Optimization>Disabled</Optimization>
       <AdditionalIncludeDirectories>.;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>%(PreprocessorDefinitions)</PreprocessorDefinitions>
@@ -301,7 +301,7 @@
       <TargetEnvironment>X64</TargetEnvironment>
     </Midl>
     <ClCompile>
-      <AdditionalOptions>  /c /MTd /Od /Ob0 /Zi /EHsc /GR /Zc:forScope /Zc:wchar_t /DTBB_USE_DEBUG /D__TBB_LIB_NAME=tbb_debug.lib /DDO_ITT_NOTIFY /GS /DUSE_WINTHREAD /D_CRT_SECURE_NO_DEPRECATE /D_WIN32_WINNT=0x0502 /D__TBB_BUILD=1 /W4 /I../../src /I../../src/rml/include /I../../include</AdditionalOptions>
+      <AdditionalOptions>  /c /MTd /Od /Ob0 /Zi /EHsc /GR /Zc:forScope /Zc:wchar_t /DTBB_SUPPRESS_DEPRECATED_MESSAGES=1 /DTBB_USE_DEBUG /D__TBB_LIB_NAME=tbb_debug.lib /DDO_ITT_NOTIFY /GS /DUSE_WINTHREAD /D_CRT_SECURE_NO_DEPRECATE /D_WIN32_WINNT=0x0502 /D__TBB_BUILD=1 /W4 /I../../src /I../../src/rml/include /I../../include</AdditionalOptions>
       <Optimization>Disabled</Optimization>
       <AdditionalIncludeDirectories>.;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>%(PreprocessorDefinitions)</PreprocessorDefinitions>
@@ -326,7 +326,7 @@
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release-MT|Win32'">
     <ClCompile>
-      <AdditionalOptions>  /c /MT /O2 /Zi /EHsc /GR /Zc:forScope /Zc:wchar_t /D__TBB_LIB_NAME=tbb.lib /DDO_ITT_NOTIFY /GS /DUSE_WINTHREAD /D_CRT_SECURE_NO_DEPRECATE /D_WIN32_WINNT=0x0502 /D__TBB_BUILD=1 /W4 /I../../src /I../../src/rml/include /I../../include</AdditionalOptions>
+      <AdditionalOptions>  /c /MT /O2 /Zi /EHsc /GR /Zc:forScope /Zc:wchar_t /DTBB_SUPPRESS_DEPRECATED_MESSAGES=1 /D__TBB_LIB_NAME=tbb.lib /DDO_ITT_NOTIFY /GS /DUSE_WINTHREAD /D_CRT_SECURE_NO_DEPRECATE /D_WIN32_WINNT=0x0502 /D__TBB_BUILD=1 /W4 /I../../src /I../../src/rml/include /I../../include</AdditionalOptions>
       <AdditionalIncludeDirectories>.;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
@@ -353,7 +353,7 @@
       <TargetEnvironment>X64</TargetEnvironment>
     </Midl>
     <ClCompile>
-      <AdditionalOptions>  /c /MT /O2 /Zi /EHsc /GR /Zc:forScope /Zc:wchar_t /D__TBB_LIB_NAME=tbb.lib /DDO_ITT_NOTIFY /GS /DUSE_WINTHREAD /D_CRT_SECURE_NO_DEPRECATE /D_WIN32_WINNT=0x0502 /D__TBB_BUILD=1 /W4 /I../../src /I../../src/rml/include /I../../include</AdditionalOptions>
+      <AdditionalOptions>  /c /MT /O2 /Zi /EHsc /GR /Zc:forScope /Zc:wchar_t /DTBB_SUPPRESS_DEPRECATED_MESSAGES=1 /D__TBB_LIB_NAME=tbb.lib /DDO_ITT_NOTIFY /GS /DUSE_WINTHREAD /D_CRT_SECURE_NO_DEPRECATE /D_WIN32_WINNT=0x0502 /D__TBB_BUILD=1 /W4 /I../../src /I../../src/rml/include /I../../include</AdditionalOptions>
       <AdditionalIncludeDirectories>.;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
@@ -599,6 +599,7 @@
     <ClInclude Include="..\..\include\tbb\blocked_range.h" />
     <ClInclude Include="..\..\include\tbb\blocked_range2d.h" />
     <ClInclude Include="..\..\include\tbb\blocked_range3d.h" />
+    <ClInclude Include="..\..\include\tbb\blocked_rangeNd.h" />
     <ClInclude Include="..\..\include\tbb\cache_aligned_allocator.h" />
     <ClInclude Include="..\..\include\tbb\combinable.h" />
     <ClInclude Include="..\..\include\tbb\concurrent_hash_map.h" />
diff --git a/src/tbb/build/vs2013/tbbmalloc.vcxproj b/src/tbb/build/vs2013/tbbmalloc.vcxproj
index 90d5fe13..b8f21dd5 100644
--- a/src/tbb/build/vs2013/tbbmalloc.vcxproj
+++ b/src/tbb/build/vs2013/tbbmalloc.vcxproj
@@ -170,7 +170,7 @@
   </PropertyGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <ClCompile>
-      <AdditionalOptions> /c /MDd /Od /Ob0 /Zi /EHsc /GR /Zc:forScope /Zc:wchar_t /DTBB_USE_DEBUG /D__TBB_LIB_NAME=tbb_debug.lib /DDO_ITT_NOTIFY /GS /DUSE_WINTHREAD /D_CRT_SECURE_NO_DEPRECATE /D_WIN32_WINNT=0x0502 /D__TBBMALLOC_BUILD=1 /I../../src /I../../src/rml/include /I../../include /I../../src/tbbmalloc /I../../src/tbbmalloc /I.</AdditionalOptions>
+      <AdditionalOptions> /c /MDd /Od /Ob0 /Zi /EHsc /GR /Zc:forScope /Zc:wchar_t /DTBB_SUPPRESS_DEPRECATED_MESSAGES=1 /DTBB_USE_DEBUG /D__TBB_LIB_NAME=tbb_debug.lib /DDO_ITT_NOTIFY /GS /DUSE_WINTHREAD /D_CRT_SECURE_NO_DEPRECATE /D_WIN32_WINNT=0x0502 /D__TBBMALLOC_BUILD=1 /I../../src /I../../src/rml/include /I../../include /I../../src/tbbmalloc /I../../src/tbbmalloc /I.</AdditionalOptions>
       <Optimization>Disabled</Optimization>
       <AdditionalIncludeDirectories>.;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>%(PreprocessorDefinitions)</PreprocessorDefinitions>
@@ -197,7 +197,7 @@
       <TargetEnvironment>X64</TargetEnvironment>
     </Midl>
     <ClCompile>
-      <AdditionalOptions> /c /MDd /Od /Ob0 /Zi /EHsc /GR /Zc:forScope /Zc:wchar_t /DTBB_USE_DEBUG /D__TBB_LIB_NAME=tbb_debug.lib /DDO_ITT_NOTIFY /GS /DUSE_WINTHREAD /D_CRT_SECURE_NO_DEPRECATE /D_WIN32_WINNT=0x0502 /D__TBBMALLOC_BUILD=1 /I../../src /I../../src/rml/include /I../../include /I../../src/tbbmalloc /I../../src/tbbmalloc /I.</AdditionalOptions>
+      <AdditionalOptions> /c /MDd /Od /Ob0 /Zi /EHsc /GR /Zc:forScope /Zc:wchar_t /DTBB_SUPPRESS_DEPRECATED_MESSAGES=1 /DTBB_USE_DEBUG /D__TBB_LIB_NAME=tbb_debug.lib /DDO_ITT_NOTIFY /GS /DUSE_WINTHREAD /D_CRT_SECURE_NO_DEPRECATE /D_WIN32_WINNT=0x0502 /D__TBBMALLOC_BUILD=1 /I../../src /I../../src/rml/include /I../../include /I../../src/tbbmalloc /I../../src/tbbmalloc /I.</AdditionalOptions>
       <Optimization>Disabled</Optimization>
       <AdditionalIncludeDirectories>.;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <MinimalRebuild>false</MinimalRebuild>
@@ -222,7 +222,7 @@
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
     <ClCompile>
-      <AdditionalOptions> /c /MD /O2 /Zi /EHsc /GR /Zc:forScope /Zc:wchar_t /D__TBB_LIB_NAME=tbb.lib /DDO_ITT_NOTIFY /GS /DUSE_WINTHREAD /D_CRT_SECURE_NO_DEPRECATE /D_WIN32_WINNT=0x0502 /D__TBBMALLOC_BUILD=1 /I../../src /I../../src/rml/include /I../../include /I../../src/tbbmalloc /I../../src/tbbmalloc /I.</AdditionalOptions>
+      <AdditionalOptions> /c /MD /O2 /Zi /EHsc /GR /Zc:forScope /Zc:wchar_t /DTBB_SUPPRESS_DEPRECATED_MESSAGES=1 /D__TBB_LIB_NAME=tbb.lib /DDO_ITT_NOTIFY /GS /DUSE_WINTHREAD /D_CRT_SECURE_NO_DEPRECATE /D_WIN32_WINNT=0x0502 /D__TBBMALLOC_BUILD=1 /I../../src /I../../src/rml/include /I../../include /I../../src/tbbmalloc /I../../src/tbbmalloc /I.</AdditionalOptions>
       <AdditionalIncludeDirectories>.;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
@@ -248,7 +248,7 @@
       <TargetEnvironment>X64</TargetEnvironment>
     </Midl>
     <ClCompile>
-      <AdditionalOptions> /c /MD /O2 /Zi /EHsc /GR /Zc:forScope /Zc:wchar_t /D__TBB_LIB_NAME=tbb.lib /DDO_ITT_NOTIFY /GS /DUSE_WINTHREAD /D_CRT_SECURE_NO_DEPRECATE /D_WIN32_WINNT=0x0502 /D__TBBMALLOC_BUILD=1 /I../../src /I../../src/rml/include /I../../include /I../../src/tbbmalloc /I../../src/tbbmalloc /I.</AdditionalOptions>
+      <AdditionalOptions> /c /MD /O2 /Zi /EHsc /GR /Zc:forScope /Zc:wchar_t /DTBB_SUPPRESS_DEPRECATED_MESSAGES=1 /D__TBB_LIB_NAME=tbb.lib /DDO_ITT_NOTIFY /GS /DUSE_WINTHREAD /D_CRT_SECURE_NO_DEPRECATE /D_WIN32_WINNT=0x0502 /D__TBBMALLOC_BUILD=1 /I../../src /I../../src/rml/include /I../../include /I../../src/tbbmalloc /I../../src/tbbmalloc /I.</AdditionalOptions>
       <AdditionalIncludeDirectories>.;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
@@ -271,7 +271,7 @@
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug-MT|Win32'">
     <ClCompile>
-      <AdditionalOptions> /c /MTd /Od /Ob0 /Zi /EHsc /GR /Zc:forScope /Zc:wchar_t /DTBB_USE_DEBUG /D__TBB_LIB_NAME=tbb_debug.lib /DDO_ITT_NOTIFY /GS /DUSE_WINTHREAD /D_CRT_SECURE_NO_DEPRECATE /D_WIN32_WINNT=0x0502 /D__TBBMALLOC_BUILD=1 /I../../src /I../../src/rml/include /I../../include /I../../src/tbbmalloc /I../../src/tbbmalloc /I.</AdditionalOptions>
+      <AdditionalOptions> /c /MTd /Od /Ob0 /Zi /EHsc /GR /Zc:forScope /Zc:wchar_t /DTBB_SUPPRESS_DEPRECATED_MESSAGES=1 /DTBB_USE_DEBUG /D__TBB_LIB_NAME=tbb_debug.lib /DDO_ITT_NOTIFY /GS /DUSE_WINTHREAD /D_CRT_SECURE_NO_DEPRECATE /D_WIN32_WINNT=0x0502 /D__TBBMALLOC_BUILD=1 /I../../src /I../../src/rml/include /I../../include /I../../src/tbbmalloc /I../../src/tbbmalloc /I.</AdditionalOptions>
       <Optimization>Disabled</Optimization>
       <AdditionalIncludeDirectories>.;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>%(PreprocessorDefinitions)</PreprocessorDefinitions>
@@ -298,7 +298,7 @@
       <TargetEnvironment>X64</TargetEnvironment>
     </Midl>
     <ClCompile>
-      <AdditionalOptions> /c /MTd /Od /Ob0 /Zi /EHsc /GR /Zc:forScope /Zc:wchar_t /DTBB_USE_DEBUG /D__TBB_LIB_NAME=tbb_debug.lib /DDO_ITT_NOTIFY /GS /DUSE_WINTHREAD /D_CRT_SECURE_NO_DEPRECATE /D_WIN32_WINNT=0x0502 /D__TBBMALLOC_BUILD=1 /I../../src /I../../src/rml/include /I../../include /I../../src/tbbmalloc /I../../src/tbbmalloc /I.</AdditionalOptions>
+      <AdditionalOptions> /c /MTd /Od /Ob0 /Zi /EHsc /GR /Zc:forScope /Zc:wchar_t /DTBB_SUPPRESS_DEPRECATED_MESSAGES=1 /DTBB_USE_DEBUG /D__TBB_LIB_NAME=tbb_debug.lib /DDO_ITT_NOTIFY /GS /DUSE_WINTHREAD /D_CRT_SECURE_NO_DEPRECATE /D_WIN32_WINNT=0x0502 /D__TBBMALLOC_BUILD=1 /I../../src /I../../src/rml/include /I../../include /I../../src/tbbmalloc /I../../src/tbbmalloc /I.</AdditionalOptions>
       <Optimization>Disabled</Optimization>
       <AdditionalIncludeDirectories>.;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <MinimalRebuild>false</MinimalRebuild>
@@ -323,7 +323,7 @@
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release-MT|Win32'">
     <ClCompile>
-      <AdditionalOptions> /c /MT /O2 /Zi /EHsc /GR /Zc:forScope /Zc:wchar_t /D__TBB_LIB_NAME=tbb.lib /DDO_ITT_NOTIFY /GS /DUSE_WINTHREAD /D_CRT_SECURE_NO_DEPRECATE /D_WIN32_WINNT=0x0502 /D__TBBMALLOC_BUILD=1 /I../../src /I../../src/rml/include /I../../include /I../../src/tbbmalloc /I../../src/tbbmalloc /I.</AdditionalOptions>
+      <AdditionalOptions> /c /MT /O2 /Zi /EHsc /GR /Zc:forScope /Zc:wchar_t /DTBB_SUPPRESS_DEPRECATED_MESSAGES=1 /D__TBB_LIB_NAME=tbb.lib /DDO_ITT_NOTIFY /GS /DUSE_WINTHREAD /D_CRT_SECURE_NO_DEPRECATE /D_WIN32_WINNT=0x0502 /D__TBBMALLOC_BUILD=1 /I../../src /I../../src/rml/include /I../../include /I../../src/tbbmalloc /I../../src/tbbmalloc /I.</AdditionalOptions>
       <AdditionalIncludeDirectories>.;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
@@ -347,7 +347,7 @@
       <TargetEnvironment>X64</TargetEnvironment>
     </Midl>
     <ClCompile>
-      <AdditionalOptions> /c /MT /O2 /Zi /EHsc /GR /Zc:forScope /Zc:wchar_t /D__TBB_LIB_NAME=tbb.lib /DDO_ITT_NOTIFY /GS /DUSE_WINTHREAD /D_CRT_SECURE_NO_DEPRECATE /D_WIN32_WINNT=0x0502 /D__TBBMALLOC_BUILD=1 /I../../src /I../../src/rml/include /I../../include /I../../src/tbbmalloc /I../../src/tbbmalloc /I.</AdditionalOptions>
+      <AdditionalOptions> /c /MT /O2 /Zi /EHsc /GR /Zc:forScope /Zc:wchar_t /DTBB_SUPPRESS_DEPRECATED_MESSAGES=1 /D__TBB_LIB_NAME=tbb.lib /DDO_ITT_NOTIFY /GS /DUSE_WINTHREAD /D_CRT_SECURE_NO_DEPRECATE /D_WIN32_WINNT=0x0502 /D__TBBMALLOC_BUILD=1 /I../../src /I../../src/rml/include /I../../include /I../../src/tbbmalloc /I../../src/tbbmalloc /I.</AdditionalOptions>
       <AdditionalIncludeDirectories>.;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
@@ -482,6 +482,7 @@
     <ClInclude Include="..\..\include\tbb\blocked_range.h" />
     <ClInclude Include="..\..\include\tbb\blocked_range2d.h" />
     <ClInclude Include="..\..\include\tbb\blocked_range3d.h" />
+    <ClInclude Include="..\..\include\tbb\blocked_rangeNd.h" />
     <ClInclude Include="..\..\include\tbb\cache_aligned_allocator.h" />
     <ClInclude Include="..\..\include\tbb\combinable.h" />
     <ClInclude Include="..\..\include\tbb\concurrent_hash_map.h" />
diff --git a/src/tbb/build/vs2013/tbbmalloc_proxy.vcxproj b/src/tbb/build/vs2013/tbbmalloc_proxy.vcxproj
index 758bb517..23dac2f6 100644
--- a/src/tbb/build/vs2013/tbbmalloc_proxy.vcxproj
+++ b/src/tbb/build/vs2013/tbbmalloc_proxy.vcxproj
@@ -170,7 +170,7 @@
   </PropertyGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <ClCompile>
-      <AdditionalOptions> /c /MDd /Od /Ob0 /Zi /EHsc /GR /Zc:forScope /Zc:wchar_t /DTBB_USE_DEBUG /D__TBB_LIB_NAME=tbb_debug.lib /DDO_ITT_NOTIFY /GS /DUSE_WINTHREAD /D_CRT_SECURE_NO_DEPRECATE /D_WIN32_WINNT=0x0502 /W4 /D__TBBMALLOC_BUILD=1 /I../../src /I../../src/rml/include /I../../include /I../../src/tbbmalloc /I../../src/tbbmalloc</AdditionalOptions>
+      <AdditionalOptions> /c /MDd /Od /Ob0 /Zi /EHsc /GR /Zc:forScope /Zc:wchar_t /DTBB_SUPPRESS_DEPRECATED_MESSAGES=1 /DTBB_USE_DEBUG /D__TBB_LIB_NAME=tbb_debug.lib /DDO_ITT_NOTIFY /GS /DUSE_WINTHREAD /D_CRT_SECURE_NO_DEPRECATE /D_WIN32_WINNT=0x0502 /W4 /D__TBBMALLOC_BUILD=1 /I../../src /I../../src/rml/include /I../../include /I../../src/tbbmalloc /I../../src/tbbmalloc</AdditionalOptions>
       <Optimization>Disabled</Optimization>
       <AdditionalIncludeDirectories>.;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>%(PreprocessorDefinitions)</PreprocessorDefinitions>
@@ -199,7 +199,7 @@
       <TargetEnvironment>X64</TargetEnvironment>
     </Midl>
     <ClCompile>
-      <AdditionalOptions> /c /MDd /Od /Ob0 /Zi /EHsc /GR /Zc:forScope /Zc:wchar_t /DTBB_USE_DEBUG /D__TBB_LIB_NAME=tbb_debug.lib /DDO_ITT_NOTIFY /GS /DUSE_WINTHREAD /D_CRT_SECURE_NO_DEPRECATE /D_WIN32_WINNT=0x0502 /W4 /D__TBBMALLOC_BUILD=1 /I../../src /I../../src/rml/include /I../../include /I../../src/tbbmalloc /I../../src/tbbmalloc</AdditionalOptions>
+      <AdditionalOptions> /c /MDd /Od /Ob0 /Zi /EHsc /GR /Zc:forScope /Zc:wchar_t /DTBB_SUPPRESS_DEPRECATED_MESSAGES=1 /DTBB_USE_DEBUG /D__TBB_LIB_NAME=tbb_debug.lib /DDO_ITT_NOTIFY /GS /DUSE_WINTHREAD /D_CRT_SECURE_NO_DEPRECATE /D_WIN32_WINNT=0x0502 /W4 /D__TBBMALLOC_BUILD=1 /I../../src /I../../src/rml/include /I../../include /I../../src/tbbmalloc /I../../src/tbbmalloc</AdditionalOptions>
       <Optimization>Disabled</Optimization>
       <AdditionalIncludeDirectories>.;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <MinimalRebuild>false</MinimalRebuild>
@@ -227,7 +227,7 @@
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
     <ClCompile>
-      <AdditionalOptions> /c /MD /O2 /Zi /EHsc /GR /Zc:forScope /Zc:wchar_t /D__TBB_LIB_NAME=tbb.lib /DDO_ITT_NOTIFY /GS /DUSE_WINTHREAD /D_CRT_SECURE_NO_DEPRECATE /D_WIN32_WINNT=0x0502 /W4 /D__TBBMALLOC_BUILD=1 /I../../src /I../../src/rml/include /I../../include /I../../src/tbbmalloc /I../../src/tbbmalloc</AdditionalOptions>
+      <AdditionalOptions> /c /MD /O2 /Zi /EHsc /GR /Zc:forScope /Zc:wchar_t /DTBB_SUPPRESS_DEPRECATED_MESSAGES=1 /D__TBB_LIB_NAME=tbb.lib /DDO_ITT_NOTIFY /GS /DUSE_WINTHREAD /D_CRT_SECURE_NO_DEPRECATE /D_WIN32_WINNT=0x0502 /W4 /D__TBBMALLOC_BUILD=1 /I../../src /I../../src/rml/include /I../../include /I../../src/tbbmalloc /I../../src/tbbmalloc</AdditionalOptions>
       <AdditionalIncludeDirectories>.;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <ExceptionHandling>
@@ -256,7 +256,7 @@
       <TargetEnvironment>X64</TargetEnvironment>
     </Midl>
     <ClCompile>
-      <AdditionalOptions> /c /MD /O2 /Zi /EHsc /GR /Zc:forScope /Zc:wchar_t /D__TBB_LIB_NAME=tbb.lib /DDO_ITT_NOTIFY /GS /DUSE_WINTHREAD /D_CRT_SECURE_NO_DEPRECATE /D_WIN32_WINNT=0x0502 /W4 /D__TBBMALLOC_BUILD=1 /I../../src /I../../src/rml/include /I../../include /I../../src/tbbmalloc /I../../src/tbbmalloc</AdditionalOptions>
+      <AdditionalOptions> /c /MD /O2 /Zi /EHsc /GR /Zc:forScope /Zc:wchar_t /DTBB_SUPPRESS_DEPRECATED_MESSAGES=1 /D__TBB_LIB_NAME=tbb.lib /DDO_ITT_NOTIFY /GS /DUSE_WINTHREAD /D_CRT_SECURE_NO_DEPRECATE /D_WIN32_WINNT=0x0502 /W4 /D__TBBMALLOC_BUILD=1 /I../../src /I../../src/rml/include /I../../include /I../../src/tbbmalloc /I../../src/tbbmalloc</AdditionalOptions>
       <AdditionalIncludeDirectories>.;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <ExceptionHandling>
@@ -282,7 +282,7 @@
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug-MT|Win32'">
     <ClCompile>
-      <AdditionalOptions> /c /MTd /Od /Ob0 /Zi /EHsc /GR /Zc:forScope /Zc:wchar_t /DTBB_USE_DEBUG /D__TBB_LIB_NAME=tbb_debug.lib /DDO_ITT_NOTIFY /GS /DUSE_WINTHREAD /D_CRT_SECURE_NO_DEPRECATE /D_WIN32_WINNT=0x0502 /W4 /D__TBBMALLOC_BUILD=1 /I../../src /I../../src/rml/include /I../../include /I../../src/tbbmalloc /I../../src/tbbmalloc</AdditionalOptions>
+      <AdditionalOptions> /c /MTd /Od /Ob0 /Zi /EHsc /GR /Zc:forScope /Zc:wchar_t /DTBB_SUPPRESS_DEPRECATED_MESSAGES=1 /DTBB_USE_DEBUG /D__TBB_LIB_NAME=tbb_debug.lib /DDO_ITT_NOTIFY /GS /DUSE_WINTHREAD /D_CRT_SECURE_NO_DEPRECATE /D_WIN32_WINNT=0x0502 /W4 /D__TBBMALLOC_BUILD=1 /I../../src /I../../src/rml/include /I../../include /I../../src/tbbmalloc /I../../src/tbbmalloc</AdditionalOptions>
       <Optimization>Disabled</Optimization>
       <AdditionalIncludeDirectories>.;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>%(PreprocessorDefinitions)</PreprocessorDefinitions>
@@ -311,7 +311,7 @@
       <TargetEnvironment>X64</TargetEnvironment>
     </Midl>
     <ClCompile>
-      <AdditionalOptions> /c /MTd /Od /Ob0 /Zi /EHsc /GR /Zc:forScope /Zc:wchar_t /DTBB_USE_DEBUG /D__TBB_LIB_NAME=tbb_debug.lib /DDO_ITT_NOTIFY /GS /DUSE_WINTHREAD /D_CRT_SECURE_NO_DEPRECATE /D_WIN32_WINNT=0x0502 /W4 /D__TBBMALLOC_BUILD=1 /I../../src /I../../src/rml/include /I../../include /I../../src/tbbmalloc /I../../src/tbbmalloc</AdditionalOptions>
+      <AdditionalOptions> /c /MTd /Od /Ob0 /Zi /EHsc /GR /Zc:forScope /Zc:wchar_t /DTBB_SUPPRESS_DEPRECATED_MESSAGES=1 /DTBB_USE_DEBUG /D__TBB_LIB_NAME=tbb_debug.lib /DDO_ITT_NOTIFY /GS /DUSE_WINTHREAD /D_CRT_SECURE_NO_DEPRECATE /D_WIN32_WINNT=0x0502 /W4 /D__TBBMALLOC_BUILD=1 /I../../src /I../../src/rml/include /I../../include /I../../src/tbbmalloc /I../../src/tbbmalloc</AdditionalOptions>
       <Optimization>Disabled</Optimization>
       <AdditionalIncludeDirectories>.;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <MinimalRebuild>false</MinimalRebuild>
@@ -339,7 +339,7 @@
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release-MT|Win32'">
     <ClCompile>
-      <AdditionalOptions> /c /MT /O2 /Zi /EHsc /GR /Zc:forScope /Zc:wchar_t /D__TBB_LIB_NAME=tbb.lib /DDO_ITT_NOTIFY /GS /DUSE_WINTHREAD /D_CRT_SECURE_NO_DEPRECATE /D_WIN32_WINNT=0x0502 /W4 /D__TBBMALLOC_BUILD=1 /I../../src /I../../src/rml/include /I../../include /I../../src/tbbmalloc /I../../src/tbbmalloc</AdditionalOptions>
+      <AdditionalOptions> /c /MT /O2 /Zi /EHsc /GR /Zc:forScope /Zc:wchar_t /DTBB_SUPPRESS_DEPRECATED_MESSAGES=1 /D__TBB_LIB_NAME=tbb.lib /DDO_ITT_NOTIFY /GS /DUSE_WINTHREAD /D_CRT_SECURE_NO_DEPRECATE /D_WIN32_WINNT=0x0502 /W4 /D__TBBMALLOC_BUILD=1 /I../../src /I../../src/rml/include /I../../include /I../../src/tbbmalloc /I../../src/tbbmalloc</AdditionalOptions>
       <AdditionalIncludeDirectories>.;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <ExceptionHandling>
@@ -368,7 +368,7 @@
       <TargetEnvironment>X64</TargetEnvironment>
     </Midl>
     <ClCompile>
-      <AdditionalOptions> /c /MT /O2 /Zi /EHsc /GR /Zc:forScope /Zc:wchar_t /D__TBB_LIB_NAME=tbb.lib /DDO_ITT_NOTIFY /GS /DUSE_WINTHREAD /D_CRT_SECURE_NO_DEPRECATE /D_WIN32_WINNT=0x0502 /W4 /D__TBBMALLOC_BUILD=1 /I../../src /I../../src/rml/include /I../../include /I../../src/tbbmalloc /I../../src/tbbmalloc</AdditionalOptions>
+      <AdditionalOptions> /c /MT /O2 /Zi /EHsc /GR /Zc:forScope /Zc:wchar_t /DTBB_SUPPRESS_DEPRECATED_MESSAGES=1 /D__TBB_LIB_NAME=tbb.lib /DDO_ITT_NOTIFY /GS /DUSE_WINTHREAD /D_CRT_SECURE_NO_DEPRECATE /D_WIN32_WINNT=0x0502 /W4 /D__TBBMALLOC_BUILD=1 /I../../src /I../../src/rml/include /I../../include /I../../src/tbbmalloc /I../../src/tbbmalloc</AdditionalOptions>
       <AdditionalIncludeDirectories>.;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <ExceptionHandling>
diff --git a/src/tbb/build/windows.cl.inc b/src/tbb/build/windows.cl.inc
index 3906d086..732b854f 100644
--- a/src/tbb/build/windows.cl.inc
+++ b/src/tbb/build/windows.cl.inc
@@ -1,4 +1,4 @@
-# Copyright (c) 2005-2017 Intel Corporation
+# Copyright (c) 2005-2020 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -11,10 +11,6 @@
 # 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.
-#
-#
-#
-#
 
 #------------------------------------------------------------------------------
 # Define compiler-specific variables.
@@ -24,7 +20,7 @@
 #------------------------------------------------------------------------------
 # Setting compiler flags.
 #------------------------------------------------------------------------------
-CPLUS = cl /nologo
+CPLUS ?= cl /nologo
 LINK_FLAGS = /link /nologo
 LIB_LINK_FLAGS=/link /nologo /DLL /MAP /DEBUG /fixed:no /INCREMENTAL:NO /DYNAMICBASE /NXCOMPAT
 
@@ -43,6 +39,11 @@ else
 endif
 EH_FLAGS = $(if $(no_exceptions),/EHs-,/EHsc /GR)
 
+# UWD binaries have to use static CRT linkage
+ifeq ($(target_app), uwd)
+    MS_CRT_KEY = /MT$(if $(findstring debug,$(cfg)),d)
+endif
+
 ifeq ($(cfg), release)
         CPLUS_FLAGS = $(MS_CRT_KEY) /O2 /Zi $(EH_FLAGS) /Zc:forScope /Zc:wchar_t /D__TBB_LIB_NAME=$(TBB.LIB)
         ASM_FLAGS =
@@ -54,17 +55,20 @@ endif
 
 ZW_KEY = /ZW:nostdlib
 
-ifneq (,$(filter win8ui,$(target_app) $(target_ui)))
-        CPLUS_FLAGS += $(ZW_KEY) /D "_UNICODE" /D "UNICODE" /D "WINAPI_FAMILY=WINAPI_FAMILY_APP"
+# These flags are general for Windows* universal applications
+ifneq (,$(target_app))
+    CPLUS_FLAGS += $(ZW_KEY) /D "_UNICODE" /D "UNICODE" /D "WINAPI_FAMILY=WINAPI_FAMILY_APP"
+endif
+
+ifeq ($(target_app), win8ui)
         _WIN32_WINNT = 0x0602
-else ifneq (,$(filter uwp,$(target_app) $(target_ui)))
-        CPLUS_FLAGS += $(ZW_KEY) /D "_UNICODE" /D "UNICODE" /D "WINAPI_FAMILY=WINAPI_FAMILY_APP"
+else ifneq (,$(filter $(target_app),uwp uwd))
         _WIN32_WINNT = 0x0A00
         LIB_LINK_FLAGS += /NODEFAULTLIB:kernel32.lib OneCore.lib
 else
         CPLUS_FLAGS += /DDO_ITT_NOTIFY
 endif
-ifneq (,$(filter store,$(target_mode) $(target_ui_mode)))
+ifeq ($(target_mode), store)
 #       it is necessary to source vcvars with 'store' argument in production
         LIB_LINK_FLAGS += /APPCONTAINER
 endif
diff --git a/src/tbb/build/windows.gcc.inc b/src/tbb/build/windows.gcc.inc
index e4dad35c..eef1c1b8 100644
--- a/src/tbb/build/windows.gcc.inc
+++ b/src/tbb/build/windows.gcc.inc
@@ -1,4 +1,4 @@
-# Copyright (c) 2005-2017 Intel Corporation
+# Copyright (c) 2005-2020 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -11,14 +11,6 @@
 # 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 by R
-R_COMPILED_BY ?= 4.9.3
-GCC_VERSION=${subst gcc ,,${R_COMPILED_BY}}
 
 #------------------------------------------------------------------------------
 # Overriding settings from windows.inc
@@ -53,7 +45,7 @@ PROXY.LIB =
 # Compiler-specific variables
 #------------------------------------------------------------------------------
 
-# CPLUS = g++
+CPLUS ?= g++
 COMPILE_ONLY = -c -MMD
 PREPROC_ONLY = -E -x c++
 INCLUDE_KEY = -I
@@ -81,13 +73,13 @@ LINK_FLAGS = -Wl,--enable-auto-import
 LIB_LINK_FLAGS = $(DYLIB_KEY)
 
 # gcc 4.8 and later support RTM intrinsics, but require command line switch to enable them
-ifeq ($(shell expr $(GCC_VERSION) \>= 4.8), 1)
+ifeq (ok,$(call detect_js,/minversion gcc 4.8))
     RTM_KEY = -mrtm
 endif
 
 # gcc 6.0 and later have -flifetime-dse option that controls
 # elimination of stores done outside the object lifetime
-ifeq ($(shell expr $(GCC_VERSION) \>= 6.0), 1)
+ifeq (ok,$(call detect_js,/minversion gcc 6.0))
     # keep pre-contruction stores for zero initialization
     DSE_KEY = -flifetime-dse=1
 endif
@@ -105,7 +97,7 @@ CPLUS_FLAGS += -D_WIN32_WINNT=$(_WIN32_WINNT)
 # MinGW specific
 CPLUS_FLAGS += -DMINGW_HAS_SECURE_API=1 -D__MSVCRT_VERSION__=0x0700 -msse -mthreads
 
-# CONLY = gcc
+CONLY = gcc
 debugger = gdb
 C_FLAGS = $(CPLUS_FLAGS)
 
diff --git a/src/tbb/build/windows.icl.inc b/src/tbb/build/windows.icl.inc
index 7a0b1165..e3b0c0ff 100644
--- a/src/tbb/build/windows.icl.inc
+++ b/src/tbb/build/windows.icl.inc
@@ -1,4 +1,4 @@
-# Copyright (c) 2005-2017 Intel Corporation
+# Copyright (c) 2005-2020 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -11,10 +11,6 @@
 # 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.
-#
-#
-#
-#
 
 #------------------------------------------------------------------------------
 # Define compiler-specific variables.
@@ -33,7 +29,7 @@ cfg ?= release
 #------------------------------------------------------------------------------
 # Setting compiler flags.
 #------------------------------------------------------------------------------
-CPLUS = icl /nologo $(VCCOMPAT_FLAG)
+CPLUS ?= icl /nologo $(VCCOMPAT_FLAG)
 LINK_FLAGS = /link /nologo
 LIB_LINK_FLAGS= /link /nologo /DLL /MAP /DEBUG /fixed:no /INCREMENTAL:NO /DYNAMICBASE /NXCOMPAT
 
@@ -55,6 +51,11 @@ ifeq (ok,$(call detect_js,/minversion icl 17 4))
     VS2017_SUPPORT = yes
 endif
 
+# ICC 19.0.4 and higher provide support for VS2019
+ifeq (ok,$(call detect_js,/minversion icl 19 4))
+    VS2019_SUPPORT = yes
+endif
+
 ifeq ($(runtime), vc_mt)
     MS_CRT_KEY = /MT$(if $(findstring debug,$(cfg)),d)
 else
@@ -63,7 +64,7 @@ endif
 EH_FLAGS = $(if $(no_exceptions),/EHs-,/EHsc /GR)
 
 ifeq ($(cfg), release)
-    CPLUS_FLAGS = $(MS_CRT_KEY) /O2 /Zi $(EH_FLAGS) /Zc:forScope /Zc:wchar_t /D__TBB_LIB_NAME=$(TBB.LIB)
+    CPLUS_FLAGS = $(MS_CRT_KEY) /O2 /Zi /Qopt-report-embed- $(EH_FLAGS) /Zc:forScope /Zc:wchar_t /D__TBB_LIB_NAME=$(TBB.LIB)
     ASM_FLAGS =
 endif
 ifeq ($(cfg), debug)
@@ -114,7 +115,7 @@ ifeq ($(VCCOMPAT_FLAG),)
         VCCOMPAT_FLAG := $(if $(findstring vc8, $(VCVERSION)),/Qvc8)
 endif
 ifeq ($(VCCOMPAT_FLAG),)
-        VCCOMPAT_FLAG := $(if $(findstring vc_mt, $(VCVERSION)),/Qvc10)
+        VCCOMPAT_FLAG := $(if $(findstring vc_mt, $(VCVERSION)),/Qvc14)
 endif
 ifeq ($(VCCOMPAT_FLAG),)
         VCCOMPAT_FLAG := $(if $(findstring vc9, $(VCVERSION)),/Qvc9)
@@ -135,6 +136,11 @@ ifeq ($(VCCOMPAT_FLAG),)
             VCCOMPAT_FLAG := /Qvc14.1
         endif
     endif
+    ifeq ($(VS2019_SUPPORT),yes)
+        ifneq (,$(findstring vc14.2, $(VCVERSION)))
+            VCCOMPAT_FLAG := /Qvc14.2
+        endif
+    endif
 endif
 ifeq ($(VCCOMPAT_FLAG),)
         $(error VC version not detected correctly: $(VCVERSION) )
diff --git a/src/tbb/build/windows.inc b/src/tbb/build/windows.inc
index ea90a3a6..dafd8928 100644
--- a/src/tbb/build/windows.inc
+++ b/src/tbb/build/windows.inc
@@ -1,4 +1,4 @@
-# Copyright (c) 2005-2017 Intel Corporation
+# Copyright (c) 2005-2020 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -11,10 +11,8 @@
 # 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.
-#
-#
-#
-#
+
+export SHELL = cmd
 
 ifdef tbb_build_dir
   test_dir:=$(tbb_build_dir)
@@ -22,34 +20,9 @@ else
   test_dir:=.
 endif
 
-ifndef rtools
-  export SHELL = cmd
-  CMD:=cmd /C
-  SLASH=\\
-  RM=cmd /C del /Q /F
-  RD=cmd /C rmdir
-  MD=cmd /c mkdir
-  NUL= nul
-else
-  ifneq ($(COMSPEC), )
-    # Use comspec env var if present
-    # Since it represents a full path, quote in case there are some spaces.
-    CMD:="$(subst \,/,$(COMSPEC))" /C
-  else
-    # otherwise rely on cmd being in the path
-    CMD:=cmd /C
-  endif
-  export SHELL = sh.exe
-  SLASH=/
-  RD=rmdir
-  MD=mkdir
-  RM=rm
-  NUL= /dev/null
-endif
-
 # A convenience wrapper for calls to detect.js.
 # $(1) is the full command line for the script, e.g. /minversion icl 12
-detect_js = $(shell $(CMD) "cscript //NoLogo //E:jscript $(tbb_root)/build/detect.js $(1)")
+detect_js = $(shell cmd /C "cscript /nologo /E:jscript $(tbb_root)/build/detect.js $(1)")
 
 # TODO give an error if archs doesn't match
 ifndef arch
@@ -64,7 +37,13 @@ native_compiler := cl
 export compiler ?= cl
 debugger ?= devenv /debugexe
 
-CWD=$(shell $(CMD) echo %CD%)
+CMD=cmd /C
+CWD=$(shell cmd /C echo %CD%)
+RM=cmd /C del /Q /F
+RD=cmd /C rmdir
+MD=cmd /c mkdir
+SLASH=\\
+NUL = nul
 
 AR=lib
 AR_OUTPUT_KEY=/out:
@@ -80,7 +59,11 @@ def_prefix = $(if $(findstring intel64,$(arch)),win64,win32)
 # Target Windows version. Do not increase beyond 0x0502 without prior discussion!
 # Used as the value for macro definition option in windows.cl.inc etc.
 # For tests, we need at least Windows XP SP2 for sake of enabling stack backtraces.
+ifeq (1,$(tbb_cpf))
+_WIN32_WINNT=0x0600
+else
 _WIN32_WINNT=0x0502
+endif
 
 TBB.LST = $(tbb_root)/src/tbb/$(def_prefix)-tbb-export.lst
 TBB.DEF = $(TBB.LST:.lst=.def)
@@ -89,13 +72,20 @@ TBB.LIB = tbb$(CPF_SUFFIX)$(DEBUG_SUFFIX).$(LIBEXT)
 TBB.RES = tbb_resource.res
 # On Windows, we use #pragma comment to set the proper TBB lib to link with.
 # But for cross-configuration testing, need to link explicitly.
-# Tests use this variable to detect dependency on TBB binary, so have to be non-empty. 
+# Tests use this variable to detect dependency on TBB binary, so have to be non-empty.
 LINK_TBB.LIB = $(if $(crosstest),$(TBB.LIB),$(DEFINE_KEY)__TBB_IMPLICITLY_LINKED)
 TBB.MANIFEST =
 ifneq ($(filter vc8 vc9,$(runtime)),)
     TBB.MANIFEST = tbbmanifest.exe.manifest
 endif
 
+TBBBIND.DEF = $(tbb_root)/src/tbb/$(def_prefix)-tbbbind-export.def
+TBBBIND.DLL = tbbbind$(DEBUG_SUFFIX).$(DLL)
+TBBBIND.LIB = tbbbind$(DEBUG_SUFFIX).$(LIBEXT)
+TBBBIND.RES = tbbbind.res
+LINK_TBBBIND.LIB = $(TBBBIND.LIB)
+HWLOC.LIB = libhwloc.$(LIBEXT)
+
 MALLOC.DEF = $(MALLOC_ROOT)/$(def_prefix)-tbbmalloc-export.def
 MALLOC.DLL = tbbmalloc$(DEBUG_SUFFIX).$(DLL)
 MALLOC.LIB = tbbmalloc$(DEBUG_SUFFIX).$(LIBEXT)
@@ -120,14 +110,8 @@ ifneq ($(filter vc8 vc9,$(runtime)),)
 RML.MANIFEST = tbbmanifest.exe.manifest
 endif
 
-MAKE_VERSIONS = $(CMD) cscript //NoLogo //E:JScript         \
-  "$(subst \,/,$(tbb_root)/build/version_info_windows.js)"  \
-  "$(subst \,/,$(CONLY))"                                   \
-  "$(arch)"                                                 \
-  "$(subst \,/,$(VERSION_FLAGS))"                           \
-  > version_string.ver
-  
-MAKE_TBBVARS = $(CMD) "$(subst /,\,$(tbb_root)/build/generate_tbbvars.bat)"
+MAKE_VERSIONS = cmd /C cscript /nologo /E:jscript $(subst \,/,$(tbb_root))/build/version_info_windows.js $(compiler) $(arch) $(subst \,/,"$(VERSION_FLAGS)") > version_string.ver
+MAKE_TBBVARS  = cmd /C "$(subst /,\,$(tbb_root))\build\generate_tbbvars.bat"
 
 TEST_LAUNCHER = $(subst /,\,$(tbb_root))\build\test_launcher.bat $(largs)
 
diff --git a/src/tbb/cmake/README.rst b/src/tbb/cmake/README.rst
new file mode 100644
index 00000000..6997a437
--- /dev/null
+++ b/src/tbb/cmake/README.rst
@@ -0,0 +1,361 @@
+.. contents::
+
+Introduction
+------------
+Many developers use CMake to manage their development projects, so the Threading Building Blocks (TBB)
+team created the set of CMake modules to simplify integration of the TBB library into a CMake project.
+The modules are available starting from TBB 2017 U7 in `<tbb_root>/cmake <https://github.com/01org/tbb/tree/tbb_2017/cmake>`_.
+
+About TBB
+^^^^^^^^^^^^^^^
+TBB 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 TBB to be flexible yet efficient. The generic interfaces enable you to customize components to your specific needs.
+
+The net result is that TBB enables you to specify parallelism far more conveniently than using raw threads, and at the same time can improve performance.
+
+References
+^^^^^^^^^^
+* `Official TBB open source site <https://www.threadingbuildingblocks.org/>`_
+* `Official GitHub repository <https://github.com/01org/tbb>`_
+
+Engineering team contacts
+^^^^^^^^^^^^^^^^^^^^^^^^^
+The TBB team is very interested in convenient integration of the TBB library into customer projects. These CMake modules were created to provide such a possibility for CMake projects using a simple but powerful interface. We hope you will try these modules and we are looking forward to receiving your feedback!
+
+E-mail us: `inteltbbdevelopers@intel.com <mailto:inteltbbdevelopers@intel.com>`_.
+
+Visit our `forum <https://software.intel.com/en-us/forums/intel-threading-building-blocks/>`_.
+
+Release Notes
+-------------
+* Minimum supported CMake version: ``3.0.0``.
+* TBB versioning via `find_package <https://cmake.org/cmake/help/latest/command/find_package.html>`_ has the following format: ``find_package(TBB <major>.<minor> ...)``.
+
+Use cases of TBB integration into CMake-aware projects
+------------------------------------------------------------
+There are two types of TBB packages:
+ * Binary packages with pre-built binaries for Windows* OS, Linux* OS and macOS*. They are available on the releases page of the Github repository: https://github.com/01org/tbb/releases. The main purpose of the binary package integration is the ability to build TBB header files and binaries into your CMake-aware project.
+ * A source package is also available to download from the release page via the "Source code" link. In addition, it can be cloned from the repository by ``git clone https://github.com/01org/tbb.git``. The main purpose of the source package integration is to allow you to do a custom build of the TBB library from the source files and then build that into your CMake-aware project.
+
+There are four types of CMake modules that can be used to integrate TBB: `TBBConfig`, `TBBGet`, `TBBMakeConfig` and `TBBBuild`. See `Technical documentation for CMake modules`_ section for additional details.
+
+Binary package integration
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+The following use case is valid for packages starting from TBB 2017 U7:
+
+* Download package manually and make integration.
+
+ Pre-condition: Location of TBBConfig.cmake is available via ``TBB_DIR`` or ``CMAKE_PREFIX_PATH`` contains path to TBB root.
+
+ CMake code for integration:
+  .. code:: cmake
+
+   find_package(TBB <options>)
+
+The following use case is valid for all TBB 2017 packages.
+
+* Download package using TBBGet_ and make integration.
+
+ Pre-condition: TBB CMake modules are available via <path-to-tbb-cmake-modules>.
+
+ CMake code for integration:
+  .. code:: cmake
+
+   include(<path-to-tbb-cmake-modules>/TBBGet.cmake)
+   tbb_get(TBB_ROOT tbb_root CONFIG_DIR TBB_DIR)
+   find_package(TBB <options>)
+
+Source package integration
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+* Build TBB from existing source files using TBBBuild_ and make integration.
+
+ Pre-condition: TBB source code is available via <tbb_root> and TBB CMake modules are available via <path-to-tbb-cmake-modules>.
+
+ CMake code for integration:
+  .. code:: cmake
+
+   include(<path-to-tbb-cmake-modules>/TBBBuild.cmake)
+   tbb_build(TBB_ROOT <tbb_root> CONFIG_DIR TBB_DIR)
+   find_package(TBB <options>)
+
+* Download TBB source files using TBBGet_, build it using TBBBuild_ and make integration.
+
+ Pre-condition: TBB CMake modules are available via <path-to-tbb-cmake-modules>.
+
+ CMake code for integration:
+  .. code:: cmake
+
+   include(<path-to-tbb-cmake-modules>/TBBGet.cmake)
+   include(<path-to-tbb-cmake-modules>/TBBBuild.cmake)
+   tbb_get(TBB_ROOT tbb_root SOURCE_CODE)
+   tbb_build(TBB_ROOT ${tbb_root} CONFIG_DIR TBB_DIR)
+   find_package(TBB <options>)
+
+Tutorials: TBB integration using CMake
+--------------------------------------------
+Binary TBB integration to the sub_string_finder sample (Windows* OS)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+In this example, we will integrate binary TBB package into the sub_string_finder sample on Windows* OS (Microsoft* Visual Studio).
+This example is also applicable for other platforms with slight changes.
+Place holders <version> and <date> should be replaced with the actual values for the TBB package being used. The example is written for `CMake 3.7.1`.
+
+Precondition:
+  * `Microsoft* Visual Studio 11` or higher.
+  * `CMake 3.0.0` or higher.
+
+#. Download the latest binary package for Windows from `this page <https://github.com/01org/tbb/releases/latest>`_ and unpack it to the directory ``C:\demo_tbb_cmake``.
+#. In the directory ``C:\demo_tbb_cmake\tbb<version>_<date>oss\examples\GettingStarted\sub_string_finder`` create ``CMakeLists.txt`` file with the following content:
+    .. code:: cmake
+
+        cmake_minimum_required(VERSION 3.0.0 FATAL_ERROR)
+
+        project(sub_string_finder CXX)
+        add_executable(sub_string_finder sub_string_finder.cpp)
+
+        # find_package will search for available TBBConfig using variables CMAKE_PREFIX_PATH and TBB_DIR.
+        find_package(TBB REQUIRED tbb)
+
+        # Link TBB imported targets to the executable;
+        # "TBB::tbb" can be used instead of "${TBB_IMPORTED_TARGETS}".
+        target_link_libraries(sub_string_finder ${TBB_IMPORTED_TARGETS})
+#. Run CMake GUI and:
+    * Fill the following fields (you can use the buttons ``Browse Source...`` and ``Browse Build...`` accordingly)
+
+     * Where is the source code: ``C:/demo_tbb_cmake/tbb<version>_<date>oss/examples/GettingStarted/sub_string_finder``
+     * Where to build the binaries: ``C:/demo_tbb_cmake/tbb<version>_<date>oss/examples/GettingStarted/sub_string_finder/build``
+
+    * Add new cache entry using button ``Add Entry`` to let CMake know where to search for TBBConfig:
+
+     * Name: ``CMAKE_PREFIX_PATH``
+     * Type: ``PATH``
+     * Value: ``C:/demo_tbb_cmake/tbb<version>_<date>oss``
+
+    * Push the button ``Generate`` and choose a proper generator for your Microsoft* Visual Studio version.
+#. Now you can open the generated solution ``C:/demo_tbb_cmake/tbb<version>_<date>oss/examples/GettingStarted/sub_string_finder/build/sub_string_finder.sln`` in your Microsoft* Visual Studio and build it.
+
+Source code integration of TBB to the sub_string_finder sample (Linux* OS)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+In this example, we will build TBB from source code with enabled Community Preview Features and link the sub_string_finder sample with the built library.
+This example is also applicable for other platforms with slight changes.
+
+Precondition:
+  * `CMake 3.0.0` or higher.
+  * `Git` (to clone the TBB repository from GitHub)
+
+#. Create the directory ``~/demo_tbb_cmake``, go to the created directory and clone the TBB repository there:
+    ``mkdir ~/demo_tbb_cmake ; cd ~/demo_tbb_cmake ; git clone https://github.com/01org/tbb.git``
+#. In the directory ``~/demo_tbb_cmake/tbb/examples/GettingStarted/sub_string_finder`` create ``CMakeLists.txt`` file with following content:
+    .. code:: cmake
+
+     cmake_minimum_required(VERSION 3.0.0 FATAL_ERROR)
+
+     project(sub_string_finder CXX)
+     add_executable(sub_string_finder sub_string_finder.cpp)
+
+     include(${TBB_ROOT}/cmake/TBBBuild.cmake)
+
+     # Build TBB with enabled Community Preview Features (CPF).
+     tbb_build(TBB_ROOT ${TBB_ROOT} CONFIG_DIR TBB_DIR MAKE_ARGS tbb_cpf=1)
+
+     find_package(TBB REQUIRED tbb_preview)
+
+     # Link TBB imported targets to the executable;
+     # "TBB::tbb_preview" can be used instead of "${TBB_IMPORTED_TARGETS}".
+     target_link_libraries(sub_string_finder ${TBB_IMPORTED_TARGETS})
+#. Create a build directory for the sub_string_finder sample to perform build out of source, go to the created directory
+    ``mkdir ~/demo_tbb_cmake/tbb/examples/GettingStarted/sub_string_finder/build ; cd ~/demo_tbb_cmake/tbb/examples/GettingStarted/sub_string_finder/build``
+#. Run CMake to prepare Makefile for the sub_string_finder sample and provide TBB location (root) where to perform build:
+    ``cmake -DTBB_ROOT=${HOME}/demo_tbb_cmake/tbb ..``
+#. Make an executable and run it:
+    ``make ; ./sub_string_finder``
+
+Technical documentation for CMake modules
+-----------------------------------------
+TBBConfig
+^^^^^^^^^
+
+Configuration module for TBB library.
+
+How to use this module in your CMake project:
+ #. Add location of TBB (root) to `CMAKE_PREFIX_PATH <https://cmake.org/cmake/help/latest/variable/CMAKE_PREFIX_PATH.html>`_
+    or specify location of TBBConfig.cmake in ``TBB_DIR``.
+ #. Use `find_package <https://cmake.org/cmake/help/latest/command/find_package.html>`_ to configure TBB.
+ #. Use provided variables and/or imported targets (described below) to work with TBB.
+
+TBB 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``, ``tbb_preview``, etc.).
+
+If components are not specified then default are 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 ``find_package`` call in order to search only for release TBB version. This variable helps to avoid simultaneous linkage of release and debug TBB versions when CMake configuration is `Debug` but a third-party component depends on release TBB version.
+Variables set during TBB configuration:
+
+=========================  ================================================
+         Variable                            Description
+=========================  ================================================
+``TBB_FOUND``              TBB library is found
+``TBB_<component>_FOUND``  specific TBB component is found
+``TBB_IMPORTED_TARGETS``   all created TBB imported targets
+``TBB_VERSION``            TBB version (format: ``<major>.<minor>``)
+``TBB_INTERFACE_VERSION``  TBB interface version (can be empty, see below for details)
+=========================  ================================================
+
+TBBInstallConfig
+^^^^^^^^^^^^^^^^
+
+Module for generation and installation of TBB CMake configuration files (TBBConfig.cmake and TBBConfigVersion.cmake files) on Linux, macOS and Windows.
+
+Provides the following functions:
+
+ .. code:: cmake
+
+  tbb_install_config(INSTALL_DIR <install_dir> SYSTEM_NAME Linux|Darwin|Windows
+                     [TBB_VERSION <major>.<minor>|TBB_VERSION_FILE <version_file>]
+                     [LIB_REL_PATH <lib_rel_path> INC_REL_PATH <inc_rel_path>]
+                     [LIB_PATH <lib_path> INC_PATH <inc_path>])``
+
+**Note: the module overwrites existing TBBConfig.cmake and TBBConfigVersion.cmake files in <install_dir>.**
+
+``tbb_config_installer.cmake`` allows to run ``TBBInstallConfig.cmake`` from command line.
+It accepts the same parameters as ``tbb_install_config`` function, run ``cmake -P tbb_config_installer.cmake`` to get help.
+
+Use cases
+"""""""""
+**Prepare TBB CMake configuration files for custom TBB package.**
+
+The use case is applicable for package maintainers who create own TBB packages and want to create TBBConfig.cmake and TBBConfigVersion.cmake for these packages.
+
+===========================================  ===========================================================
+              Parameter                                      Description
+===========================================  ===========================================================
+``INSTALL_DIR <directory>``                  Directory to install CMake configuration files
+``SYSTEM_NAME Linux|Darwin|Windows``         OS name to generate config files for
+``TBB_VERSION_FILE <version_file>``          Path to ``tbb_stddef.h`` to parse version from and
+                                             write it to TBBConfigVersion.cmake
+``TBB_VERSION <major>.<minor>``              Directly specified TBB version; alternative to ``TBB_VERSION_FILE`` parameter;
+                                             ``TBB_INTERFACE_VERSION`` is set to empty value in this case
+``LIB_REL_PATH <lib_rel_path>``              Relative path to TBB binaries (.lib files on Windows), default: ``../../../lib``
+``BIN_REL_PATH <bin_rel_path>``              Relative path to TBB DLLs, default: ``../../../bin`` (applicable for Windows only)
+``INC_REL_PATH <inc_rel_path>``              Relative path to TBB headers, default: ``../../../include``
+===========================================  ===========================================================
+
+*Example*
+
+ Assume your package is installed to the following structure:
+
+ * Binaries go to ``<prefix>/lib``
+ * Headers go to ``<prefix>/include``
+ * CMake configuration files go to ``<prefix>/lib/cmake/<package>``
+
+ The package is packed from ``/my/package/content`` directory.
+
+ ``cmake -DINSTALL_DIR=/my/package/content/lib/cmake/TBB -DSYSTEM_NAME=Linux -DTBB_VERSION_FILE=/my/package/content/include/tbb/tbb_stddef.h -P tbb_config_installer.cmake`` (default relative paths will be used)
+
+**Install TBB CMake configuration files for installed TBB.**
+
+The use case is applicable for users who have installed TBB, but do not have (or have incorrect) CMake configuration files for this TBB.
+
+====================================  ==============================================
+      Parameter                            Description
+====================================  ==============================================
+``INSTALL_DIR <directory>``           Directory to install CMake configuration files
+``SYSTEM_NAME Linux|Darwin|Windows``  OS name to generate config files for
+``LIB_PATH <lib_path>``               Path to installed TBB binaries (.lib files on Windows)
+``BIN_PATH <bin_path>``               Path to installed TBB DLLs (applicable for Windows only)
+``INC_PATH <inc_path>``               Path to installed TBB headers
+====================================  ==============================================
+
+``LIB_PATH`` and ``INC_PATH`` will be converted to relative paths based on ``INSTALL_DIR``.
+By default TBB version will be parsed from ``<inc_path>/tbb/tbb_stddef.h``,
+but it can be overridden by optional parameters ``TBB_VERSION_FILE`` or ``TBB_VERSION``.
+
+*Example*
+
+ TBB is installed to ``/usr`` directory.
+ In order to create TBBConfig.cmake and TBBConfigVersion.cmake in ``/usr/lib/cmake/TBB`` run
+
+ ``cmake -DINSTALL_DIR=/usr/lib/cmake/TBB -DSYSTEM_NAME=Linux -DLIB_PATH=/usr/lib -DINC_PATH=/usr/include -P tbb_config_installer.cmake``.
+
+TBBGet
+^^^^^^
+
+Module for getting TBB library from `GitHub <https://github.com/01org/tbb>`_.
+
+Provides the following functions:
+ ``tbb_get(TBB_ROOT <variable> [RELEASE_TAG <release_tag>|LATEST] [SAVE_TO <path>] [SYSTEM_NAME Linux|Windows|Darwin] [CONFIG_DIR <variable> | SOURCE_CODE])``
+  downloads TBB from GitHub and creates TBBConfig for the downloaded binary package if there is no TBBConfig.
+
+  ====================================  ====================================
+                     Parameter                       Description
+  ====================================  ====================================
+  ``TBB_ROOT <variable>``               a variable to save TBB root in, ``<variable>-NOTFOUND`` will be provided in case ``tbb_get`` is unsuccessful
+  ``RELEASE_TAG <release_tag>|LATEST``  TBB release tag to be downloaded (for example, ``2017_U6``), ``LATEST`` is used by default
+  ``SAVE_TO <path>``                    path to location at which to unpack downloaded TBB, ``${CMAKE_CURRENT_BINARY_DIR}/tbb_downloaded`` is used by default
+  ``SYSTEM_NAME Linux|Windows|Darwin``  operating system name to download a binary package for,
+                                        value of `CMAKE_SYSTEM_NAME <https://cmake.org/cmake/help/latest/variable/CMAKE_SYSTEM_NAME.html>`_ is used by default
+  ``CONFIG_DIR <variable>``             a variable to save location of TBBConfig.cmake and TBBConfigVersion.cmake. Ignored if ``SOURCE_CODE`` specified
+  ``SOURCE_CODE``                       flag to get TBB source code (instead of binary package)
+  ====================================  ====================================
+
+TBBMakeConfig
+^^^^^^^^^^^^^
+
+Module for making TBBConfig in `official TBB binary packages published on GitHub <https://github.com/01org/tbb/releases>`_.
+
+This module is to be used for packages that do not have TBBConfig.
+
+Provides the following functions:
+ ``tbb_make_config(TBB_ROOT <path> CONFIG_DIR <variable> [SYSTEM_NAME Linux|Windows|Darwin])``
+  creates CMake configuration files (TBBConfig.cmake and TBBConfigVersion.cmake) for TBB binary package.
+
+  ====================================  ====================================
+                     Parameter                       Description
+  ====================================  ====================================
+  ``TBB_ROOT <variable>``               path to TBB root
+  ``CONFIG_DIR <variable>``             a variable to store location of the created configuration files
+  ``SYSTEM_NAME Linux|Windows|Darwin``  operating system name of the binary TBB package,
+                                        value of `CMAKE_SYSTEM_NAME <https://cmake.org/cmake/help/latest/variable/CMAKE_SYSTEM_NAME.html>`_ is used by default
+  ====================================  ====================================
+
+TBBBuild
+^^^^^^^^
+
+Module for building TBB library from the source code.
+
+Provides the following functions:
+ ``tbb_build(TBB_ROOT <tbb_root> CONFIG_DIR <variable> [MAKE_ARGS <custom_make_arguments>])``
+  builds TBB from source code using the ``Makefile``, creates and provides the location of the CMake configuration files (TBBConfig.cmake and TBBConfigVersion.cmake) .
+
+  =====================================  ====================================
+                Parameter                             Description
+  =====================================  ====================================
+  ``TBB_ROOT <variable>``                path to TBB root
+  ``CONFIG_DIR <variable>``              a variable to store location of the created configuration files,
+                                         ``<variable>-NOTFOUND`` will be provided in case ``tbb_build`` is unsuccessful
+  ``MAKE_ARGS <custom_make_arguments>``  custom arguments to be passed to ``make`` tool.
+
+                                         The following arguments are always passed with automatically detected values to
+                                         ``make`` tool if they are not redefined in ``<custom_make_arguments>``:
+
+                                           - ``compiler=<compiler>``
+                                           - ``tbb_build_dir=<tbb_build_dir>``
+                                           - ``tbb_build_prefix=<tbb_build_prefix>``
+                                           - ``-j<n>``
+  =====================================  ====================================
+
+
+------------
+
+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.
diff --git a/src/tbb/cmake/TBBBuild.cmake b/src/tbb/cmake/TBBBuild.cmake
new file mode 100644
index 00000000..e4831d09
--- /dev/null
+++ b/src/tbb/cmake/TBBBuild.cmake
@@ -0,0 +1,197 @@
+# Copyright (c) 2017-2020 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.
+
+#
+# Usage:
+#  include(TBBBuild.cmake)
+#  tbb_build(TBB_ROOT <tbb_root> CONFIG_DIR <config_dir> MAKE_ARGS <arg1> [... <argN>])
+#  find_package(TBB <options>)
+#
+
+include(CMakeParseArguments)
+
+# Save the location of Intel TBB CMake modules here, as it will not be possible to do inside functions,
+# see for details: https://cmake.org/cmake/help/latest/variable/CMAKE_CURRENT_LIST_DIR.html
+set(_tbb_cmake_module_path ${CMAKE_CURRENT_LIST_DIR})
+
+##
+# Builds Intel TBB.
+#
+# Parameters:
+#  TBB_ROOT   <directory> - path to Intel TBB root directory (with sources);
+#  MAKE_ARGS  <list>      - user-defined arguments to be passed to make-tool;
+#  CONFIG_DIR <variable>  - store location of the created TBBConfig if the build was ok, store <variable>-NOTFOUND otherwise.
+#
+function(tbb_build)
+    # NOTE: internal function are used to hide them from user.
+
+    ##
+    # Provides arguments for make-command to build Intel TBB.
+    #
+    # Following arguments are provided automatically if they are not defined by user:
+    #  compiler=<value>
+    #  tbb_build_dir=<value>
+    #  tbb_build_prefix=<value>
+    #  -j<n>
+    #
+    # Parameters:
+    #  USER_DEFINED_ARGS <list> - list of user-defined arguments;
+    #  RESULT <variable> - resulting list of 'make' arguments.
+    #
+    function(tbb_get_make_args)
+        set(oneValueArgs RESULT)
+        set(multiValueArgs USER_DEFINED_ARGS)
+        cmake_parse_arguments(tbb_GMA "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+
+        set(result "${tbb_GMA_USER_DEFINED_ARGS}")
+
+        if (NOT tbb_GMA_USER_DEFINED_ARGS MATCHES "compiler=")
+            # TODO: add other supported compilers.
+            if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+                set(compiler gcc)
+            elseif (CMAKE_CXX_COMPILER_ID STREQUAL "Intel")
+                set(compiler icc)
+                if (CMAKE_SYSTEM_NAME MATCHES "Windows")
+                    set(compiler icl)
+                endif()
+            elseif (MSVC)
+                set(compiler cl)
+            elseif (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+                set(compiler clang)
+            endif()
+
+            set(result "compiler=${compiler}" ${result})
+        endif()
+
+        if (NOT tbb_GMA_USER_DEFINED_ARGS MATCHES "stdver=" AND DEFINED CMAKE_CXX_STANDARD)
+            set(result "stdver=c++${CMAKE_CXX_STANDARD}" ${result})
+        endif()
+
+        if (NOT tbb_GMA_USER_DEFINED_ARGS MATCHES "tbb_build_dir=")
+            set(result "tbb_build_dir=${CMAKE_CURRENT_BINARY_DIR}/tbb_cmake_build" ${result})
+        endif()
+
+        if (NOT tbb_GMA_USER_DEFINED_ARGS MATCHES "tbb_build_prefix=")
+            set(result "tbb_build_prefix=tbb_cmake_build_subdir" ${result})
+        endif()
+
+        if (NOT tbb_GMA_USER_DEFINED_ARGS MATCHES "(;|^) *\\-j[0-9]* *(;|$)")
+            include(ProcessorCount)
+            ProcessorCount(num_of_cores)
+            if (NOT num_of_cores EQUAL 0)
+                set(result "-j${num_of_cores}" ${result})
+            endif()
+        endif()
+
+        if (CMAKE_SYSTEM_NAME MATCHES "Android")
+            set(result target=android ${result})
+        endif()
+
+        set(${tbb_GMA_RESULT} ${result} PARENT_SCOPE)
+    endfunction()
+
+    ##
+    # Provides release and debug directories basing on 'make' arguments.
+    #
+    # Following 'make' arguments are parsed: tbb_build_dir, tbb_build_prefix
+    #
+    # Parameters:
+    #  MAKE_ARGS   <list>     - 'make' arguments (tbb_build_dir and tbb_build_prefix are required)
+    #  RELEASE_DIR <variable> - store normalized (CMake) path to release directory
+    #  DEBUG_DIR   <variable> - store normalized (CMake) path to debug directory
+    #
+    function(tbb_get_build_paths_from_make_args)
+        set(oneValueArgs RELEASE_DIR DEBUG_DIR)
+        set(multiValueArgs MAKE_ARGS)
+        cmake_parse_arguments(tbb_GBPFMA "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+
+        foreach(arg ${tbb_GBPFMA_MAKE_ARGS})
+            if (arg MATCHES "tbb_build_dir=")
+                string(REPLACE "tbb_build_dir=" "" tbb_build_dir "${arg}")
+            elseif (arg MATCHES "tbb_build_prefix=")
+                string(REPLACE "tbb_build_prefix=" "" tbb_build_prefix "${arg}")
+            endif()
+        endforeach()
+
+        set(tbb_release_dir "${tbb_build_dir}/${tbb_build_prefix}_release")
+        set(tbb_debug_dir "${tbb_build_dir}/${tbb_build_prefix}_debug")
+
+        file(TO_CMAKE_PATH "${tbb_release_dir}" tbb_release_dir)
+        file(TO_CMAKE_PATH "${tbb_debug_dir}" tbb_debug_dir)
+
+        set(${tbb_GBPFMA_RELEASE_DIR} ${tbb_release_dir} PARENT_SCOPE)
+        set(${tbb_GBPFMA_DEBUG_DIR} ${tbb_debug_dir} PARENT_SCOPE)
+    endfunction()
+
+    # -------------------- #
+    # Function entry point #
+    # -------------------- #
+    set(oneValueArgs TBB_ROOT CONFIG_DIR)
+    set(multiValueArgs MAKE_ARGS)
+    cmake_parse_arguments(tbb_build "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+
+    if (NOT EXISTS "${tbb_build_TBB_ROOT}/Makefile" OR NOT EXISTS "${tbb_build_TBB_ROOT}/src")
+        message(STATUS "Intel TBB can not be built: Makefile or src directory was not found in ${tbb_build_TBB_ROOT}")
+        set(${tbb_build_CONFIG_DIR} ${tbb_build_CONFIG_DIR}-NOTFOUND PARENT_SCOPE)
+        return()
+    endif()
+
+    set(make_tool_name make)
+    if (CMAKE_SYSTEM_NAME MATCHES "Windows")
+        set(make_tool_name gmake)
+    elseif (CMAKE_SYSTEM_NAME MATCHES "Android")
+        set(make_tool_name ndk-build)
+    endif()
+
+    find_program(TBB_MAKE_TOOL ${make_tool_name} DOC "Make-tool to build Intel TBB.")
+    mark_as_advanced(TBB_MAKE_TOOL)
+
+    if (NOT TBB_MAKE_TOOL)
+        message(STATUS "Intel TBB can not be built: required make-tool (${make_tool_name}) was not found")
+        set(${tbb_build_CONFIG_DIR} ${tbb_build_CONFIG_DIR}-NOTFOUND PARENT_SCOPE)
+        return()
+    endif()
+
+    tbb_get_make_args(USER_DEFINED_ARGS ${tbb_build_MAKE_ARGS} RESULT tbb_make_args)
+
+    set(tbb_build_cmd ${TBB_MAKE_TOOL} ${tbb_make_args})
+
+    string(REPLACE ";" " " tbb_build_cmd_str "${tbb_build_cmd}")
+    message(STATUS "Building Intel TBB: ${tbb_build_cmd_str}")
+    execute_process(COMMAND ${tbb_build_cmd}
+                    WORKING_DIRECTORY ${tbb_build_TBB_ROOT}
+                    RESULT_VARIABLE tbb_build_result
+                    ERROR_VARIABLE tbb_build_error_output
+                    OUTPUT_QUIET)
+
+    if (NOT tbb_build_result EQUAL 0)
+        message(STATUS "Building is unsuccessful (${tbb_build_result}): ${tbb_build_error_output}")
+        set(${tbb_build_CONFIG_DIR} ${tbb_build_CONFIG_DIR}-NOTFOUND PARENT_SCOPE)
+        return()
+    endif()
+
+    tbb_get_build_paths_from_make_args(MAKE_ARGS ${tbb_make_args}
+                                       RELEASE_DIR tbb_release_dir
+                                       DEBUG_DIR tbb_debug_dir)
+
+    include(${_tbb_cmake_module_path}/TBBMakeConfig.cmake)
+    tbb_make_config(TBB_ROOT ${tbb_build_TBB_ROOT}
+                    SYSTEM_NAME ${CMAKE_SYSTEM_NAME}
+                    CONFIG_DIR tbb_config_dir
+                    CONFIG_FOR_SOURCE
+                    TBB_RELEASE_DIR ${tbb_release_dir}
+                    TBB_DEBUG_DIR ${tbb_debug_dir})
+
+    set(${tbb_build_CONFIG_DIR} ${tbb_config_dir} PARENT_SCOPE)
+endfunction()
diff --git a/src/tbb/cmake/TBBGet.cmake b/src/tbb/cmake/TBBGet.cmake
new file mode 100644
index 00000000..230edcab
--- /dev/null
+++ b/src/tbb/cmake/TBBGet.cmake
@@ -0,0 +1,294 @@
+# Copyright (c) 2017-2020 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(CMakeParseArguments)
+
+# Save the location of Intel TBB CMake modules here, as it will not be possible to do inside functions,
+# see for details: https://cmake.org/cmake/help/latest/variable/CMAKE_CURRENT_LIST_DIR.html
+set(_tbb_cmake_module_path ${CMAKE_CURRENT_LIST_DIR})
+
+##
+# Downloads file.
+#
+# Parameters:
+#  URL     <url>      - URL to download data from;
+#  SAVE_AS <filename> - filename there to save downloaded data;
+#  INFO    <string>   - text description of content to be downloaded;
+#                       will be printed as message in format is "Downloading <INFO>: <URL>;
+#  FORCE              - option to delete local file from SAVE_AS if it exists;
+#
+function(_tbb_download_file)
+    set(options FORCE)
+    set(oneValueArgs URL RELEASE SAVE_AS INFO)
+    cmake_parse_arguments(tbb_df "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+
+    if (tbb_df_FORCE AND EXISTS "${tbb_df_SAVE_AS}")
+        file(REMOVE ${tbb_df_SAVE_AS})
+    endif()
+
+    if (NOT EXISTS "${tbb_df_SAVE_AS}")
+        set(_show_progress)
+        if (TBB_DOWNLOADING_PROGRESS)
+            set(_show_progress SHOW_PROGRESS)
+        endif()
+
+        message(STATUS "Downloading ${tbb_df_INFO}: ${tbb_df_URL}")
+        file(DOWNLOAD ${tbb_df_URL} ${tbb_df_SAVE_AS} ${_show_progress} STATUS download_status)
+
+        list(GET download_status 0 download_status_num)
+        if (NOT download_status_num EQUAL 0)
+            message(STATUS "Unsuccessful downloading: ${download_status}")
+            file(REMOVE ${tbb_df_SAVE_AS})
+            return()
+        endif()
+    else()
+        message(STATUS "Needed file was found locally ${tbb_df_SAVE_AS}. Remove it if you still want to download a new one")
+    endif()
+endfunction()
+
+##
+# Checks if specified Intel TBB release is available on GitHub.
+#
+# tbb_check_git_release(<release> <result>)
+# Parameters:
+#  <release_tag> - release to be checked;
+#  <result>  - store result (TRUE/FALSE).
+#
+function(_tbb_check_git_release_tag _tbb_release_tag _tbb_release_tag_avail)
+    if (_tbb_release_tag STREQUAL LATEST)
+        set(${_tbb_release_tag_avail} TRUE PARENT_SCOPE)
+        return()
+    endif()
+
+    set(tbb_releases_file "${CMAKE_CURRENT_BINARY_DIR}/tbb_releases.json")
+
+    _tbb_download_file(URL     "${tbb_github_api}/releases"
+                       SAVE_AS ${tbb_releases_file}
+                       INFO    "information from GitHub about Intel TBB releases"
+                       FORCE)
+
+    if (NOT EXISTS "${tbb_releases_file}")
+        set(${_tbb_release_tag_avail} FALSE PARENT_SCOPE)
+        return()
+    endif()
+
+    file(READ ${tbb_releases_file} tbb_releases)
+
+    string(REPLACE "\"" "" tbb_releases ${tbb_releases})
+    string(REGEX MATCHALL "tag_name: *([A-Za-z0-9_\\.]+)" tbb_releases ${tbb_releases})
+
+    set(_release_available FALSE)
+    foreach(tbb_rel ${tbb_releases})
+        string(REGEX REPLACE "tag_name: *" "" tbb_rel_cut ${tbb_rel})
+        list(REMOVE_ITEM tbb_releases ${tbb_rel})
+        list(APPEND tbb_releases ${tbb_rel_cut})
+        if (_tbb_release_tag STREQUAL tbb_rel_cut)
+            set(_release_available TRUE)
+            break()
+        endif()
+    endforeach()
+
+    if (NOT _release_available)
+        string(REPLACE ";" ", " tbb_releases_str "${tbb_releases}")
+        message(STATUS "Requested release tag ${_tbb_release_tag} is not available. Available Intel TBB release tags: ${tbb_releases_str}")
+    endif()
+
+    set(${_tbb_release_tag_avail} ${_release_available} PARENT_SCOPE)
+endfunction()
+
+##
+# Compares two Intel TBB releases and provides result
+# TRUE if the first release is less than the second, FALSE otherwise.
+#
+# tbb_is_release_less(<rel1> <rel2> <result>)
+#
+function(_tbb_is_release_less rel1 rel2 result)
+    # Convert release to numeric representation to compare it using "if" with VERSION_LESS.
+    string(REGEX REPLACE "[A-Za-z]" "" rel1 "${rel1}")
+    string(REPLACE "_" "." rel1 "${rel1}")
+    string(REGEX REPLACE "[A-Za-z]" "" rel2 "${rel2}")
+    string(REPLACE "_" "." rel2 "${rel2}")
+
+    if (${rel1} VERSION_LESS ${rel2})
+        set(${result} TRUE PARENT_SCOPE)
+        return()
+    endif()
+
+    set(${result} FALSE PARENT_SCOPE)
+endfunction()
+
+##
+# Finds exact URL to download Intel TBB basing on provided parameters.
+#
+# Usage:
+#  _tbb_get_url(URL <var_to_save_url> RELEASE_TAG <release_tag|LATEST> OS <os> [SOURCE_CODE])
+#
+function(_tbb_get_url)
+    set(oneValueArgs URL RELEASE_TAG OS)
+    set(options SOURCE_CODE)
+    cmake_parse_arguments(tbb_get_url "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+
+    set(tbb_github_api "https://api.github.com/repos/01org/tbb")
+
+    _tbb_check_git_release_tag(${tbb_get_url_RELEASE_TAG} tbb_release_available)
+    if (NOT tbb_release_available)
+        set(${tbb_download_FULL_PATH} ${tbb_download_FULL_PATH}-NOTFOUND PARENT_SCOPE)
+        return()
+    endif()
+
+    if (tbb_get_url_RELEASE_TAG STREQUAL LATEST)
+        set(tbb_rel_info_api_url "${tbb_github_api}/releases/latest")
+    else()
+        set(tbb_rel_info_api_url "${tbb_github_api}/releases/tags/${tbb_get_url_RELEASE_TAG}")
+    endif()
+
+    set(tbb_release_info_file "${CMAKE_CURRENT_BINARY_DIR}/tbb_${tbb_get_url_RELEASE_TAG}_info.json")
+
+    _tbb_download_file(URL     ${tbb_rel_info_api_url}
+                       SAVE_AS ${tbb_release_info_file}
+                       INFO    "information from GitHub about packages for Intel TBB ${tbb_get_url_RELEASE_TAG}"
+                       FORCE)
+
+    if (NOT EXISTS "${tbb_release_info_file}")
+        set(${tbb_get_url_URL} ${tbb_get_url_URL}-NOTFOUND PARENT_SCOPE)
+        return()
+    endif()
+
+    file(STRINGS ${tbb_release_info_file} tbb_release_info)
+
+    if (tbb_get_url_SOURCE_CODE)
+        # Find name of the latest release to get link to source archive.
+        if (tbb_get_url_RELEASE_TAG STREQUAL LATEST)
+            string(REPLACE "\"" "" tbb_release_info ${tbb_release_info})
+            string(REGEX REPLACE ".*tag_name: *([A-Za-z0-9_\\.]+).*" "\\1" tbb_get_url_RELEASE_TAG "${tbb_release_info}")
+        endif()
+
+        set(${tbb_get_url_URL} "https://github.com/01org/tbb/archive/${tbb_get_url_RELEASE_TAG}.tar.gz" PARENT_SCOPE)
+    else()
+        if (tbb_get_url_OS MATCHES "Linux")
+            set(tbb_lib_archive_suffix lin.tgz)
+        elseif (tbb_get_url_OS MATCHES "Windows")
+            set(tbb_lib_archive_suffix win.zip)
+        elseif (tbb_get_url_OS MATCHES "Darwin")
+            set(tbb_lib_archive_suffix mac.tgz)
+
+            # Since 2017_U4 release archive for Apple has suffix "mac.tgz" instead of "osx.tgz".
+            if (NOT tbb_get_url_RELEASE_TAG STREQUAL "LATEST")
+                _tbb_is_release_less(${tbb_get_url_RELEASE_TAG} 2017_U4 release_less)
+                if (release_less)
+                    set(tbb_lib_archive_suffix osx.tgz)
+                endif()
+            endif()
+        elseif (tbb_get_url_OS MATCHES "Android")
+            set(tbb_lib_archive_suffix and.tgz)
+        else()
+            message(STATUS "Currently prebuilt Intel TBB is not available for your OS (${tbb_get_url_OS})")
+            set(${tbb_get_url_URL} ${tbb_get_url_URL}-NOTFOUND PARENT_SCOPE)
+            return()
+        endif()
+
+        string(REGEX REPLACE ".*(https.*${tbb_lib_archive_suffix}).*" "\\1" tbb_bin_url "${tbb_release_info}")
+
+        set(${tbb_get_url_URL} ${tbb_bin_url} PARENT_SCOPE)
+    endif()
+endfunction()
+
+function(tbb_get)
+    set(oneValueArgs RELEASE_TAG SYSTEM_NAME SAVE_TO TBB_ROOT CONFIG_DIR)
+    set(options SOURCE_CODE)
+    cmake_parse_arguments(tbb_get "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+
+    set(tbb_os ${CMAKE_SYSTEM_NAME})
+    if (tbb_get_SYSTEM_NAME)
+        set(tbb_os ${tbb_get_SYSTEM_NAME})
+    endif()
+
+    set(tbb_release_tag LATEST)
+    if (tbb_get_RELEASE_TAG)
+        set(tbb_release_tag ${tbb_get_RELEASE_TAG})
+    endif()
+
+    set(tbb_save_to ${CMAKE_CURRENT_BINARY_DIR}/tbb_downloaded)
+    if (tbb_get_SAVE_TO)
+        set(tbb_save_to ${tbb_get_SAVE_TO})
+    endif()
+
+    if (tbb_get_SOURCE_CODE)
+        _tbb_get_url(URL tbb_url RELEASE_TAG ${tbb_release_tag} OS ${tbb_os} SOURCE_CODE)
+    else()
+        _tbb_get_url(URL tbb_url RELEASE_TAG ${tbb_release_tag} OS ${tbb_os})
+    endif()
+
+    if (NOT tbb_url)
+        message(STATUS "URL to download Intel TBB has not been found")
+        set(${tbb_get_TBB_ROOT} ${tbb_get_TBB_ROOT}-NOTFOUND PARENT_SCOPE)
+        return()
+    endif()
+
+    get_filename_component(filename ${tbb_url} NAME)
+    set(local_file "${CMAKE_CURRENT_BINARY_DIR}/${filename}")
+
+    _tbb_download_file(URL     ${tbb_url}
+                       SAVE_AS ${local_file}
+                       INFO    "Intel TBB library")
+
+    if (NOT EXISTS "${local_file}")
+        set(${tbb_get_TBB_ROOT} ${tbb_get_TBB_ROOT}-NOTFOUND PARENT_SCOPE)
+        return()
+    endif()
+
+    get_filename_component(subdir_name ${filename} NAME_WE)
+    file(MAKE_DIRECTORY ${tbb_save_to}/${subdir_name})
+    if (NOT EXISTS "${tbb_save_to}/${subdir_name}")
+        message(STATUS "${tbb_save_to}/${subdir_name} can not be created")
+        set(${tbb_get_TBB_ROOT} ${tbb_get_TBB_ROOT}-NOTFOUND PARENT_SCOPE)
+        return()
+    endif()
+
+    message(STATUS "Unpacking ${local_file} to ${tbb_save_to}/${subdir_name}")
+    execute_process(COMMAND ${CMAKE_COMMAND} -E tar xzf ${local_file}
+                    WORKING_DIRECTORY ${tbb_save_to}/${subdir_name}
+                    RESULT_VARIABLE unpacking_result)
+
+    if (NOT unpacking_result EQUAL 0)
+        message(STATUS "Unsuccessful unpacking: ${unpacking_result}")
+        set(${tbb_get_TBB_ROOT} ${tbb_get_TBB_ROOT}-NOTFOUND PARENT_SCOPE)
+        return()
+    endif()
+
+    file(GLOB_RECURSE tbb_h ${tbb_save_to}/${subdir_name}/*/include/tbb/tbb.h)
+    list(GET tbb_h 0 tbb_h)
+
+    if (NOT EXISTS "${tbb_h}")
+        message(STATUS "tbb/tbb.h has not been found in the downloaded package")
+        set(${tbb_get_TBB_ROOT} ${tbb_get_TBB_ROOT}-NOTFOUND PARENT_SCOPE)
+        return()
+    endif()
+
+    get_filename_component(tbb_root "${tbb_h}" PATH)
+    get_filename_component(tbb_root "${tbb_root}" PATH)
+    get_filename_component(tbb_root "${tbb_root}" PATH)
+
+    if (NOT tbb_get_SOURCE_CODE)
+        set(tbb_config_dir ${tbb_root}/cmake)
+
+        if (NOT EXISTS "${tbb_config_dir}")
+            tbb_make_config(TBB_ROOT ${tbb_root} CONFIG_DIR tbb_config_dir)
+        endif()
+
+        set(${tbb_get_CONFIG_DIR} ${tbb_config_dir} PARENT_SCOPE)
+    endif()
+
+    set(${tbb_get_TBB_ROOT} ${tbb_root} PARENT_SCOPE)
+endfunction()
diff --git a/src/tbb/cmake/TBBInstallConfig.cmake b/src/tbb/cmake/TBBInstallConfig.cmake
new file mode 100644
index 00000000..e846fe3d
--- /dev/null
+++ b/src/tbb/cmake/TBBInstallConfig.cmake
@@ -0,0 +1,124 @@
+# Copyright (c) 2019-2020 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(CMakeParseArguments)
+
+# Save the location of Intel TBB CMake modules here, as it will not be possible to do inside functions,
+# see for details: https://cmake.org/cmake/help/latest/variable/CMAKE_CURRENT_LIST_DIR.html
+set(_tbb_cmake_module_path ${CMAKE_CURRENT_LIST_DIR})
+
+function(tbb_install_config)
+    set(oneValueArgs INSTALL_DIR
+                     SYSTEM_NAME
+                     LIB_REL_PATH INC_REL_PATH BIN_REL_PATH TBB_VERSION TBB_VERSION_FILE
+                     LIB_PATH BIN_PATH INC_PATH)                                      # If TBB is installed on the system
+
+    cmake_parse_arguments(tbb_IC "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+
+    get_filename_component(config_install_dir ${tbb_IC_INSTALL_DIR} ABSOLUTE)
+    file(MAKE_DIRECTORY ${config_install_dir})
+
+    # --- TBB_LIB_REL_PATH handling ---
+    set(TBB_LIB_REL_PATH "../../../lib")
+
+    if (tbb_IC_LIB_REL_PATH)
+        file(TO_CMAKE_PATH ${tbb_IC_LIB_REL_PATH} TBB_LIB_REL_PATH)
+    endif()
+
+    if (tbb_IC_LIB_PATH)
+        get_filename_component(lib_abs_path ${tbb_IC_LIB_PATH} ABSOLUTE)
+        file(RELATIVE_PATH TBB_LIB_REL_PATH ${config_install_dir} ${lib_abs_path})
+        unset(lib_abs_path)
+    endif()
+    # ------
+
+    # --- TBB_BIN_REL_PATH handling ---
+    set(TBB_BIN_REL_PATH "../../../bin")
+
+    if (tbb_IC_BIN_REL_PATH)
+        file(TO_CMAKE_PATH ${tbb_IC_BIN_REL_PATH} TBB_BIN_REL_PATH)
+    endif()
+
+    if (tbb_IC_BIN_PATH)
+        get_filename_component(bin_abs_path ${tbb_IC_BIN_PATH} ABSOLUTE)
+        file(RELATIVE_PATH TBB_BIN_REL_PATH ${config_install_dir} ${bin_abs_path})
+        unset(bin_abs_path)
+    endif()
+    # ------
+
+    # --- TBB_INC_REL_PATH handling ---
+    set(TBB_INC_REL_PATH "../../../include")
+
+    if (tbb_IC_INC_REL_PATH)
+        file(TO_CMAKE_PATH ${tbb_IC_INC_REL_PATH} TBB_INC_REL_PATH)
+    endif()
+
+    if (tbb_IC_INC_PATH)
+        get_filename_component(inc_abs_path ${tbb_IC_INC_PATH} ABSOLUTE)
+        file(RELATIVE_PATH TBB_INC_REL_PATH ${config_install_dir} ${inc_abs_path})
+        unset(inc_abs_path)
+    endif()
+    # ------
+
+    # --- TBB_VERSION handling ---
+    if (tbb_IC_TBB_VERSION)
+        set(TBB_VERSION ${tbb_IC_TBB_VERSION})
+    else()
+        set(tbb_version_file "${config_install_dir}/${TBB_INC_REL_PATH}/tbb/tbb_stddef.h")
+        if (tbb_IC_TBB_VERSION_FILE)
+            set(tbb_version_file ${tbb_IC_TBB_VERSION_FILE})
+        endif()
+
+        file(READ ${tbb_version_file} _tbb_stddef)
+        string(REGEX REPLACE ".*#define TBB_VERSION_MAJOR ([0-9]+).*" "\\1" _tbb_ver_major "${_tbb_stddef}")
+        string(REGEX REPLACE ".*#define TBB_VERSION_MINOR ([0-9]+).*" "\\1" _tbb_ver_minor "${_tbb_stddef}")
+        string(REGEX REPLACE ".*#define TBB_INTERFACE_VERSION ([0-9]+).*" "\\1" TBB_INTERFACE_VERSION "${_tbb_stddef}")
+        set(TBB_VERSION "${_tbb_ver_major}.${_tbb_ver_minor}")
+    endif()
+    # ------
+
+    set(tbb_system_name ${CMAKE_SYSTEM_NAME})
+    if (tbb_IC_SYSTEM_NAME)
+        set(tbb_system_name ${tbb_IC_SYSTEM_NAME})
+    endif()
+
+    if (tbb_system_name STREQUAL "Linux")
+        set(TBB_LIB_PREFIX "lib")
+        set(TBB_LIB_EXT "so.2")
+        set(TBB_IMPLIB_RELEASE "")
+        set(TBB_IMPLIB_DEBUG "")
+    elseif (tbb_system_name STREQUAL "Darwin")
+        set(TBB_LIB_PREFIX "lib")
+        set(TBB_LIB_EXT "dylib")
+        set(TBB_IMPLIB_RELEASE "")
+        set(TBB_IMPLIB_DEBUG "")
+    elseif (tbb_system_name STREQUAL "Windows")
+        set(TBB_LIB_PREFIX "")
+        set(TBB_LIB_EXT "dll")
+        # .lib files installed to TBB_LIB_REL_PATH (e.g. <prefix>/lib);
+        # .dll files installed to TBB_BIN_REL_PATH (e.g. <prefix>/bin);
+        # Expand TBB_LIB_REL_PATH here in IMPORTED_IMPLIB property and
+        # redefine it with TBB_BIN_REL_PATH value to properly fill IMPORTED_LOCATION property in TBBConfig.cmake.in template.
+        set(TBB_IMPLIB_RELEASE "
+                                      IMPORTED_IMPLIB_RELEASE \"\${CMAKE_CURRENT_LIST_DIR}/${TBB_LIB_REL_PATH}/\${_tbb_component}.lib\"")
+        set(TBB_IMPLIB_DEBUG "
+                                      IMPORTED_IMPLIB_DEBUG \"\${CMAKE_CURRENT_LIST_DIR}/${TBB_LIB_REL_PATH}/\${_tbb_component}_debug.lib\"")
+        set(TBB_LIB_REL_PATH ${TBB_BIN_REL_PATH})
+    else()
+        message(FATAL_ERROR "Unsupported OS name: ${tbb_system_name}")
+    endif()
+
+    configure_file(${_tbb_cmake_module_path}/templates/TBBConfig.cmake.in ${config_install_dir}/TBBConfig.cmake @ONLY)
+    configure_file(${_tbb_cmake_module_path}/templates/TBBConfigVersion.cmake.in ${config_install_dir}/TBBConfigVersion.cmake @ONLY)
+endfunction()
diff --git a/src/tbb/cmake/TBBMakeConfig.cmake b/src/tbb/cmake/TBBMakeConfig.cmake
new file mode 100644
index 00000000..8c2c78be
--- /dev/null
+++ b/src/tbb/cmake/TBBMakeConfig.cmake
@@ -0,0 +1,164 @@
+# Copyright (c) 2017-2020 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.
+
+#
+# Usage:
+#   include(TBBMakeConfig.cmake)
+#   tbb_make_config(TBB_ROOT <tbb_root> SYSTEM_NAME <system_name> CONFIG_DIR <var_to_store_config_dir> [SAVE_TO] [CONFIG_FOR_SOURCE TBB_RELEASE_DIR <tbb_release_dir> TBB_DEBUG_DIR <tbb_debug_dir>])
+#
+
+include(CMakeParseArguments)
+
+# Save the location of Intel TBB CMake modules here, as it will not be possible to do inside functions,
+# see for details: https://cmake.org/cmake/help/latest/variable/CMAKE_CURRENT_LIST_DIR.html
+set(_tbb_cmake_module_path ${CMAKE_CURRENT_LIST_DIR})
+
+function(tbb_make_config)
+    set(oneValueArgs TBB_ROOT SYSTEM_NAME CONFIG_DIR SAVE_TO TBB_RELEASE_DIR TBB_DEBUG_DIR)
+    set(options CONFIG_FOR_SOURCE)
+    cmake_parse_arguments(tbb_MK "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+
+    set(tbb_system_name ${CMAKE_SYSTEM_NAME})
+    if (tbb_MK_SYSTEM_NAME)
+        set(tbb_system_name ${tbb_MK_SYSTEM_NAME})
+    endif()
+
+    set(tbb_config_dir ${tbb_MK_TBB_ROOT}/cmake)
+    if (tbb_MK_SAVE_TO)
+        set(tbb_config_dir ${tbb_MK_SAVE_TO})
+    endif()
+
+    file(MAKE_DIRECTORY ${tbb_config_dir})
+
+    set(TBB_DEFAULT_COMPONENTS tbb tbbmalloc tbbmalloc_proxy)
+
+    if (tbb_MK_CONFIG_FOR_SOURCE)
+        set(TBB_RELEASE_DIR ${tbb_MK_TBB_RELEASE_DIR})
+        set(TBB_DEBUG_DIR ${tbb_MK_TBB_DEBUG_DIR})
+    endif()
+
+    if (tbb_system_name STREQUAL "Linux")
+        set(TBB_SHARED_LIB_DIR "lib")
+        set(TBB_X32_SUBDIR "ia32")
+        set(TBB_X64_SUBDIR "intel64")
+        set(TBB_LIB_PREFIX "lib")
+        set(TBB_LIB_EXT "so.2")
+
+        # Note: multiline variable
+        set(TBB_CHOOSE_COMPILER_SUBDIR "set(_tbb_compiler_subdir gcc4.8)
+
+# For non-GCC compilers try to find version of system GCC to choose right compiler subdirectory.
+if (NOT CMAKE_CXX_COMPILER_ID STREQUAL \"GNU\" AND NOT CMAKE_C_COMPILER_ID STREQUAL \"GNU\")
+    find_program(_gcc_executable gcc)
+    if (NOT _gcc_executable)
+        message(FATAL_ERROR \"This Intel TBB package is intended to be used only in environment with available 'gcc'\")
+    endif()
+    unset(_gcc_executable)
+endif()")
+
+    elseif (tbb_system_name STREQUAL "Windows")
+        set(TBB_SHARED_LIB_DIR "bin")
+        set(TBB_X32_SUBDIR "ia32")
+        set(TBB_X64_SUBDIR "intel64")
+        set(TBB_LIB_PREFIX "")
+        set(TBB_LIB_EXT "dll")
+
+        # Note: multiline variable
+        set(TBB_CHOOSE_COMPILER_SUBDIR "if (NOT MSVC)
+    message(FATAL_ERROR \"This Intel TBB package is intended to be used only in the project with MSVC\")
+endif()
+
+if (MSVC_VERSION VERSION_LESS 1900)
+    message(FATAL_ERROR \"This Intel TBB package is intended to be used only in the project with MSVC version 1900 (vc14) or higher\")
+endif()
+
+set(_tbb_compiler_subdir vc14)
+
+if (WINDOWS_STORE)
+    set(_tbb_compiler_subdir \${_tbb_compiler_subdir}_uwp)
+endif()")
+
+        if (tbb_MK_CONFIG_FOR_SOURCE)
+            set(TBB_IMPLIB_RELEASE "
+                                  IMPORTED_IMPLIB_RELEASE \"${tbb_MK_TBB_RELEASE_DIR}/\${_tbb_component}.lib\"")
+            set(TBB_IMPLIB_DEBUG "
+                                  IMPORTED_IMPLIB_DEBUG \"${tbb_MK_TBB_DEBUG_DIR}/\${_tbb_component}_debug.lib\"")
+        else()
+            set(TBB_IMPLIB_RELEASE "
+                                  IMPORTED_IMPLIB_RELEASE \"\${_tbb_root}/lib/\${_tbb_arch_subdir}/\${_tbb_compiler_subdir}/\${_tbb_component}.lib\"")
+            set(TBB_IMPLIB_DEBUG "
+                                  IMPORTED_IMPLIB_DEBUG \"\${_tbb_root}/lib/\${_tbb_arch_subdir}/\${_tbb_compiler_subdir}/\${_tbb_component}_debug.lib\"")
+        endif()
+
+        # Note: multiline variable
+        # tbb/internal/_tbb_windef.h (included via tbb/tbb_stddef.h) does implicit linkage of some .lib files, use a special define to avoid it
+        set(TBB_COMPILE_DEFINITIONS "
+                              INTERFACE_COMPILE_DEFINITIONS \"__TBB_NO_IMPLICIT_LINKAGE=1\"")
+    elseif (tbb_system_name STREQUAL "Darwin")
+        set(TBB_SHARED_LIB_DIR "lib")
+        set(TBB_X32_SUBDIR ".")
+        set(TBB_X64_SUBDIR ".")
+        set(TBB_LIB_PREFIX "lib")
+        set(TBB_LIB_EXT "dylib")
+        set(TBB_CHOOSE_COMPILER_SUBDIR "set(_tbb_compiler_subdir .)")
+    elseif (tbb_system_name STREQUAL "Android")
+        set(TBB_SHARED_LIB_DIR "lib")
+        set(TBB_X32_SUBDIR ".")
+        set(TBB_X64_SUBDIR "x86_64")
+        set(TBB_LIB_PREFIX "lib")
+        set(TBB_LIB_EXT "so")
+        set(TBB_CHOOSE_COMPILER_SUBDIR "set(_tbb_compiler_subdir .)")
+    else()
+        message(FATAL_ERROR "Unsupported OS name: ${tbb_system_name}")
+    endif()
+
+    file(READ "${tbb_MK_TBB_ROOT}/include/tbb/tbb_stddef.h" _tbb_stddef)
+    string(REGEX REPLACE ".*#define TBB_VERSION_MAJOR ([0-9]+).*" "\\1" _tbb_ver_major "${_tbb_stddef}")
+    string(REGEX REPLACE ".*#define TBB_VERSION_MINOR ([0-9]+).*" "\\1" _tbb_ver_minor "${_tbb_stddef}")
+    string(REGEX REPLACE ".*#define TBB_INTERFACE_VERSION ([0-9]+).*" "\\1" TBB_INTERFACE_VERSION "${_tbb_stddef}")
+    set(TBB_VERSION "${_tbb_ver_major}.${_tbb_ver_minor}")
+
+    if (tbb_MK_CONFIG_FOR_SOURCE)
+        set(TBB_CHOOSE_ARCH_AND_COMPILER "")
+        set(TBB_RELEASE_LIB_PATH "${TBB_RELEASE_DIR}")
+        set(TBB_DEBUG_LIB_PATH "${TBB_DEBUG_DIR}")
+        set(TBB_UNSET_ADDITIONAL_VARIABLES "")
+    else()
+        # Note: multiline variable
+        set(TBB_CHOOSE_ARCH_AND_COMPILER "
+if (CMAKE_SIZEOF_VOID_P EQUAL 8)
+    set(_tbb_arch_subdir ${TBB_X64_SUBDIR})
+else()
+    set(_tbb_arch_subdir ${TBB_X32_SUBDIR})
+endif()
+
+${TBB_CHOOSE_COMPILER_SUBDIR}
+
+get_filename_component(_tbb_lib_path \"\${_tbb_root}/${TBB_SHARED_LIB_DIR}/\${_tbb_arch_subdir}/\${_tbb_compiler_subdir}\" ABSOLUTE)
+")
+
+    set(TBB_RELEASE_LIB_PATH "\${_tbb_lib_path}")
+    set(TBB_DEBUG_LIB_PATH "\${_tbb_lib_path}")
+
+    # Note: multiline variable
+    set(TBB_UNSET_ADDITIONAL_VARIABLES "
+unset(_tbb_arch_subdir)
+unset(_tbb_compiler_subdir)")
+    endif()
+
+    configure_file(${_tbb_cmake_module_path}/templates/TBBConfigInternal.cmake.in ${tbb_config_dir}/TBBConfig.cmake @ONLY)
+    configure_file(${_tbb_cmake_module_path}/templates/TBBConfigVersion.cmake.in ${tbb_config_dir}/TBBConfigVersion.cmake @ONLY)
+
+    set(${tbb_MK_CONFIG_DIR} ${tbb_config_dir} PARENT_SCOPE)
+endfunction()
diff --git a/src/tbb/cmake/tbb_config_generator.cmake b/src/tbb/cmake/tbb_config_generator.cmake
new file mode 100644
index 00000000..495fc45d
--- /dev/null
+++ b/src/tbb/cmake/tbb_config_generator.cmake
@@ -0,0 +1,41 @@
+# Copyright (c) 2017-2020 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.
+
+function(tbb_conf_gen_print_help)
+    message("Usage: cmake -DTBB_ROOT=<tbb_root> -DTBB_OS=Linux|Windows|Darwin [-DSAVE_TO=<path>] -P tbb_config_generator.cmake")
+endfunction()
+
+if (NOT DEFINED TBB_ROOT)
+    tbb_conf_gen_print_help()
+    message(FATAL_ERROR "Required parameter TBB_ROOT is not defined")
+endif()
+
+if (NOT EXISTS "${TBB_ROOT}")
+    tbb_conf_gen_print_help()
+    message(FATAL_ERROR "TBB_ROOT=${TBB_ROOT} does not exist")
+endif()
+
+if (NOT DEFINED TBB_OS)
+    tbb_conf_gen_print_help()
+    message(FATAL_ERROR "Required parameter TBB_OS is not defined")
+endif()
+
+if (DEFINED SAVE_TO)
+    set(tbb_conf_gen_save_to_param SAVE_TO ${SAVE_TO})
+endif()
+
+include(${CMAKE_CURRENT_LIST_DIR}/TBBMakeConfig.cmake)
+tbb_make_config(TBB_ROOT ${TBB_ROOT} CONFIG_DIR tbb_config_dir SYSTEM_NAME ${TBB_OS} ${tbb_conf_gen_save_to_param})
+
+message(STATUS "TBBConfig files were created in ${tbb_config_dir}")
diff --git a/src/tbb/cmake/tbb_config_installer.cmake b/src/tbb/cmake/tbb_config_installer.cmake
new file mode 100644
index 00000000..b1b2d444
--- /dev/null
+++ b/src/tbb/cmake/tbb_config_installer.cmake
@@ -0,0 +1,48 @@
+# Copyright (c) 2019-2020 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.
+
+function(tbb_conf_gen_print_help)
+    message("Usage: cmake -DINSTALL_DIR=<config_install_dir> -DSYSTEM_NAME=Linux|Darwin|Windows <parameters> -P tbb_config_generator.cmake
+
+Parameters:
+  For custom TBB package:
+    -DTBB_VERSION_FILE=<tbb_version_file>
+    -DTBB_VERSION=<major>.<minor>.<interface> (alternative to TBB_VERSION_FILE)
+    -DINC_REL_PATH=<relative_path_to_tbb_headers>
+    -DLIB_REL_PATH=<relative_path_to_tbb_libs>
+    -DBIN_REL_PATH=<relative_path_to_tbb_dlls> (only for Windows)
+  For installed TBB:
+    -DINC_PATH=<path_to_installed_tbb_headers>
+    -DLIB_PATH=<path_to_installed_tbb_libs>
+    -DBIN_PATH=<path_to_installed_tbb_dlls> (only for Windows)
+")
+endfunction()
+
+if (NOT DEFINED INSTALL_DIR)
+    tbb_conf_gen_print_help()
+    message(FATAL_ERROR "Required parameter INSTALL_DIR is not defined")
+endif()
+
+if (NOT DEFINED SYSTEM_NAME)
+    tbb_conf_gen_print_help()
+    message(FATAL_ERROR "Required parameter SYSTEM_NAME is not defined")
+endif()
+
+foreach (arg TBB_VERSION INC_REL_PATH LIB_REL_PATH BIN_REL_PATH TBB_VERSION_FILE INC_PATH LIB_PATH BIN_PATH)
+    set(optional_args ${optional_args} ${arg} ${${arg}})
+endforeach()
+
+include(${CMAKE_CURRENT_LIST_DIR}/TBBInstallConfig.cmake)
+tbb_install_config(INSTALL_DIR ${INSTALL_DIR} SYSTEM_NAME ${SYSTEM_NAME} ${optional_args})
+message(STATUS "TBBConfig files were created in ${INSTALL_DIR}")
diff --git a/src/tbb/cmake/templates/TBBConfig.cmake.in b/src/tbb/cmake/templates/TBBConfig.cmake.in
new file mode 100644
index 00000000..744f1215
--- /dev/null
+++ b/src/tbb/cmake/templates/TBBConfig.cmake.in
@@ -0,0 +1,98 @@
+# Copyright (c) 2017-2020 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()
+
+set(TBB_INTERFACE_VERSION @TBB_INTERFACE_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(FIND TBB_FIND_COMPONENTS tbbmalloc _tbbmalloc_ix)
+    if (_tbbmalloc_ix EQUAL -1)
+        list(APPEND TBB_FIND_COMPONENTS tbbmalloc)
+        set(TBB_FIND_REQUIRED_tbbmalloc ${TBB_FIND_REQUIRED_tbbmalloc_proxy})
+    endif()
+    unset(_tbbmalloc_ix)
+endif()
+unset(_tbbmalloc_proxy_ix)
+
+foreach (_tbb_component ${TBB_FIND_COMPONENTS})
+    set(TBB_${_tbb_component}_FOUND 0)
+
+    get_filename_component(_tbb_release_lib "${CMAKE_CURRENT_LIST_DIR}/@TBB_LIB_REL_PATH@/@TBB_LIB_PREFIX@${_tbb_component}.@TBB_LIB_EXT@" ABSOLUTE)
+
+    if (NOT TBB_FIND_RELEASE_ONLY)
+        get_filename_component(_tbb_debug_lib "${CMAKE_CURRENT_LIST_DIR}/@TBB_LIB_REL_PATH@/@TBB_LIB_PREFIX@${_tbb_component}_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_current_realpath "${CMAKE_CURRENT_LIST_DIR}" REALPATH)
+            get_filename_component(_tbb_include_dir "${_tbb_current_realpath}/@TBB_INC_REL_PATH@" ABSOLUTE)
+            set_target_properties(TBB::${_tbb_component} PROPERTIES
+                                  INTERFACE_INCLUDE_DIRECTORIES "${_tbb_include_dir}")
+            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 Intel TBB 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)
diff --git a/src/tbb/cmake/templates/TBBConfigInternal.cmake.in b/src/tbb/cmake/templates/TBBConfigInternal.cmake.in
new file mode 100644
index 00000000..ba161301
--- /dev/null
+++ b/src/tbb/cmake/templates/TBBConfigInternal.cmake.in
@@ -0,0 +1,98 @@
+# Copyright (c) 2017-2020 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_DEFAULT_COMPONENTS@")
+    foreach (_tbb_component ${TBB_FIND_COMPONENTS})
+        set(TBB_FIND_REQUIRED_${_tbb_component} 1)
+    endforeach()
+endif()
+
+# 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(FIND TBB_FIND_COMPONENTS tbbmalloc _tbbmalloc_ix)
+    if (_tbbmalloc_ix EQUAL -1)
+        list(APPEND TBB_FIND_COMPONENTS tbbmalloc)
+        set(TBB_FIND_REQUIRED_tbbmalloc ${TBB_FIND_REQUIRED_tbbmalloc_proxy})
+    endif()
+endif()
+
+set(TBB_INTERFACE_VERSION @TBB_INTERFACE_VERSION@)
+
+get_filename_component(_tbb_root "${CMAKE_CURRENT_LIST_FILE}" PATH)
+get_filename_component(_tbb_root "${_tbb_root}" PATH)
+@TBB_CHOOSE_ARCH_AND_COMPILER@
+foreach (_tbb_component ${TBB_FIND_COMPONENTS})
+    set(TBB_${_tbb_component}_FOUND 0)
+
+    set(_tbb_release_lib "@TBB_RELEASE_LIB_PATH@/@TBB_LIB_PREFIX@${_tbb_component}.@TBB_LIB_EXT@")
+
+    if (NOT TBB_FIND_RELEASE_ONLY)
+        set(_tbb_debug_lib "@TBB_DEBUG_LIB_PATH@/@TBB_LIB_PREFIX@${_tbb_component}_debug.@TBB_LIB_EXT@")
+    endif()
+
+    if (EXISTS "${_tbb_release_lib}" OR EXISTS "${_tbb_debug_lib}")
+        if (NOT TARGET TBB::${_tbb_component})
+            add_library(TBB::${_tbb_component} SHARED IMPORTED)
+            set_target_properties(TBB::${_tbb_component} PROPERTIES
+                                INTERFACE_INCLUDE_DIRECTORIES "${_tbb_root}/include"@TBB_COMPILE_DEFINITIONS@)
+
+            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 Intel TBB 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)
+@TBB_UNSET_ADDITIONAL_VARIABLES@
+unset(_tbbmalloc_proxy_ix)
+unset(_tbbmalloc_ix)
+unset(_tbb_lib_path)
+unset(_tbb_release_lib)
+unset(_tbb_debug_lib)
diff --git a/src/tbb/cmake/templates/TBBConfigVersion.cmake.in b/src/tbb/cmake/templates/TBBConfigVersion.cmake.in
new file mode 100644
index 00000000..c7b107b0
--- /dev/null
+++ b/src/tbb/cmake/templates/TBBConfigVersion.cmake.in
@@ -0,0 +1,24 @@
+# Copyright (c) 2017-2020 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()
diff --git a/src/tbb/doc/Release_Notes.txt b/src/tbb/doc/Release_Notes.txt
new file mode 100644
index 00000000..23b3f815
--- /dev/null
+++ b/src/tbb/doc/Release_Notes.txt
@@ -0,0 +1,132 @@
+------------------------------------------------------------------------
+Intel(R) Threading Building Blocks - Release Notes
+                   Version 2020
+------------------------------------------------------------------------
+
+Intel(R) Threading Building Blocks (Intel(R) TBB) is planned to be
+improved through renewal and update with latest C++ standards to increase
+usability. Evaluation of some Intel(R) TBB features removal will be
+conducted in some future releases. Features under consideration are mapped
+to updated options as described in the 'TBB Revamp: Background,Changes,
+and Modernization'
+(see https://software.intel.com/en-us/articles/tbb-revamp).
+
+System Requirements
+-------------------
+
+Intel(R) Threading Building Blocks is available commercially
+(see http://software.intel.com/en-us/intel-tbb) as a binary distribution,
+and in open source, in both source and binary forms
+(see https://github.com/intel/tbb).
+
+When built from source, Intel(R) TBB is intended to be highly portable
+and so supports a wide variety of operating systems and platforms (see
+http://threadingbuildingblocks.org for more details).
+
+Binary distributions, including commercial distributions, are validated
+and officially supported for the hardware, software, operating systems
+and compilers listed here.
+
+Hardware - Recommended
+
+    Microsoft* Windows* Systems
+        Intel(R) Core(TM) processor family
+        Intel(R) Xeon(R) processor family
+    Linux* Systems
+        Intel(R) Core(TM) processor family
+        Intel(R) Xeon(R) processor family
+    macOS* Systems
+        Intel(R) Core(TM) processor family
+    Android* Systems
+        Intel(R) Atom(TM) processor family
+
+Hardware - Supported
+
+    Intel(R) Pentium(R) processor family
+    Intel(R) Xeon Phi(TM) processor family
+    Intel(R) Atom(TM) processor family
+    Non Intel(R) processors compatible with the above processors
+
+Software - Minimum Requirements
+
+    Supported operating system (see below)
+    Supported compiler (see below)
+
+Software - Recommended
+
+    Intel(R) Parallel Studio XE 2019, 2020
+    Intel(R) System Studio 2019, 2020
+
+Software - Supported Operating Systems
+
+    Systems with Microsoft* Windows* operating systems
+        Microsoft* Windows* 10
+        Microsoft* Windows* Server 2016
+        Microsoft* Windows* Server 2019
+    Systems with Linux* operating systems
+        CentOS* 7.1
+        Debian* 9, 10
+        Fedora* 30
+        Intel(R) Cluster Ready
+        Red Hat* Enterprise Linux* 7, 8
+        SuSE* Linux* Enterprise Server 12,15
+        Ubuntu* 16.04 LTS, 18.04 LTS
+        Ubuntu* 19.04
+        WindRiver* Linux 9
+        Yocto* 2.3
+    Systems with OS X* or macOS* operating systems
+        macOS* 10.14, 10.15
+    Systems with Android* operating systems
+        Android* 6.x, 7.x, 8.x, 9.x
+
+Software - Supported Compilers
+
+    Intel(R) C++ Compiler 18, 19 and 19.1 version
+    Microsoft* Visual C++ 14.1 (Microsoft* Visual Studio* 2017,
+        Windows* OS only)
+    Microsoft* Visual C++ 14.2 (Microsoft* Visual Studio* 2019,
+        Windows* OS only)
+    Microsoft* Windows* Software Development Kit for Windows* 8.1
+    Microsoft* Windows* Software Development Kit for Windows* 10
+    For each supported Linux* operating system, the standard gcc
+        version provided with that operating system is supported
+            GNU Compilers (gcc) 4.8 - 9.1
+            GNU C Library (glibc) version 2.17 - 2.29
+    Clang* 3.8 - 8.0
+    Xcode* 8.x - 11.x
+    Android* NDK r10e - r17b
+
+Software - Supported Performance Analysis Tools
+
+    Intel(R) VTune(TM) Amplifier XE 2019, 2020
+    Intel(R) Inspector XE 2019, 2020
+    Intel(R) Advisor XE 2019, 2020
+
+Known Issues
+------------
+
+Below is the list of known issues in this release of
+Intel(R) Threading Building Blocks (Intel(R) TBB).
+See the "Known Issues" appendix in the Intel(R) TBB Developer
+Reference for notes applicable to multiple releases of Intel(R) TBB.
+
+Library Issues
+
+    - If you build Intel(R) TBB from sources with GCC 6 or higher,
+        specify the -flifetime-dse=1 option to prevent crashes at
+        runtime, or use Intel(R) TBB makefiles that automatically set
+        this option.
+
+------------------------------------------------------------------------
+(C) 2020 Intel Corporation
+
+Intel, the Intel logo, Intel Core, Intel Atom, Celeron, Xeon,
+Intel Xeon Phi and Pentium are trademarks of Intel Corporation
+in the U.S. and/or other countries
+
+* Other names and brands may be claimed as the property of others.
+
+Third Party and Open Source Licenses
+
+Content of some examples or binaries may be covered by various open-source
+licenses. See the index.html file in each respective folder for details.
diff --git a/src/tbb/doc/copyright_brand_disclaimer_doxygen.txt b/src/tbb/doc/copyright_brand_disclaimer_doxygen.txt
new file mode 100644
index 00000000..73780e34
--- /dev/null
+++ b/src/tbb/doc/copyright_brand_disclaimer_doxygen.txt
@@ -0,0 +1,9 @@
+<hr>
+<p></p>
+Copyright &copy; 2005-2020 Intel Corporation.  All Rights Reserved.
+<p></p>
+Intel, Pentium, Intel Xeon, Itanium, Intel XScale and VTune are
+registered trademarks or trademarks of Intel Corporation or its
+subsidiaries in the United States and other countries.
+<p></p>
+* Other names and brands may be claimed as the property of others.
diff --git a/src/tbb/include/index.html b/src/tbb/include/index.html
index b0962e01..c8698efb 100644
--- a/src/tbb/include/index.html
+++ b/src/tbb/include/index.html
@@ -15,7 +15,7 @@ <H2>Directories</H2>
 <HR>
 <A HREF="../index.html">Up to parent directory</A>
 <p></p>
-Copyright &copy; 2005-2017 Intel Corporation.  All Rights Reserved.
+Copyright &copy; 2005-2020 Intel Corporation.  All Rights Reserved.
 <P></P>
 Intel is a registered trademark or trademark of Intel Corporation
 or its subsidiaries in the United States and other countries.
diff --git a/src/tbb/include/serial/tbb/parallel_for.h b/src/tbb/include/serial/tbb/parallel_for.h
index 83ca9d57..4e6111b7 100644
--- a/src/tbb/include/serial/tbb/parallel_for.h
+++ b/src/tbb/include/serial/tbb/parallel_for.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,11 +12,18 @@
     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 "../../tbb/internal/_deprecated_header_message_guard.h"
 
+#if !defined(__TBB_show_deprecation_message_parallel_for_H) && defined(__TBB_show_deprecated_header_message)
+#define  __TBB_show_deprecation_message_parallel_for_H
+#pragma message("TBB Warning: serial/tbb/parallel_for.h is deprecated. For details, please see Deprecated Features appendix in the TBB reference manual.")
+#endif
 
-
-*/
+#if defined(__TBB_show_deprecated_header_message)
+#undef __TBB_show_deprecated_header_message
+#endif
 
 #ifndef __TBB_SERIAL_parallel_for_H
 #define __TBB_SERIAL_parallel_for_H
@@ -98,35 +105,35 @@ void start_for< Range, Body, Partitioner >::execute() {
 //! Parallel iteration over range with default partitioner.
 /** @ingroup algorithms **/
 template<typename Range, typename Body>
-void parallel_for( const Range& range, const Body& body ) {
+__TBB_DEPRECATED_IN_VERBOSE_MODE void parallel_for( const Range& range, const Body& body ) {
     serial::interface9::start_for<Range,Body,const __TBB_DEFAULT_PARTITIONER>::run(range,body,__TBB_DEFAULT_PARTITIONER());
 }
 
 //! Parallel iteration over range with simple partitioner.
 /** @ingroup algorithms **/
 template<typename Range, typename Body>
-void parallel_for( const Range& range, const Body& body, const simple_partitioner& partitioner ) {
+__TBB_DEPRECATED_IN_VERBOSE_MODE void parallel_for( const Range& range, const Body& body, const simple_partitioner& partitioner ) {
     serial::interface9::start_for<Range,Body,const simple_partitioner>::run(range,body,partitioner);
 }
 
 //! Parallel iteration over range with auto_partitioner.
 /** @ingroup algorithms **/
 template<typename Range, typename Body>
-void parallel_for( const Range& range, const Body& body, const auto_partitioner& partitioner ) {
+__TBB_DEPRECATED_IN_VERBOSE_MODE void parallel_for( const Range& range, const Body& body, const auto_partitioner& partitioner ) {
     serial::interface9::start_for<Range,Body,const auto_partitioner>::run(range,body,partitioner);
 }
 
 //! Parallel iteration over range with static_partitioner.
 /** @ingroup algorithms **/
 template<typename Range, typename Body>
-void parallel_for( const Range& range, const Body& body, const static_partitioner& partitioner ) {
+__TBB_DEPRECATED_IN_VERBOSE_MODE void parallel_for( const Range& range, const Body& body, const static_partitioner& partitioner ) {
     serial::interface9::start_for<Range,Body,const static_partitioner>::run(range,body,partitioner);
 }
 
 //! Parallel iteration over range with affinity_partitioner.
 /** @ingroup algorithms **/
 template<typename Range, typename Body>
-void parallel_for( const Range& range, const Body& body, affinity_partitioner& partitioner ) {
+__TBB_DEPRECATED_IN_VERBOSE_MODE void parallel_for( const Range& range, const Body& body, affinity_partitioner& partitioner ) {
     serial::interface9::start_for<Range,Body,affinity_partitioner>::run(range,body,partitioner);
 }
 
@@ -154,53 +161,53 @@ void parallel_for_impl(Index first, Index last, Index step, const Function& f, P
 
 //! Parallel iteration over a range of integers with explicit step and default partitioner
 template <typename Index, typename Function>
-void parallel_for(Index first, Index last, Index step, const Function& f) {
+__TBB_DEPRECATED_IN_VERBOSE_MODE void parallel_for(Index first, Index last, Index step, const Function& f) {
     parallel_for_impl<Index,Function,const auto_partitioner>(first, last, step, f, auto_partitioner());
 }
 //! Parallel iteration over a range of integers with explicit step and simple partitioner
 template <typename Index, typename Function>
-void parallel_for(Index first, Index last, Index step, const Function& f, const simple_partitioner& p) {
+__TBB_DEPRECATED_IN_VERBOSE_MODE void parallel_for(Index first, Index last, Index step, const Function& f, const simple_partitioner& p) {
     parallel_for_impl<Index,Function,const simple_partitioner>(first, last, step, f, p);
 }
 //! Parallel iteration over a range of integers with explicit step and auto partitioner
 template <typename Index, typename Function>
-void parallel_for(Index first, Index last, Index step, const Function& f, const auto_partitioner& p) {
+__TBB_DEPRECATED_IN_VERBOSE_MODE void parallel_for(Index first, Index last, Index step, const Function& f, const auto_partitioner& p) {
     parallel_for_impl<Index,Function,const auto_partitioner>(first, last, step, f, p);
 }
 //! Parallel iteration over a range of integers with explicit step and static partitioner
 template <typename Index, typename Function>
-void parallel_for(Index first, Index last, Index step, const Function& f, const static_partitioner& p) {
+__TBB_DEPRECATED_IN_VERBOSE_MODE void parallel_for(Index first, Index last, Index step, const Function& f, const static_partitioner& p) {
     parallel_for_impl<Index,Function,const static_partitioner>(first, last, step, f, p);
 }
 //! Parallel iteration over a range of integers with explicit step and affinity partitioner
 template <typename Index, typename Function>
-void parallel_for(Index first, Index last, Index step, const Function& f, affinity_partitioner& p) {
+__TBB_DEPRECATED_IN_VERBOSE_MODE void parallel_for(Index first, Index last, Index step, const Function& f, affinity_partitioner& p) {
     parallel_for_impl(first, last, step, f, p);
 }
 
 //! Parallel iteration over a range of integers with default step and default partitioner
 template <typename Index, typename Function>
-void parallel_for(Index first, Index last, const Function& f) {
+__TBB_DEPRECATED_IN_VERBOSE_MODE void parallel_for(Index first, Index last, const Function& f) {
     parallel_for_impl<Index,Function,const auto_partitioner>(first, last, static_cast<Index>(1), f, auto_partitioner());
 }
 //! Parallel iteration over a range of integers with default step and simple partitioner
 template <typename Index, typename Function>
-void parallel_for(Index first, Index last, const Function& f, const simple_partitioner& p) {
+__TBB_DEPRECATED_IN_VERBOSE_MODE void parallel_for(Index first, Index last, const Function& f, const simple_partitioner& p) {
     parallel_for_impl<Index,Function,const simple_partitioner>(first, last, static_cast<Index>(1), f, p);
 }
 //! Parallel iteration over a range of integers with default step and auto partitioner
 template <typename Index, typename Function>
-    void parallel_for(Index first, Index last, const Function& f, const auto_partitioner& p) {
+__TBB_DEPRECATED_IN_VERBOSE_MODE void parallel_for(Index first, Index last, const Function& f, const auto_partitioner& p) {
     parallel_for_impl<Index,Function,const auto_partitioner>(first, last, static_cast<Index>(1), f, p);
 }
 //! Parallel iteration over a range of integers with default step and static partitioner
 template <typename Index, typename Function>
-void parallel_for(Index first, Index last, const Function& f, const static_partitioner& p) {
+__TBB_DEPRECATED_IN_VERBOSE_MODE void parallel_for(Index first, Index last, const Function& f, const static_partitioner& p) {
     parallel_for_impl<Index,Function,const static_partitioner>(first, last, static_cast<Index>(1), f, p);
 }
 //! Parallel iteration over a range of integers with default step and affinity_partitioner
 template <typename Index, typename Function>
-void parallel_for(Index first, Index last, const Function& f, affinity_partitioner& p) {
+__TBB_DEPRECATED_IN_VERBOSE_MODE void parallel_for(Index first, Index last, const Function& f, affinity_partitioner& p) {
     parallel_for_impl(first, last, static_cast<Index>(1), f, p);
 }
 
diff --git a/src/tbb/include/serial/tbb/tbb_annotate.h b/src/tbb/include/serial/tbb/tbb_annotate.h
index 81c8d3a4..3e67e4c4 100644
--- a/src/tbb/include/serial/tbb/tbb_annotate.h
+++ b/src/tbb/include/serial/tbb/tbb_annotate.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_annotate_H
diff --git a/src/tbb/include/tbb/aggregator.h b/src/tbb/include/tbb/aggregator.h
index 6aecbb74..786c52c8 100644
--- a/src/tbb/include/tbb/aggregator.h
+++ b/src/tbb/include/tbb/aggregator.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,15 +12,14 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB__aggregator_H
 #define __TBB__aggregator_H
 
+#define __TBB_aggregator_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #if !TBB_PREVIEW_AGGREGATOR
 #error Set TBB_PREVIEW_AGGREGATOR before including aggregator.h
 #endif
@@ -199,4 +198,7 @@ using interface6::aggregator_operation;
 
 } // namespace tbb
 
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_aggregator_H_include_area
+
 #endif  // __TBB__aggregator_H
diff --git a/src/tbb/include/tbb/aligned_space.h b/src/tbb/include/tbb/aligned_space.h
index ee4d9e72..1b047f97 100644
--- a/src/tbb/include/tbb/aligned_space.h
+++ b/src/tbb/include/tbb/aligned_space.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,15 +12,25 @@
     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 "internal/_deprecated_header_message_guard.h"
 
+#if !defined(__TBB_show_deprecation_message_aligned_space_H) && defined(__TBB_show_deprecated_header_message)
+#define  __TBB_show_deprecation_message_aligned_space_H
+#pragma message("TBB Warning: tbb/aligned_space.h is deprecated. For details, please see Deprecated Features appendix in the TBB reference manual.")
+#endif
 
-
-*/
+#if defined(__TBB_show_deprecated_header_message)
+#undef __TBB_show_deprecated_header_message
+#endif
 
 #ifndef __TBB_aligned_space_H
 #define __TBB_aligned_space_H
 
+#define __TBB_aligned_space_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #include "tbb_stddef.h"
 #include "tbb_machine.h"
 
@@ -30,7 +40,7 @@ namespace tbb {
 /** The elements are not constructed or destroyed by this class.
     @ingroup memory_allocation */
 template<typename T,size_t N=1>
-class aligned_space {
+class __TBB_DEPRECATED_IN_VERBOSE_MODE_MSG("tbb::aligned_space is deprecated, use std::aligned_storage") aligned_space {
 private:
     typedef __TBB_TypeWithAlignmentAtLeastAsStrict(T) element_type;
     element_type array[(sizeof(T)*N+sizeof(element_type)-1)/sizeof(element_type)];
@@ -44,4 +54,7 @@ class aligned_space {
 
 } // namespace tbb
 
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_aligned_space_H_include_area
+
 #endif /* __TBB_aligned_space_H */
diff --git a/src/tbb/include/tbb/atomic.h b/src/tbb/include/tbb/atomic.h
index 72ec534e..e602306f 100644
--- a/src/tbb/include/tbb/atomic.h
+++ b/src/tbb/include/tbb/atomic.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,15 +12,25 @@
     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 "internal/_deprecated_header_message_guard.h"
 
+#if !defined(__TBB_show_deprecation_message_atomic_H) && defined(__TBB_show_deprecated_header_message)
+#define  __TBB_show_deprecation_message_atomic_H
+#pragma message("TBB Warning: tbb/atomic.h is deprecated. For details, please see Deprecated Features appendix in the TBB reference manual.")
+#endif
 
-
-*/
+#if defined(__TBB_show_deprecated_header_message)
+#undef __TBB_show_deprecated_header_message
+#endif
 
 #ifndef __TBB_atomic_H
 #define __TBB_atomic_H
 
+#define __TBB_atomic_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #include <cstddef>
 
 #if _MSC_VER
@@ -404,10 +414,12 @@ struct atomic_impl_with_arithmetic: atomic_impl<I> {
 /** See the Reference for details.
     @ingroup synchronization */
 template<typename T>
-struct atomic: internal::atomic_impl<T> {
+struct __TBB_DEPRECATED_IN_VERBOSE_MODE_MSG("tbb::atomic is deprecated, use std::atomic")
+atomic: internal::atomic_impl<T> {
 #if __TBB_ATOMIC_CTORS
     atomic() = default;
     constexpr atomic(T arg): internal::atomic_impl<T>(arg) {}
+    constexpr atomic<T>(const atomic<T>& rhs): internal::atomic_impl<T>(rhs) {}
 #endif
     T operator=( T rhs ) {
         // "this" required here in strict ISO C++ because store_with_release is a dependent name
@@ -418,16 +430,20 @@ struct atomic: internal::atomic_impl<T> {
 
 #if __TBB_ATOMIC_CTORS
     #define __TBB_DECL_ATOMIC(T)                                                                    \
-        template<> struct atomic<T>: internal::atomic_impl_with_arithmetic<T,T,char> {              \
+        template<> struct __TBB_DEPRECATED_IN_VERBOSE_MODE_MSG("tbb::atomic is deprecated, use std::atomic")  \
+        atomic<T>: internal::atomic_impl_with_arithmetic<T,T,char> {                                \
             atomic() = default;                                                                     \
             constexpr atomic(T arg): internal::atomic_impl_with_arithmetic<T,T,char>(arg) {}        \
+            constexpr atomic<T>(const atomic<T>& rhs):                                              \
+                      internal::atomic_impl_with_arithmetic<T,T,char>(rhs) {}                       \
                                                                                                     \
             T operator=( T rhs ) {return store_with_release(rhs);}                                  \
             atomic<T>& operator=( const atomic<T>& rhs ) {store_with_release(rhs); return *this;}   \
         };
 #else
     #define __TBB_DECL_ATOMIC(T)                                                                    \
-        template<> struct atomic<T>: internal::atomic_impl_with_arithmetic<T,T,char> {              \
+        template<> struct __TBB_DEPRECATED_IN_VERBOSE_MODE_MSG("tbb::atomic is deprecated, use std::atomic")  \
+        atomic<T>: internal::atomic_impl_with_arithmetic<T,T,char> {                                \
             T operator=( T rhs ) {return store_with_release(rhs);}                                  \
             atomic<T>& operator=( const atomic<T>& rhs ) {store_with_release(rhs); return *this;}   \
         };
@@ -451,15 +467,20 @@ __TBB_DECL_ATOMIC(unsigned long)
    type synonyms on the platform.  Type U should be the wider variant of T from the
    perspective of /Wp64. */
 #define __TBB_DECL_ATOMIC_ALT(T,U) \
-    template<> struct atomic<T>: internal::atomic_impl_with_arithmetic<T,T,char> {             \
+    template<> struct __TBB_DEPRECATED_IN_VERBOSE_MODE_MSG("tbb::atomic is deprecated, use std::atomic") \
+    atomic<T>: internal::atomic_impl_with_arithmetic<T,T,char> {                               \
         atomic() = default ;                                                                   \
         constexpr atomic(T arg): internal::atomic_impl_with_arithmetic<T,T,char>(arg) {}       \
+        constexpr atomic<T>(const atomic<T>& rhs):                                             \
+                  internal::atomic_impl_with_arithmetic<T,T,char>(rhs) {}                      \
+                                                                                               \
         T operator=( U rhs ) {return store_with_release(T(rhs));}                              \
         atomic<T>& operator=( const atomic<T>& rhs ) {store_with_release(rhs); return *this;}  \
     };
 #else
 #define __TBB_DECL_ATOMIC_ALT(T,U) \
-    template<> struct atomic<T>: internal::atomic_impl_with_arithmetic<T,T,char> {             \
+    template<> struct __TBB_DEPRECATED_IN_VERBOSE_MODE_MSG("tbb::atomic is deprecated, use std::atomic") \
+    atomic<T>: internal::atomic_impl_with_arithmetic<T,T,char> {                               \
         T operator=( U rhs ) {return store_with_release(T(rhs));}                              \
         atomic<T>& operator=( const atomic<T>& rhs ) {store_with_release(rhs); return *this;}  \
     };
@@ -482,10 +503,12 @@ __TBB_DECL_ATOMIC(wchar_t)
 #endif /* _MSC_VER||!defined(_NATIVE_WCHAR_T_DEFINED) */
 
 //! Specialization for atomic<T*> with arithmetic and operator->.
-template<typename T> struct atomic<T*>: internal::atomic_impl_with_arithmetic<T*,ptrdiff_t,T> {
+template<typename T> struct __TBB_DEPRECATED_IN_VERBOSE_MODE_MSG("tbb::atomic is deprecated, use std::atomic")
+atomic<T*>: internal::atomic_impl_with_arithmetic<T*,ptrdiff_t,T> {
 #if __TBB_ATOMIC_CTORS
     atomic() = default ;
     constexpr atomic(T* arg): internal::atomic_impl_with_arithmetic<T*,ptrdiff_t,T>(arg) {}
+    constexpr atomic(const atomic<T*>& rhs): internal::atomic_impl_with_arithmetic<T*,ptrdiff_t,T>(rhs) {}
 #endif
     T* operator=( T* rhs ) {
         // "this" required here in strict ISO C++ because store_with_release is a dependent name
@@ -500,10 +523,12 @@ template<typename T> struct atomic<T*>: internal::atomic_impl_with_arithmetic<T*
 };
 
 //! Specialization for atomic<void*>, for sake of not allowing arithmetic or operator->.
-template<> struct atomic<void*>: internal::atomic_impl<void*> {
+template<> struct __TBB_DEPRECATED_IN_VERBOSE_MODE_MSG("tbb::atomic is deprecated, use std::atomic")
+atomic<void*>: internal::atomic_impl<void*> {
 #if __TBB_ATOMIC_CTORS
     atomic() = default ;
     constexpr atomic(void* arg): internal::atomic_impl<void*>(arg) {}
+    constexpr atomic(const atomic<void*>& rhs): internal::atomic_impl<void*>(rhs) {}
 #endif
     void* operator=( void* rhs ) {
         // "this" required here in strict ISO C++ because store_with_release is a dependent name
@@ -555,4 +580,7 @@ inline atomic<T>& as_atomic( T& t ) {
     #pragma warning (pop)
 #endif // warnings are restored
 
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_atomic_H_include_area
+
 #endif /* __TBB_atomic_H */
diff --git a/src/tbb/include/tbb/blocked_range.h b/src/tbb/include/tbb/blocked_range.h
index 1f3901eb..b77e7e0a 100644
--- a/src/tbb/include/tbb/blocked_range.h
+++ b/src/tbb/include/tbb/blocked_range.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_blocked_range_H
@@ -25,6 +21,15 @@
 
 namespace tbb {
 
+namespace internal {
+
+// blocked_rangeNd_impl forward declaration in tbb::internal namespace to
+// name it as a friend for a tbb::blocked_range.
+template<typename Value, unsigned int N, typename>
+class blocked_rangeNd_impl;
+
+} // namespace internal
+
 /** \page range_req Requirements on range concept
     Class \c R implementing the concept of range must define:
     - \code R::R( const R& ); \endcode               Copy constructor
@@ -47,9 +52,11 @@ class blocked_range {
     //! Type for size of a range
     typedef std::size_t size_type;
 
+#if __TBB_DEPRECATED_BLOCKED_RANGE_DEFAULT_CTOR
     //! Construct range with default-constructed values for begin, end, and grainsize.
     /** Requires that Value have a default constructor. */
     blocked_range() : my_end(), my_begin(), my_grainsize() {}
+#endif
 
     //! Construct range over half-open interval [begin,end), with the given grainsize.
     blocked_range( Value begin_, Value end_, size_type grainsize_=1 ) :
@@ -151,6 +158,9 @@ class blocked_range {
 
     template<typename RowValue, typename ColValue, typename PageValue>
     friend class blocked_range3d;
+
+    template<typename DimValue, unsigned int N, typename>
+    friend class internal::blocked_rangeNd_impl;
 };
 
 } // namespace tbb
diff --git a/src/tbb/include/tbb/blocked_range2d.h b/src/tbb/include/tbb/blocked_range2d.h
index 1e3dfd17..2498e046 100644
--- a/src/tbb/include/tbb/blocked_range2d.h
+++ b/src/tbb/include/tbb/blocked_range2d.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_blocked_range2d_H
@@ -55,7 +51,7 @@ class blocked_range2d {
 
     //! True if range is empty
     bool empty() const {
-        // Yes, it is a logical OR here, not AND.
+        // Range is empty if at least one dimension is empty.
         return my_rows.empty() || my_cols.empty();
     }
 
diff --git a/src/tbb/include/tbb/blocked_range3d.h b/src/tbb/include/tbb/blocked_range3d.h
index 5f3b3c86..15f93130 100644
--- a/src/tbb/include/tbb/blocked_range3d.h
+++ b/src/tbb/include/tbb/blocked_range3d.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_blocked_range3d_H
@@ -61,7 +57,7 @@ class blocked_range3d {
 
     //! True if range is empty
     bool empty() const {
-        // Yes, it is a logical OR here, not AND.
+        // Range is empty if at least one dimension is empty.
         return my_pages.empty() || my_rows.empty() || my_cols.empty();
     }
 
diff --git a/src/tbb/include/tbb/blocked_rangeNd.h b/src/tbb/include/tbb/blocked_rangeNd.h
new file mode 100644
index 00000000..922c77c6
--- /dev/null
+++ b/src/tbb/include/tbb/blocked_rangeNd.h
@@ -0,0 +1,150 @@
+/*
+    Copyright (c) 2017-2020 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.
+*/
+
+#ifndef __TBB_blocked_rangeNd_H
+#define __TBB_blocked_rangeNd_H
+
+#if ! TBB_PREVIEW_BLOCKED_RANGE_ND
+    #error Set TBB_PREVIEW_BLOCKED_RANGE_ND to include blocked_rangeNd.h
+#endif
+
+#include "tbb_config.h"
+
+// tbb::blocked_rangeNd requires C++11 support
+#if __TBB_CPP11_PRESENT && __TBB_CPP11_ARRAY_PRESENT && __TBB_CPP11_TEMPLATE_ALIASES_PRESENT
+
+#include "internal/_template_helpers.h" // index_sequence, make_index_sequence
+
+#include <array>
+#include <algorithm>    // std::any_of
+#include <type_traits>  // std::is_same, std::enable_if
+
+#include "tbb/blocked_range.h"
+
+namespace tbb {
+namespace internal {
+
+/*
+    The blocked_rangeNd_impl uses make_index_sequence<N> to automatically generate a ctor with
+    exactly N arguments of the type tbb::blocked_range<Value>. Such ctor provides an opportunity
+    to use braced-init-list parameters to initialize each dimension.
+    Use of parameters, whose representation is a braced-init-list, but they're not
+    std::initializer_list or a reference to one, produces a non-deduced context
+    within template argument deduction.
+
+    NOTE: blocked_rangeNd must be exactly a templated alias to the blocked_rangeNd_impl
+    (and not e.g. a derived class), otherwise it would need to declare its own ctor
+    facing the same problem that the impl class solves.
+*/
+
+template<typename Value, unsigned int N, typename = make_index_sequence<N>>
+class blocked_rangeNd_impl;
+
+template<typename Value, unsigned int N, std::size_t... Is>
+class blocked_rangeNd_impl<Value, N, index_sequence<Is...>> {
+public:
+    //! Type of a value.
+    using value_type = Value;
+
+private:
+
+    //! Helper type to construct range with N tbb::blocked_range<value_type> objects.
+    template<std::size_t>
+    using dim_type_helper = tbb::blocked_range<value_type>;
+
+public:
+    blocked_rangeNd_impl() = delete;
+
+    //! Constructs N-dimensional range over N half-open intervals each represented as tbb::blocked_range<Value>.
+    blocked_rangeNd_impl(const dim_type_helper<Is>&... args) : my_dims{ {args...} } {}
+
+    //! Dimensionality of a range.
+    static constexpr unsigned int ndims() { return N; }
+
+    //! Range in certain dimension.
+    const tbb::blocked_range<value_type>& dim(unsigned int dimension) const {
+        __TBB_ASSERT(dimension < N, "out of bound");
+        return my_dims[dimension];
+    }
+
+    //------------------------------------------------------------------------
+    // Methods that implement Range concept
+    //------------------------------------------------------------------------
+
+    //! True if at least one dimension is empty.
+    bool empty() const {
+        return std::any_of(my_dims.begin(), my_dims.end(), [](const tbb::blocked_range<value_type>& d) {
+            return d.empty();
+        });
+    }
+
+    //! True if at least one dimension is divisible.
+    bool is_divisible() const {
+        return std::any_of(my_dims.begin(), my_dims.end(), [](const tbb::blocked_range<value_type>& d) {
+            return d.is_divisible();
+        });
+    }
+
+#if __TBB_USE_PROPORTIONAL_SPLIT_IN_BLOCKED_RANGES
+    //! Static field to support proportional split.
+    static const bool is_splittable_in_proportion = true;
+
+    blocked_rangeNd_impl(blocked_rangeNd_impl& r, proportional_split proportion) : my_dims(r.my_dims) {
+        do_split(r, proportion);
+    }
+#endif
+
+    blocked_rangeNd_impl(blocked_rangeNd_impl& r, split proportion) : my_dims(r.my_dims) {
+        do_split(r, proportion);
+    }
+
+private:
+    __TBB_STATIC_ASSERT(N != 0, "zero dimensional blocked_rangeNd can't be constructed");
+
+    //! Ranges in each dimension.
+    std::array<tbb::blocked_range<value_type>, N> my_dims;
+
+    template<typename split_type>
+    void do_split(blocked_rangeNd_impl& r, split_type proportion) {
+        __TBB_STATIC_ASSERT((is_same_type<split_type, split>::value
+                            || is_same_type<split_type, proportional_split>::value),
+                            "type of split object is incorrect");
+        __TBB_ASSERT(r.is_divisible(), "can't split not divisible range");
+
+        auto my_it = std::max_element(my_dims.begin(), my_dims.end(), [](const tbb::blocked_range<value_type>& first, const tbb::blocked_range<value_type>& second) {
+            return (first.size() * second.grainsize() < second.size() * first.grainsize());
+        });
+
+        auto r_it = r.my_dims.begin() + (my_it - my_dims.begin());
+
+        my_it->my_begin = tbb::blocked_range<value_type>::do_split(*r_it, proportion);
+
+        // (!(my_it->my_begin < r_it->my_end) && !(r_it->my_end < my_it->my_begin)) equals to
+        // (my_it->my_begin == r_it->my_end), but we can't use operator== due to Value concept
+        __TBB_ASSERT(!(my_it->my_begin < r_it->my_end) && !(r_it->my_end < my_it->my_begin),
+                     "blocked_range has been split incorrectly");
+    }
+};
+
+} // namespace internal
+
+template<typename Value, unsigned int N>
+using blocked_rangeNd = internal::blocked_rangeNd_impl<Value, N>;
+
+} // namespace tbb
+
+#endif /* __TBB_CPP11_PRESENT && __TBB_CPP11_ARRAY_PRESENT && __TBB_CPP11_TEMPLATE_ALIASES_PRESENT */
+#endif /* __TBB_blocked_rangeNd_H */
diff --git a/src/tbb/include/tbb/cache_aligned_allocator.h b/src/tbb/include/tbb/cache_aligned_allocator.h
index d435e785..5b4897c4 100644
--- a/src/tbb/include/tbb/cache_aligned_allocator.h
+++ b/src/tbb/include/tbb/cache_aligned_allocator.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_cache_aligned_allocator_H
@@ -24,7 +20,11 @@
 #include <new>
 #include "tbb_stddef.h"
 #if __TBB_ALLOCATOR_CONSTRUCT_VARIADIC
- #include <utility> // std::forward
+#include <utility> // std::forward
+#endif
+
+#if __TBB_CPP17_MEMORY_RESOURCE_PRESENT
+#include <memory_resource>
 #endif
 
 namespace tbb {
@@ -69,7 +69,6 @@ class cache_aligned_allocator {
     template<typename U> struct rebind {
         typedef cache_aligned_allocator<U> other;
     };
-
     cache_aligned_allocator() throw() {}
     cache_aligned_allocator( const cache_aligned_allocator& ) throw() {}
     template<typename U> cache_aligned_allocator(const cache_aligned_allocator<U>&) throw() {}
@@ -132,6 +131,79 @@ inline bool operator==( const cache_aligned_allocator<T>&, const cache_aligned_a
 template<typename T, typename U>
 inline bool operator!=( const cache_aligned_allocator<T>&, const cache_aligned_allocator<U>& ) {return false;}
 
+#if __TBB_CPP17_MEMORY_RESOURCE_PRESENT
+
+//! C++17 memory resource wrapper to ensure cache line size alignment
+class cache_aligned_resource : public std::pmr::memory_resource {
+public:
+    cache_aligned_resource() : cache_aligned_resource(std::pmr::get_default_resource()) {}
+    explicit cache_aligned_resource(std::pmr::memory_resource* upstream) : m_upstream(upstream) {}
+
+    std::pmr::memory_resource* upstream_resource() const {
+        return m_upstream;
+    }
+
+private:
+    //! We don't know what memory resource set. Use padding to guarantee alignment
+    void* do_allocate(size_t bytes, size_t alignment) override {
+        size_t cache_line_alignment = correct_alignment(alignment);
+        uintptr_t base = (uintptr_t)m_upstream->allocate(correct_size(bytes) + cache_line_alignment);
+        __TBB_ASSERT(base != 0, "Upstream resource returned NULL.");
+#if _MSC_VER && !defined(__INTEL_COMPILER)
+    // unary minus operator applied to unsigned type, result still unsigned
+    #pragma warning(push)
+    #pragma warning(disable: 4146 4706)
+#endif
+        // Round up to the next cache line (align the base address)
+        uintptr_t result = (base + cache_line_alignment) & -cache_line_alignment;
+#if _MSC_VER && !defined(__INTEL_COMPILER)
+    #pragma warning(pop)
+#endif
+        // Record where block actually starts.
+        ((uintptr_t*)result)[-1] = base;
+        return (void*)result;
+    }
+
+    void do_deallocate(void* ptr, size_t bytes, size_t alignment) override {
+        if (ptr) {
+            // Recover where block actually starts
+            uintptr_t base = ((uintptr_t*)ptr)[-1];
+            m_upstream->deallocate((void*)base, correct_size(bytes) + correct_alignment(alignment));
+        }
+    }
+
+    bool do_is_equal(const std::pmr::memory_resource& other) const noexcept override {
+        if (this == &other) { return true; }
+#if __TBB_USE_OPTIONAL_RTTI
+        const cache_aligned_resource* other_res = dynamic_cast<const cache_aligned_resource*>(&other);
+        return other_res && (this->upstream_resource() == other_res->upstream_resource());
+#else
+        return false;
+#endif
+    }
+
+    size_t correct_alignment(size_t alignment) {
+        __TBB_ASSERT(tbb::internal::is_power_of_two(alignment), "Alignment is not a power of 2");
+#if __TBB_CPP17_HW_INTERFERENCE_SIZE_PRESENT
+        size_t cache_line_size = std::hardware_destructive_interference_size;
+#else
+        size_t cache_line_size = internal::NFS_GetLineSize();
+#endif
+        return alignment < cache_line_size ? cache_line_size : alignment;
+    }
+
+    size_t correct_size(size_t bytes) {
+        // To handle the case, when small size requested. There could be not
+        // enough space to store the original pointer.
+        return bytes < sizeof(uintptr_t) ? sizeof(uintptr_t) : bytes;
+    }
+
+    std::pmr::memory_resource* m_upstream;
+};
+
+#endif /* __TBB_CPP17_MEMORY_RESOURCE_PRESENT */
+
 } // namespace tbb
 
 #endif /* __TBB_cache_aligned_allocator_H */
+
diff --git a/src/tbb/include/tbb/combinable.h b/src/tbb/include/tbb/combinable.h
index 0063dbb4..aa8d24b1 100644
--- a/src/tbb/include/tbb/combinable.h
+++ b/src/tbb/include/tbb/combinable.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,15 +12,14 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_combinable_H
 #define __TBB_combinable_H
 
+#define __TBB_combinable_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #include "enumerable_thread_specific.h"
 #include "cache_aligned_allocator.h"
 
@@ -82,4 +81,8 @@ namespace tbb {
 
     };
 } // namespace tbb
+
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_combinable_H_include_area
+
 #endif /* __TBB_combinable_H */
diff --git a/src/tbb/include/tbb/compat/condition_variable b/src/tbb/include/tbb/compat/condition_variable
index 43edfc03..a6967817 100644
--- a/src/tbb/include/tbb/compat/condition_variable
+++ b/src/tbb/include/tbb/compat/condition_variable
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,21 +12,31 @@
     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 "../internal/_deprecated_header_message_guard.h"
 
+#if !defined(__TBB_show_deprecation_message_condition_variable_H) && defined(__TBB_show_deprecated_header_message)
+#define  __TBB_show_deprecation_message_condition_variable_H
+#pragma message("TBB Warning: tbb/compat/condition_variable is deprecated. For details, please see Deprecated Features appendix in the TBB reference manual.")
+#endif
 
-
-*/
+#if defined(__TBB_show_deprecated_header_message)
+#undef __TBB_show_deprecated_header_message
+#endif
 
 #ifndef __TBB_condition_variable_H
 #define __TBB_condition_variable_H
 
+#define __TBB_condition_variable_H_include_area
+#include "../internal/_warning_suppress_enable_notice.h"
+
 #if _WIN32||_WIN64
 #include "../machine/windows_api.h"
 
-namespace tbb { 
+namespace tbb {
 namespace interface5 {
-namespace internal { 
+namespace internal {
 struct condition_variable_using_event
 {
     //! Event for blocking waiting threads.
@@ -69,17 +79,17 @@ namespace interface5 {
 
 // C++0x standard working draft 30.4.3
 // Lock tag types
-struct defer_lock_t { }; //! do not acquire ownership of the mutex
-struct try_to_lock_t { }; //! try to acquire ownership of the mutex without blocking
-struct adopt_lock_t { }; //! assume the calling thread has already
-const defer_lock_t defer_lock = {};
-const try_to_lock_t try_to_lock = {};
-const adopt_lock_t adopt_lock = {};
+struct __TBB_DEPRECATED_IN_VERBOSE_MODE defer_lock_t { }; //! do not acquire ownership of the mutex
+struct __TBB_DEPRECATED_IN_VERBOSE_MODE try_to_lock_t { }; //! try to acquire ownership of the mutex without blocking
+struct __TBB_DEPRECATED_IN_VERBOSE_MODE adopt_lock_t { }; //! assume the calling thread has already
+__TBB_DEPRECATED_IN_VERBOSE_MODE const defer_lock_t defer_lock = {};
+__TBB_DEPRECATED_IN_VERBOSE_MODE const try_to_lock_t try_to_lock = {};
+__TBB_DEPRECATED_IN_VERBOSE_MODE const adopt_lock_t adopt_lock = {};
 
 // C++0x standard working draft 30.4.3.1
-//! lock_guard 
+//! lock_guard
 template<typename M>
-class lock_guard : tbb::internal::no_copy {
+class __TBB_DEPRECATED_IN_VERBOSE_MODE lock_guard : tbb::internal::no_copy {
 public:
     //! mutex type
     typedef M mutex_type;
@@ -88,7 +98,7 @@ public:
     /** precondition: If mutex_type is not a recursive mutex, the calling thread
         does not own the mutex m. */
     explicit lock_guard(mutex_type& m) : pm(m) {m.lock();}
-    
+
     //! Adopt_lock constructor
     /** precondition: the calling thread owns the mutex m. */
     lock_guard(mutex_type& m, adopt_lock_t) : pm(m) {}
@@ -100,9 +110,9 @@ private:
 };
 
 // C++0x standard working draft 30.4.3.2
-//! unique_lock 
+//! unique_lock
 template<typename M>
-class unique_lock : tbb::internal::no_copy {
+class __TBB_DEPRECATED_IN_VERBOSE_MODE unique_lock : tbb::internal::no_copy {
     friend class condition_variable;
 public:
     typedef M mutex_type;
@@ -136,7 +146,7 @@ public:
     unique_lock(mutex_type& m, adopt_lock_t) : pm(&m), owns(true) {}
 
     //! Timed unique_lock acquisition.
-    /** To avoid requiring support for namespace chrono, this method deviates from the working draft in that 
+    /** To avoid requiring support for namespace chrono, this method deviates from the working draft in that
         it uses tbb::tick_count::interval_t to specify the time duration. */
     unique_lock(mutex_type& m, const tick_count::interval_t &i) : pm(&m) {owns = try_lock_for( i );}
 
@@ -169,14 +179,14 @@ public:
             if( !owns ) {
                 pm->lock();
                 owns = true;
-            } else 
+            } else
                 throw_exception_v4( tbb::internal::eid_possible_deadlock );
-        } else 
+        } else
             throw_exception_v4( tbb::internal::eid_operation_not_permitted );
         __TBB_ASSERT( owns, NULL );
     }
 
-    //! Try to lock the mutex. 
+    //! Try to lock the mutex.
     /** If successful, note that this lock owns it. Otherwise, set it false. */
     bool try_lock() {
         if( pm ) {
@@ -184,17 +194,17 @@ public:
                 owns = pm->try_lock();
             else
                 throw_exception_v4( tbb::internal::eid_possible_deadlock );
-        } else 
+        } else
             throw_exception_v4( tbb::internal::eid_operation_not_permitted );
         return owns;
     }
- 
-    //! Try to lock the mutex. 
+
+    //! Try to lock the mutex.
     bool try_lock_for( const tick_count::interval_t &i );
 
     //! Unlock the mutex
     /** And note that this lock no longer owns it. */
-    void unlock() { 
+    void unlock() {
         if( owns ) {
             pm->unlock();
             owns = false;
@@ -212,10 +222,10 @@ public:
 
     //! Release control over the mutex.
     mutex_type* release() {
-        mutex_type* o_pm = pm; 
-        pm = NULL; 
-        owns = false; 
-        return o_pm; 
+        mutex_type* o_pm = pm;
+        pm = NULL;
+        owns = false;
+        return o_pm;
     }
 
     // 30.4.3.2.4 observers
@@ -235,12 +245,12 @@ private:
 };
 
 template<typename M>
-bool unique_lock<M>::try_lock_for( const tick_count::interval_t &i)
-{ 
+__TBB_DEPRECATED_IN_VERBOSE_MODE bool unique_lock<M>::try_lock_for( const tick_count::interval_t &i)
+{
     const int unique_lock_tick = 100; /* microseconds; 0.1 milliseconds */
     // the smallest wait-time is 0.1 milliseconds.
     bool res = pm->try_lock();
-    int duration_in_micro; 
+    int duration_in_micro;
     if( !res && (duration_in_micro=int(i.seconds()*1e6))>unique_lock_tick ) {
         tick_count::interval_t i_100( double(unique_lock_tick)/1e6 /* seconds */); // 100 microseconds = 0.1*10E-3
         do {
@@ -252,7 +262,7 @@ bool unique_lock<M>::try_lock_for( const tick_count::interval_t &i)
     return (owns=res);
 }
 
-//! Swap the two unique locks that have the mutexes of same type 
+//! Swap the two unique locks that have the mutexes of same type
 template<typename M>
 void swap(unique_lock<M>& x, unique_lock<M>& y) { x.swap( y ); }
 
@@ -277,24 +287,24 @@ typedef pthread_cond_t condvar_impl_t;
 
 //! cv_status
 /** C++0x standard working draft 30.5 */
-enum cv_status { no_timeout, timeout }; 
+enum cv_status { no_timeout, timeout };
 
 //! condition variable
-/** C++0x standard working draft 30.5.1 
+/** C++0x standard working draft 30.5.1
     @ingroup synchronization */
-class condition_variable : tbb::internal::no_copy {
+class __TBB_DEPRECATED_IN_VERBOSE_MODE condition_variable : tbb::internal::no_copy {
 public:
     //! Constructor
-    condition_variable() { 
+    condition_variable() {
 #if _WIN32||_WIN64
-        internal_initialize_condition_variable( my_cv ); 
+        internal_initialize_condition_variable( my_cv );
 #else
         pthread_cond_init( &my_cv, NULL );
 #endif
     }
 
     //! Destructor
-    ~condition_variable() { 
+    ~condition_variable() {
         //precondition: There shall be no thread blocked on *this.
 #if _WIN32||_WIN64
         internal_destroy_condition_variable( my_cv );
@@ -304,18 +314,18 @@ public:
     }
 
     //! Notify one thread and wake it up
-    void notify_one() { 
+    void notify_one() {
 #if _WIN32||_WIN64
-        internal_condition_variable_notify_one( my_cv ); 
+        internal_condition_variable_notify_one( my_cv );
 #else
         pthread_cond_signal( &my_cv );
 #endif
     }
 
-    //! Notify all threads 
-    void notify_all() { 
+    //! Notify all threads
+    void notify_all() {
 #if _WIN32||_WIN64
-        internal_condition_variable_notify_all( my_cv ); 
+        internal_condition_variable_notify_all( my_cv );
 #else
         pthread_cond_broadcast( &my_cv );
 #endif
@@ -449,7 +459,7 @@ inline cv_status condition_variable::wait_for( unique_lock<mutex>& lock, const t
 
 __TBB_DEFINE_PROFILING_SET_NAME(interface5::condition_variable)
 
-} // namespace tbb 
+} // namespace tbb
 
 #if TBB_IMPLEMENT_CPP0X
 
@@ -469,8 +479,11 @@ using tbb::interface5::cv_status;
 using tbb::interface5::timeout;
 using tbb::interface5::no_timeout;
 
-} // namespace std 
+} // namespace std
 
 #endif /* TBB_IMPLEMENT_CPP0X */
 
+#include "../internal/_warning_suppress_disable_notice.h"
+#undef __TBB_condition_variable_H_include_area
+
 #endif /* __TBB_condition_variable_H */
diff --git a/src/tbb/include/tbb/compat/ppl.h b/src/tbb/include/tbb/compat/ppl.h
index 840dfb22..f441b038 100644
--- a/src/tbb/include/tbb/compat/ppl.h
+++ b/src/tbb/include/tbb/compat/ppl.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,15 +12,25 @@
     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 "../internal/_deprecated_header_message_guard.h"
 
+#if !defined(__TBB_show_deprecation_message_ppl_H) && defined(__TBB_show_deprecated_header_message)
+#define  __TBB_show_deprecation_message_ppl_H
+#pragma message("TBB Warning: tbb/compat/ppl.h is deprecated. For details, please see Deprecated Features appendix in the TBB reference manual.")
+#endif
 
-
-*/
+#if defined(__TBB_show_deprecated_header_message)
+#undef __TBB_show_deprecated_header_message
+#endif
 
 #ifndef __TBB_compat_ppl_H
 #define __TBB_compat_ppl_H
 
+#define __TBB_ppl_H_include_area
+#include "../internal/_warning_suppress_enable_notice.h"
+
 #include "../task_group.h"
 #include "../parallel_invoke.h"
 #include "../parallel_for_each.h"
@@ -59,4 +69,7 @@ namespace Concurrency {
 
 } // namespace Concurrency
 
+#include "../internal/_warning_suppress_disable_notice.h"
+#undef __TBB_ppl_H_include_area
+
 #endif /* __TBB_compat_ppl_H */
diff --git a/src/tbb/include/tbb/compat/thread b/src/tbb/include/tbb/compat/thread
index 0edd9289..8b8a13d7 100644
--- a/src/tbb/include/tbb/compat/thread
+++ b/src/tbb/include/tbb/compat/thread
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,15 +12,25 @@
     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 "../internal/_deprecated_header_message_guard.h"
 
+#if !defined(__TBB_show_deprecation_message_thread_H) && defined(__TBB_show_deprecated_header_message)
+#define  __TBB_show_deprecation_message_thread_H
+#pragma message("TBB Warning: tbb/compat/thread is deprecated. For details, please see Deprecated Features appendix in the TBB reference manual.")
+#endif
 
-
-*/
+#if defined(__TBB_show_deprecated_header_message)
+#undef __TBB_show_deprecated_header_message
+#endif
 
 #ifndef __TBB_thread_H
 #define __TBB_thread_H
 
+#define __TBB_thread_H_include_area
+#include "../internal/_warning_suppress_enable_notice.h"
+
 #include "../tbb_config.h"
 
 #if TBB_IMPLEMENT_CPP0X
@@ -35,7 +45,7 @@ namespace this_thread {
     using tbb::this_tbb_thread::get_id;
     using tbb::this_tbb_thread::yield;
 
-    inline void sleep_for(const tbb::tick_count::interval_t& rel_time) {
+    __TBB_DEPRECATED_IN_VERBOSE_MODE inline void sleep_for(const tbb::tick_count::interval_t& rel_time) {
         tbb::internal::thread_sleep_v3( rel_time );
     }
 }
@@ -50,6 +60,9 @@ namespace this_thread {
 
 #endif /* TBB_IMPLEMENT_CPP0X */
 
+#include "../internal/_warning_suppress_disable_notice.h"
+#undef __TBB_thread_H_include_area
+
 #else /* __TBB_thread_H */
 
 #if __TBB_COMPAT_THREAD_RECURSION_PROTECTOR
diff --git a/src/tbb/include/tbb/compat/tuple b/src/tbb/include/tbb/compat/tuple
index 5767c49e..c568ef3d 100644
--- a/src/tbb/include/tbb/compat/tuple
+++ b/src/tbb/include/tbb/compat/tuple
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,15 +12,25 @@
     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 "../internal/_deprecated_header_message_guard.h"
 
+#if !defined(__TBB_show_deprecation_message_tuple_H) && defined(__TBB_show_deprecated_header_message)
+#define  __TBB_show_deprecation_message_tuple_H
+#pragma message("TBB Warning: tbb/compat/tuple is deprecated. For details, please see Deprecated Features appendix in the TBB reference manual.")
+#endif
 
-
-*/
+#if defined(__TBB_show_deprecated_header_message)
+#undef __TBB_show_deprecated_header_message
+#endif
 
 #ifndef __TBB_tuple_H
 #define __TBB_tuple_H
 
+#define __TBB_tuple_H_include_area
+#include "../internal/_warning_suppress_enable_notice.h"
+
 #include <utility>
 #include "../tbb_stddef.h"
 
@@ -214,7 +224,7 @@ struct cons{
     typedef __HT head_type;
     typedef __TT tail_type;
 
-    head_type head; 
+    head_type head;
     tail_type tail;
 
     static const int length = 1 + tail_type::length;
@@ -276,12 +286,12 @@ struct cons{
 
 
 template <typename __HT>
-struct cons<__HT,null_type> { 
+struct cons<__HT,null_type> {
 
     typedef __HT head_type;
     typedef null_type tail_type;
 
-    head_type head; 
+    head_type head;
 
     static const int length = 1;
 
@@ -350,7 +360,7 @@ inline const __T wrap_dcons(__T*) { return __T(); }
 
 // tuple definition
 template<typename __T0, typename __T1, typename __T2, typename __T3, typename __T4 __TBB_TYPENAME_T_PACK >
-class tuple : public internal::tuple_traits<__T0, __T1, __T2, __T3, __T4 __TBB_T_PACK >::U {
+class __TBB_DEPRECATED_IN_VERBOSE_MODE tuple : public internal::tuple_traits<__T0, __T1, __T2, __T3, __T4 __TBB_T_PACK >::U {
     // friends
     template <typename __T> friend class tuple_size;
     template<int __N, typename __T> friend struct tuple_element;
@@ -366,7 +376,7 @@ class tuple : public internal::tuple_traits<__T0, __T1, __T2, __T3, __T4 __TBB_T
     typedef typename internal::tuple_traits<__T0,__T1,__T2,__T3, __T4 __TBB_T_PACK >::U my_cons;
 
 public:
-    tuple(const __T0& t0=internal::wrap_dcons((__T0*)NULL)
+    __TBB_DEPRECATED_IN_VERBOSE_MODE tuple(const __T0& t0=internal::wrap_dcons((__T0*)NULL)
           ,const __T1& t1=internal::wrap_dcons((__T1*)NULL)
           ,const __T2& t2=internal::wrap_dcons((__T2*)NULL)
           ,const __T3& t3=internal::wrap_dcons((__T3*)NULL)
@@ -425,7 +435,7 @@ public:
 
 // empty tuple
 template<>
-class tuple<null_type, null_type, null_type, null_type, null_type __TBB_NULL_TYPE_PACK > : public null_type {
+class __TBB_DEPRECATED_IN_VERBOSE_MODE tuple<null_type, null_type, null_type, null_type, null_type __TBB_NULL_TYPE_PACK > : public null_type {
 };
 
 // helper classes
@@ -437,7 +447,7 @@ public:
 };
 
 template <>
-class tuple_size<tuple<> > { 
+class tuple_size<tuple<> > {
 public:
     static const size_t value = 0;
 };
@@ -484,5 +494,8 @@ namespace tbb {
 #undef __TBB_CONST_REF_T_PARAM_PACK
 #undef __TBB_T_PARAM_LIST_PACK
 #undef __TBB_CONST_NULL_REF_PACK
- 
+
+#include "../internal/_warning_suppress_disable_notice.h"
+#undef __TBB_tuple_H_include_area
+
 #endif /* __TBB_tuple_H */
diff --git a/src/tbb/include/tbb/concurrent_hash_map.h b/src/tbb/include/tbb/concurrent_hash_map.h
index b25550a4..80bad97b 100644
--- a/src/tbb/include/tbb/concurrent_hash_map.h
+++ b/src/tbb/include/tbb/concurrent_hash_map.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,28 +12,29 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_concurrent_hash_map_H
 #define __TBB_concurrent_hash_map_H
 
+#define __TBB_concurrent_hash_map_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #include "tbb_stddef.h"
 #include <iterator>
 #include <utility>      // Need std::pair
 #include <cstring>      // Need std::memset
 #include __TBB_STD_SWAP_HEADER
 
-#include "cache_aligned_allocator.h"
 #include "tbb_allocator.h"
 #include "spin_rw_mutex.h"
 #include "atomic.h"
 #include "tbb_exception.h"
 #include "tbb_profiling.h"
+#include "aligned_space.h"
 #include "internal/_tbb_hash_compare_impl.h"
+#include "internal/_template_helpers.h"
+#include "internal/_allocator_traits.h"
 #if __TBB_INITIALIZER_LISTS_PRESENT
 #include <initializer_list>
 #endif
@@ -43,12 +44,17 @@
 #if __TBB_STATISTICS
 #include <stdio.h>
 #endif
+#if __TBB_CPP11_RVALUE_REF_PRESENT && __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT && __TBB_CPP11_TUPLE_PRESENT
+// Definition of __TBB_CPP11_RVALUE_REF_PRESENT includes __TBB_CPP11_TUPLE_PRESENT
+// for most of platforms, tuple present macro was added for logical correctness
+#include <tuple>
+#endif
 
 namespace tbb {
 
 namespace interface5 {
 
-    template<typename Key, typename T, typename HashCompare = tbb_hash_compare<Key>, typename A = tbb_allocator<std::pair<Key, T> > >
+    template<typename Key, typename T, typename HashCompare = tbb_hash_compare<Key>, typename A = tbb_allocator<std::pair<const Key, T> > >
     class concurrent_hash_map;
 
     //! @cond INTERNAL
@@ -119,9 +125,10 @@ namespace interface5 {
 #endif
         //! Constructor
         hash_map_base() {
-            std::memset( (void*) this, 0, pointers_per_table*sizeof(segment_ptr_t) // 32*4=128   or 64*8=512
-                + sizeof(my_size) + sizeof(my_mask)  // 4+4 or 8+8
-                + embedded_buckets*sizeof(bucket) ); // n*8 or n*16
+            std::memset(my_table, 0, sizeof(my_table));
+            my_mask = 0;
+            my_size = 0;
+            std::memset(my_embedded_segment, 0, sizeof(my_embedded_segment));
             for( size_type i = 0; i < embedded_block; i++ ) // fill the table
                 my_table[i] = my_embedded_segment + segment_base(i);
             my_mask = embedded_buckets - 1;
@@ -155,7 +162,7 @@ namespace interface5 {
 
         //! Initialize buckets
         static void init_buckets( segment_ptr_t ptr, size_type sz, bool is_initial ) {
-            if( is_initial ) std::memset((void*) ptr, 0, sz*sizeof(bucket) );
+            if( is_initial ) std::memset( static_cast<void*>(ptr), 0, sz*sizeof(bucket) );
             else for(size_type i = 0; i < sz; i++, ptr++) {
                 *reinterpret_cast<intptr_t*>(&ptr->mutex) = 0;
                 ptr->node_list = rehash_req;
@@ -179,22 +186,25 @@ namespace interface5 {
         };
 
         //! Enable segment
-        void enable_segment( segment_index_t k, bool is_initial = false ) {
+        template<typename Allocator>
+        void enable_segment( segment_index_t k, const Allocator& allocator, bool is_initial = false ) {
+            typedef typename tbb::internal::allocator_rebind<Allocator, bucket>::type bucket_allocator_type;
+            typedef tbb::internal::allocator_traits<bucket_allocator_type> bucket_allocator_traits;
+            bucket_allocator_type bucket_allocator(allocator);
             __TBB_ASSERT( k, "Zero segment must be embedded" );
             enable_segment_failsafe watchdog( my_table, k );
-            cache_aligned_allocator<bucket> alloc;
             size_type sz;
             __TBB_ASSERT( !is_valid(my_table[k]), "Wrong concurrent assignment");
             if( k >= first_block ) {
                 sz = segment_size( k );
-                segment_ptr_t ptr = alloc.allocate( sz );
+                segment_ptr_t ptr = bucket_allocator_traits::allocate(bucket_allocator, sz);
                 init_buckets( ptr, sz, is_initial );
                 itt_hide_store_word( my_table[k], ptr );
                 sz <<= 1;// double it to get entire capacity of the container
             } else { // the first block
                 __TBB_ASSERT( k == embedded_block, "Wrong segment index" );
                 sz = segment_size( first_block );
-                segment_ptr_t ptr = alloc.allocate( sz - embedded_buckets );
+                segment_ptr_t ptr = bucket_allocator_traits::allocate(bucket_allocator, sz - embedded_buckets);
                 init_buckets( ptr, sz - embedded_buckets, is_initial );
                 ptr -= segment_base(embedded_block);
                 for(segment_index_t i = embedded_block; i < first_block; i++) // calc the offsets
@@ -204,6 +214,22 @@ namespace interface5 {
             watchdog.my_segment_ptr = 0;
         }
 
+        template<typename Allocator>
+        void delete_segment(segment_index_t s, const Allocator& allocator) {
+            typedef typename tbb::internal::allocator_rebind<Allocator, bucket>::type bucket_allocator_type;
+            typedef tbb::internal::allocator_traits<bucket_allocator_type> bucket_allocator_traits;
+            bucket_allocator_type bucket_allocator(allocator);
+            segment_ptr_t buckets_ptr = my_table[s];
+            size_type sz = segment_size( s ? s : 1 );
+
+            if( s >= first_block) // the first segment or the next
+                bucket_allocator_traits::deallocate(bucket_allocator, buckets_ptr, sz);
+            else if( s == embedded_block && embedded_block != first_block )
+                bucket_allocator_traits::deallocate(bucket_allocator, buckets_ptr,
+                                                    segment_size(first_block) - embedded_buckets);
+            if( s >= embedded_block ) my_table[s] = 0;
+        }
+
         //! Get bucket by (masked) hashcode
         bucket *get_bucket( hashcode_t h ) const throw() { // TODO: add throw() everywhere?
             segment_index_t s = segment_index_of( h );
@@ -272,11 +298,12 @@ namespace interface5 {
         }
 
         //! Prepare enough segments for number of buckets
-        void reserve(size_type buckets) {
+        template<typename Allocator>
+        void reserve(size_type buckets, const Allocator& allocator) {
             if( !buckets-- ) return;
             bool is_initial = !my_size;
             for( size_type m = my_mask; buckets > m; m = my_mask )
-                enable_segment( segment_index_of( m+1 ), is_initial );
+                enable_segment( segment_index_of( m+1 ), allocator, is_initial );
         }
         //! Swap hash_map_bases
         void internal_swap(hash_map_base &table) {
@@ -288,6 +315,25 @@ namespace interface5 {
             for(size_type i = embedded_block; i < pointers_per_table; i++)
                 swap(this->my_table[i], table.my_table[i]);
         }
+
+#if __TBB_CPP11_RVALUE_REF_PRESENT
+        void internal_move(hash_map_base&& other) {
+            my_mask = other.my_mask;
+            other.my_mask = embedded_buckets - 1;
+            my_size = other.my_size;
+            other.my_size = 0;
+
+            for(size_type i = 0; i < embedded_buckets; ++i) {
+                my_embedded_segment[i].node_list = other.my_embedded_segment[i].node_list;
+                other.my_embedded_segment[i].node_list = NULL;
+            }
+
+            for(size_type i = embedded_block; i < pointers_per_table; ++i) {
+                my_table[i] = other.my_table[i];
+                other.my_table[i] = NULL;
+            }
+        }
+#endif // __TBB_CPP11_RVALUE_REF_PRESENT
     };
 
     template<typename Iterator>
@@ -365,9 +411,17 @@ namespace interface5 {
             my_bucket(other.my_bucket),
             my_node(other.my_node)
         {}
+
+        hash_map_iterator& operator=( const hash_map_iterator<Container,typename Container::value_type> &other ) {
+            my_map = other.my_map;
+            my_index = other.my_index;
+            my_bucket = other.my_bucket;
+            my_node = other.my_node;
+            return *this;
+        }
         Value& operator*() const {
             __TBB_ASSERT( hash_map_base::is_valid(my_node), "iterator uninitialized or at end of container?" );
-            return my_node->item;
+            return my_node->value();
         }
         Value* operator->() const {return &operator*();}
         hash_map_iterator& operator++();
@@ -553,62 +607,80 @@ class concurrent_hash_map : protected internal::hash_map_base {
 
 protected:
     friend class const_accessor;
-    struct node;
-    typedef typename Allocator::template rebind<node>::other node_allocator_type;
+    class node;
+    typedef typename tbb::internal::allocator_rebind<Allocator, node>::type node_allocator_type;
+    typedef tbb::internal::allocator_traits<node_allocator_type> node_allocator_traits;
     node_allocator_type my_allocator;
     HashCompare my_hash_compare;
 
-    struct node : public node_base {
-        value_type item;
-        node( const Key &key ) : item(key, T()) {}
-        node( const Key &key, const T &t ) : item(key, t) {}
-#if __TBB_CPP11_RVALUE_REF_PRESENT
-        node( const Key &key, T &&t ) : item(key, std::move(t)) {}
-        node( value_type&& i ) : item(std::move(i)){}
-#if __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT
-        template<typename... Args>
-        node( Args&&... args ) : item(std::forward<Args>(args)...) {}
-#if __TBB_COPY_FROM_NON_CONST_REF_BROKEN
-        node( value_type& i ) : item(const_cast<const value_type&>(i)) {}
-#endif //__TBB_COPY_FROM_NON_CONST_REF_BROKEN
-#endif //__TBB_CPP11_VARIADIC_TEMPLATES_PRESENT
-#endif //__TBB_CPP11_RVALUE_REF_PRESENT
-        node( const value_type& i ) : item(i) {}
-
-        // exception-safe allocation, see C++ Standard 2003, clause 5.3.4p17
-        void *operator new( size_t /*size*/, node_allocator_type &a ) {
-            void *ptr = a.allocate(1);
-            if(!ptr)
-                tbb::internal::throw_exception(tbb::internal::eid_bad_alloc);
-            return ptr;
-        }
-        // match placement-new form above to be called if exception thrown in constructor
-        void operator delete( void *ptr, node_allocator_type &a ) { a.deallocate(static_cast<node*>(ptr),1); }
+    class node : public node_base {
+        tbb::aligned_space<value_type> my_value;
+    public:
+        value_type* storage() { return my_value.begin(); }
+        value_type& value() { return *storage(); }
     };
 
     void delete_node( node_base *n ) {
-        my_allocator.destroy( static_cast<node*>(n) );
-        my_allocator.deallocate( static_cast<node*>(n), 1);
+        node_allocator_traits::destroy(my_allocator, static_cast<node*>(n)->storage());
+        node_allocator_traits::destroy(my_allocator, static_cast<node*>(n));
+        node_allocator_traits::deallocate(my_allocator, static_cast<node*>(n), 1);
+    }
+
+    struct node_scoped_guard : tbb::internal::no_copy {
+        node* my_node;
+        node_allocator_type& my_alloc;
+
+        node_scoped_guard(node* n, node_allocator_type& alloc) : my_node(n), my_alloc(alloc) {}
+        ~node_scoped_guard() {
+            if(my_node) {
+                node_allocator_traits::destroy(my_alloc, my_node);
+                node_allocator_traits::deallocate(my_alloc, my_node, 1);
+            }
+        }
+        void dismiss() { my_node = NULL; }
+    };
+
+#if __TBB_CPP11_RVALUE_REF_PRESENT && __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT
+    template<typename... Args>
+    static node* create_node(node_allocator_type& allocator, Args&&... args)
+#else
+    template<typename Arg1, typename Arg2>
+    static node* create_node(node_allocator_type& allocator, __TBB_FORWARDING_REF(Arg1) arg1, __TBB_FORWARDING_REF(Arg2) arg2)
+#endif
+    {
+        node* node_ptr = node_allocator_traits::allocate(allocator, 1);
+        node_scoped_guard guard(node_ptr, allocator);
+        node_allocator_traits::construct(allocator, node_ptr);
+#if __TBB_CPP11_RVALUE_REF_PRESENT && __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT
+        node_allocator_traits::construct(allocator, node_ptr->storage(), std::forward<Args>(args)...);
+#else
+        node_allocator_traits::construct(allocator, node_ptr->storage(), tbb::internal::forward<Arg1>(arg1), tbb::internal::forward<Arg2>(arg2));
+#endif
+        guard.dismiss();
+        return node_ptr;
     }
 
     static node* allocate_node_copy_construct(node_allocator_type& allocator, const Key &key, const T * t){
-        return  new( allocator ) node(key, *t);
+        return create_node(allocator, key, *t);
     }
 
 #if __TBB_CPP11_RVALUE_REF_PRESENT
     static node* allocate_node_move_construct(node_allocator_type& allocator, const Key &key, const T * t){
-        return  new( allocator ) node(key, std::move(*const_cast<T*>(t)));
-    }
-#if __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT
-    template<typename... Args>
-    static node* allocate_node_emplace_construct(node_allocator_type& allocator, Args&&... args){
-        return  new( allocator ) node(std::forward<Args>(args)...);
+        return create_node(allocator, key, std::move(*const_cast<T*>(t)));
     }
-#endif //#if __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT
 #endif
 
     static node* allocate_node_default_construct(node_allocator_type& allocator, const Key &key, const T * ){
-        return  new( allocator ) node(key);
+#if __TBB_CPP11_RVALUE_REF_PRESENT && __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT && __TBB_CPP11_TUPLE_PRESENT
+        // Emplace construct an empty T object inside the pair
+        return create_node(allocator, std::piecewise_construct,
+                           std::forward_as_tuple(key), std::forward_as_tuple());
+#else
+        // Use of a temporary object is impossible, because create_node takes a non-const reference.
+        // copy-initialization is possible because T is already required to be CopyConstructible.
+        T obj = T();
+        return create_node(allocator, key, tbb::internal::move(obj));
+#endif
     }
 
     static node* do_not_allocate_node(node_allocator_type& , const Key &, const T * ){
@@ -618,7 +690,7 @@ class concurrent_hash_map : protected internal::hash_map_base {
 
     node *search_bucket( const key_type &key, bucket *b ) const {
         node *n = static_cast<node*>( b->node_list );
-        while( is_valid(n) && !my_hash_compare.equal(key, n->item.first) )
+        while( is_valid(n) && !my_hash_compare.equal(key, n->value().first) )
             n = static_cast<node*>( n->next );
         __TBB_ASSERT(n != internal::rehash_req, "Search can be executed only for rehashed bucket");
         return n;
@@ -663,7 +735,7 @@ class concurrent_hash_map : protected internal::hash_map_base {
         __TBB_ASSERT( (mask&(mask+1))==0 && (h & mask) == h, NULL );
     restart:
         for( node_base **p = &b_old()->node_list, *n = __TBB_load_with_acquire(*p); is_valid(n); n = *p ) {
-            hashcode_t c = my_hash_compare.hash( static_cast<node*>(n)->item.first );
+            hashcode_t c = my_hash_compare.hash( static_cast<node*>(n)->value().first );
 #if TBB_USE_ASSERT
             hashcode_t bmask = h & (mask>>1);
             bmask = bmask==0? 1 : ( 1u<<(__TBB_Log2( bmask )+1 ) ) - 1; // minimal mask of parent bucket
@@ -715,7 +787,7 @@ class concurrent_hash_map : protected internal::hash_map_base {
         //! Return reference to associated value in hash table.
         const_reference operator*() const {
             __TBB_ASSERT( my_node, "attempt to dereference empty accessor" );
-            return my_node->item;
+            return my_node->value();
         }
 
         //! Return pointer to associated value in hash table.
@@ -745,7 +817,7 @@ class concurrent_hash_map : protected internal::hash_map_base {
         //! Return reference to associated value in hash table.
         reference operator*() const {
             __TBB_ASSERT( this->my_node, "attempt to dereference empty accessor" );
-            return this->my_node->item;
+            return this->my_node->value();
         }
 
         //! Return pointer to associated value in hash table.
@@ -759,18 +831,39 @@ class concurrent_hash_map : protected internal::hash_map_base {
         : internal::hash_map_base(), my_allocator(a)
     {}
 
+    explicit concurrent_hash_map( const HashCompare& compare, const allocator_type& a = allocator_type() )
+        : internal::hash_map_base(), my_allocator(a), my_hash_compare(compare)
+    {}
+
     //! Construct empty table with n preallocated buckets. This number serves also as initial concurrency level.
     concurrent_hash_map( size_type n, const allocator_type &a = allocator_type() )
-        : my_allocator(a)
+        : internal::hash_map_base(), my_allocator(a)
     {
-        reserve( n );
+        reserve( n, my_allocator );
+    }
+
+    concurrent_hash_map( size_type n, const HashCompare& compare, const allocator_type& a = allocator_type() )
+        : internal::hash_map_base(), my_allocator(a), my_hash_compare(compare)
+    {
+        reserve( n, my_allocator );
     }
 
     //! Copy constructor
-    concurrent_hash_map( const concurrent_hash_map &table, const allocator_type &a = allocator_type() )
+    concurrent_hash_map( const concurrent_hash_map &table )
+        : internal::hash_map_base(),
+          my_allocator(node_allocator_traits::select_on_container_copy_construction(table.get_allocator()))
+    {
+        call_clear_on_leave scope_guard(this);
+        internal_copy(table);
+        scope_guard.dismiss();
+    }
+
+    concurrent_hash_map( const concurrent_hash_map &table, const allocator_type &a)
         : internal::hash_map_base(), my_allocator(a)
     {
+        call_clear_on_leave scope_guard(this);
         internal_copy(table);
+        scope_guard.dismiss();
     }
 
 #if __TBB_CPP11_RVALUE_REF_PRESENT
@@ -778,7 +871,7 @@ class concurrent_hash_map : protected internal::hash_map_base {
     concurrent_hash_map( concurrent_hash_map &&table )
         : internal::hash_map_base(), my_allocator(std::move(table.get_allocator()))
     {
-        swap(table);
+        internal_move(std::move(table));
     }
 
     //! Move constructor
@@ -786,10 +879,10 @@ class concurrent_hash_map : protected internal::hash_map_base {
         : internal::hash_map_base(), my_allocator(a)
     {
         if (a == table.get_allocator()){
-            this->swap(table);
+            internal_move(std::move(table));
         }else{
             call_clear_on_leave scope_guard(this);
-            internal_copy(std::make_move_iterator(table.begin()), std::make_move_iterator(table.end()));
+            internal_copy(std::make_move_iterator(table.begin()), std::make_move_iterator(table.end()), table.size());
             scope_guard.dismiss();
         }
     }
@@ -798,19 +891,38 @@ class concurrent_hash_map : protected internal::hash_map_base {
     //! Construction with copying iteration range and given allocator instance
     template<typename I>
     concurrent_hash_map( I first, I last, const allocator_type &a = allocator_type() )
-        : my_allocator(a)
+        : internal::hash_map_base(), my_allocator(a)
     {
-        reserve( std::distance(first, last) ); // TODO: load_factor?
-        internal_copy(first, last);
+        call_clear_on_leave scope_guard(this);
+        internal_copy(first, last, std::distance(first, last));
+        scope_guard.dismiss();
+    }
+
+    template<typename I>
+    concurrent_hash_map( I first, I last, const HashCompare& compare, const allocator_type& a = allocator_type() )
+        : internal::hash_map_base(), my_allocator(a), my_hash_compare(compare)
+    {
+        call_clear_on_leave scope_guard(this);
+        internal_copy(first, last, std::distance(first, last));
+        scope_guard.dismiss();
     }
 
 #if __TBB_INITIALIZER_LISTS_PRESENT
     //! Construct empty table with n preallocated buckets. This number serves also as initial concurrency level.
     concurrent_hash_map( std::initializer_list<value_type> il, const allocator_type &a = allocator_type() )
-        : my_allocator(a)
+        : internal::hash_map_base(), my_allocator(a)
     {
-        reserve(il.size());
-        internal_copy(il.begin(), il.end());
+        call_clear_on_leave scope_guard(this);
+        internal_copy(il.begin(), il.end(), il.size());
+        scope_guard.dismiss();
+    }
+
+    concurrent_hash_map( std::initializer_list<value_type> il, const HashCompare& compare, const allocator_type& a = allocator_type() )
+        : internal::hash_map_base(), my_allocator(a), my_hash_compare(compare)
+    {
+        call_clear_on_leave scope_guard(this);
+        internal_copy(il.begin(), il.end(), il.size());
+        scope_guard.dismiss();
     }
 
 #endif //__TBB_INITIALIZER_LISTS_PRESENT
@@ -818,7 +930,9 @@ class concurrent_hash_map : protected internal::hash_map_base {
     //! Assignment
     concurrent_hash_map& operator=( const concurrent_hash_map &table ) {
         if( this!=&table ) {
+            typedef typename node_allocator_traits::propagate_on_container_copy_assignment pocca_type;
             clear();
+            tbb::internal::allocator_copy_assignment(my_allocator, table.my_allocator, pocca_type());
             internal_copy(table);
         }
         return *this;
@@ -827,17 +941,9 @@ class concurrent_hash_map : protected internal::hash_map_base {
 #if __TBB_CPP11_RVALUE_REF_PRESENT
     //! Move Assignment
     concurrent_hash_map& operator=( concurrent_hash_map &&table ) {
-        if(this != &table){
-            typedef typename tbb::internal::allocator_traits<allocator_type>::propagate_on_container_move_assignment pocma_t;
-            if(pocma_t::value || this->my_allocator == table.my_allocator) {
-                concurrent_hash_map trash (std::move(*this));
-                //TODO: swapping allocators here may be a problem, replace with single direction moving iff pocma is set
-                this->swap(table);
-            } else {
-                //do per element move
-                concurrent_hash_map moved_copy(std::move(table), this->my_allocator);
-                this->swap(moved_copy);
-            }
+        if(this != &table) {
+            typedef typename node_allocator_traits::propagate_on_container_move_assignment pocma_type;
+            internal_move_assign(std::move(table), pocma_type());
         }
         return *this;
     }
@@ -847,8 +953,7 @@ class concurrent_hash_map : protected internal::hash_map_base {
     //! Assignment
     concurrent_hash_map& operator=( std::initializer_list<value_type> il ) {
         clear();
-        reserve(il.size());
-        internal_copy(il.begin(), il.end());
+        internal_copy(il.begin(), il.end(), il.size());
         return *this;
     }
 #endif //__TBB_INITIALIZER_LISTS_PRESENT
@@ -1056,8 +1161,8 @@ class concurrent_hash_map : protected internal::hash_map_base {
     template<typename Accessor, typename... Args>
     bool generic_emplace( Accessor && result, Args &&... args ) {
         result.release();
-        node * node_ptr = allocate_node_emplace_construct(my_allocator, std::forward<Args>(args)...);
-        return lookup(/*insert*/true, node_ptr->item.first, NULL, accessor_location(result), is_write_access_needed(result), &do_not_allocate_node, node_ptr );
+        node * node_ptr = create_node(my_allocator, std::forward<Args>(args)...);
+        return lookup(/*insert*/true, node_ptr->value().first, NULL, accessor_location(result), is_write_access_needed(result), &do_not_allocate_node, node_ptr );
     }
 #endif //__TBB_CPP11_VARIADIC_TEMPLATES_PRESENT
 #endif //__TBB_CPP11_RVALUE_REF_PRESENT
@@ -1073,7 +1178,24 @@ class concurrent_hash_map : protected internal::hash_map_base {
     void internal_copy( const concurrent_hash_map& source );
 
     template<typename I>
-    void internal_copy( I first, I last );
+    void internal_copy( I first, I last, size_type reserve_size );
+
+#if __TBB_CPP11_RVALUE_REF_PRESENT
+    // A compile-time dispatch to allow move assignment of containers with non-movable value_type if POCMA is true_type
+    void internal_move_assign(concurrent_hash_map&& other, tbb::internal::traits_true_type) {
+        tbb::internal::allocator_move_assignment(my_allocator, other.my_allocator, tbb::internal::traits_true_type());
+        internal_move(std::move(other));
+    }
+
+    void internal_move_assign(concurrent_hash_map&& other, tbb::internal::traits_false_type) {
+        if (this->my_allocator == other.my_allocator) {
+            internal_move(std::move(other));
+        } else {
+            //do per element move
+            internal_copy(std::make_move_iterator(other.begin()), std::make_move_iterator(other.end()), other.size());
+        }
+    }
+#endif
 
     //! Fast find when no concurrent erasure is used. For internal use inside TBB only!
     /** Return pointer to item with given key, or NULL if no such item exists.
@@ -1098,13 +1220,40 @@ class concurrent_hash_map : protected internal::hash_map_base {
         }
         n = search_bucket( key, b );
         if( n )
-            return &n->item;
+            return n->storage();
         else if( check_mask_race( h, m ) )
             goto restart;
         return 0;
     }
 };
 
+#if __TBB_CPP17_DEDUCTION_GUIDES_PRESENT
+namespace internal {
+using namespace tbb::internal;
+
+template<template<typename...> typename Map, typename Key, typename T, typename... Args>
+using hash_map_t = Map<
+    Key, T,
+    std::conditional_t< (sizeof...(Args)>0) && !is_allocator_v< pack_element_t<0, Args...> >,
+                        pack_element_t<0, Args...>, tbb_hash_compare<Key> >,
+    std::conditional_t< (sizeof...(Args)>0) && is_allocator_v< pack_element_t<sizeof...(Args)-1, Args...> >,
+                         pack_element_t<sizeof...(Args)-1, Args...>, tbb_allocator<std::pair<const Key, T> > >
+>;
+}
+
+// Deduction guide for the constructor from two iterators and hash_compare/ allocator
+template<typename I, typename... Args>
+concurrent_hash_map(I, I, Args...)
+-> internal::hash_map_t<concurrent_hash_map, internal::iterator_key_t<I>,internal::iterator_mapped_t<I>, Args...>;
+
+// Deduction guide for the constructor from an initializer_list and hash_compare/ allocator
+// Deduction guide for an initializer_list, hash_compare and allocator is implicit
+template<typename Key, typename T, typename CompareOrAllocator>
+concurrent_hash_map(std::initializer_list<std::pair<const Key, T>>, CompareOrAllocator)
+-> internal::hash_map_t<concurrent_hash_map, Key, T, CompareOrAllocator>;
+
+#endif /* __TBB_CPP17_DEDUCTION_GUIDES_PRESENT */
+
 template<typename Key, typename T, typename HashCompare, typename A>
 bool concurrent_hash_map<Key,T,HashCompare,A>::lookup( bool op_insert, const Key &key, const T *t, const_accessor *result, bool write, node* (*allocate_node)(node_allocator_type& , const Key&, const T*), node *tmp_n ) {
     __TBB_ASSERT( !result || !result->my_node, NULL );
@@ -1177,7 +1326,7 @@ bool concurrent_hash_map<Key,T,HashCompare,A>::lookup( bool op_insert, const Key
 #if __TBB_STATISTICS
         my_info_resizes++; // concurrent ones
 #endif
-        enable_segment( grow_segment );
+        enable_segment( grow_segment, my_allocator );
     }
     if( tmp_n ) // if op_insert only
         delete_node( tmp_n );
@@ -1245,7 +1394,7 @@ bool concurrent_hash_map<Key,T,HashCompare,A>::erase( const Key &key ) {
     search:
         node_base **p = &b()->node_list;
         n = *p;
-        while( is_valid(n) && !my_hash_compare.equal(key, static_cast<node*>(n)->item.first ) ) {
+        while( is_valid(n) && !my_hash_compare.equal(key, static_cast<node*>(n)->value().first ) ) {
             p = &n->next;
             n = *p;
         }
@@ -1272,16 +1421,18 @@ bool concurrent_hash_map<Key,T,HashCompare,A>::erase( const Key &key ) {
 
 template<typename Key, typename T, typename HashCompare, typename A>
 void concurrent_hash_map<Key,T,HashCompare,A>::swap(concurrent_hash_map<Key,T,HashCompare,A> &table) {
-    //TODO: respect C++11 allocator_traits<A>::propogate_on_constainer_swap
-    using std::swap;
-    swap(this->my_allocator, table.my_allocator);
-    swap(this->my_hash_compare, table.my_hash_compare);
-    internal_swap(table);
+    typedef typename node_allocator_traits::propagate_on_container_swap pocs_type;
+    if (this != &table && (pocs_type::value || my_allocator == table.my_allocator)) {
+        using std::swap;
+        tbb::internal::allocator_swap(this->my_allocator, table.my_allocator, pocs_type());
+        swap(this->my_hash_compare, table.my_hash_compare);
+        internal_swap(table);
+    }
 }
 
 template<typename Key, typename T, typename HashCompare, typename A>
 void concurrent_hash_map<Key,T,HashCompare,A>::rehash(size_type sz) {
-    reserve( sz ); // TODO: add reduction of number of buckets as well
+    reserve( sz, my_allocator ); // TODO: add reduction of number of buckets as well
     hashcode_t mask = my_mask;
     hashcode_t b = (mask+1)>>1; // size or first index of the last segment
     __TBB_ASSERT((b&(b-1))==0, NULL); // zero or power of 2
@@ -1300,7 +1451,7 @@ void concurrent_hash_map<Key,T,HashCompare,A>::rehash(size_type sz) {
             // now h - is index of the root rehashed bucket b_old
             mark_rehashed_levels( h ); // mark all non-rehashed children recursively across all segments
             for( node_base **p = &b_old->node_list, *q = *p; is_valid(q); q = *p ) {
-                hashcode_t c = my_hash_compare.hash( static_cast<node*>(q)->item.first );
+                hashcode_t c = my_hash_compare.hash( static_cast<node*>(q)->value().first );
                 if( (c & mask) != h ) { // should be rehashed
                     *p = q->next; // exclude from b_old
                     bucket *b_new = get_bucket( c & mask );
@@ -1327,7 +1478,7 @@ void concurrent_hash_map<Key,T,HashCompare,A>::rehash(size_type sz) {
 #endif
 #if TBB_USE_ASSERT
         for( ; is_valid(n); n = n->next ) {
-            hashcode_t h = my_hash_compare.hash( static_cast<node*>(n)->item.first ) & mask;
+            hashcode_t h = my_hash_compare.hash( static_cast<node*>(n)->value().first ) & mask;
             __TBB_ASSERT( h == b, "hash() function changed for key in table or internal error" );
         }
 #endif
@@ -1374,7 +1525,7 @@ void concurrent_hash_map<Key,T,HashCompare,A>::clear() {
 #endif
 #if __TBB_EXTRA_DEBUG
         for(; is_valid(n); n = n->next ) {
-            hashcode_t h = my_hash_compare.hash( static_cast<node*>(n)->item.first );
+            hashcode_t h = my_hash_compare.hash( static_cast<node*>(n)->value().first );
             h &= m;
             __TBB_ASSERT( h == b || get_bucket(h)->node_list == internal::rehash_req, "hash() function changed for key in table or internal error" );
         }
@@ -1404,11 +1555,10 @@ void concurrent_hash_map<Key,T,HashCompare,A>::clear() {
         reported = true;
     }
 #endif
-#endif//TBB_USE_ASSERT || TBB_USE_PERFORMANCE_WARNINGS || __TBB_STATISTICS
+#endif // TBB_USE_ASSERT || TBB_USE_PERFORMANCE_WARNINGS || __TBB_STATISTICS
     my_size = 0;
     segment_index_t s = segment_index_of( m );
     __TBB_ASSERT( s+1 == pointers_per_table || !my_table[s+1], "wrong mask or concurrent grow" );
-    cache_aligned_allocator<bucket> alloc;
     do {
         __TBB_ASSERT( is_valid( my_table[s] ), "wrong mask or concurrent grow" );
         segment_ptr_t buckets_ptr = my_table[s];
@@ -1418,20 +1568,16 @@ void concurrent_hash_map<Key,T,HashCompare,A>::clear() {
                 buckets_ptr[i].node_list = n->next;
                 delete_node( n );
             }
-        if( s >= first_block) // the first segment or the next
-            alloc.deallocate( buckets_ptr, sz );
-        else if( s == embedded_block && embedded_block != first_block )
-            alloc.deallocate( buckets_ptr, segment_size(first_block)-embedded_buckets );
-        if( s >= embedded_block ) my_table[s] = 0;
+        delete_segment(s, my_allocator);
     } while(s-- > 0);
     my_mask = embedded_buckets - 1;
 }
 
 template<typename Key, typename T, typename HashCompare, typename A>
 void concurrent_hash_map<Key,T,HashCompare,A>::internal_copy( const concurrent_hash_map& source ) {
-    reserve( source.my_size ); // TODO: load_factor?
     hashcode_t mask = source.my_mask;
     if( my_mask == mask ) { // optimized version
+        reserve( source.my_size, my_allocator ); // TODO: load_factor?
         bucket *dst = 0, *src = 0;
         bool rehash_required = false;
         for( hashcode_t k = 0; k <= mask; k++ ) {
@@ -1443,24 +1589,26 @@ void concurrent_hash_map<Key,T,HashCompare,A>::internal_copy( const concurrent_h
                 rehash_required = true;
                 dst->node_list = internal::rehash_req;
             } else for(; n; n = static_cast<node*>( n->next ) ) {
-                add_to_bucket( dst, new( my_allocator ) node(n->item.first, n->item.second) );
+                node* node_ptr = create_node(my_allocator, n->value().first, n->value().second);
+                add_to_bucket( dst, node_ptr);
                 ++my_size; // TODO: replace by non-atomic op
             }
         }
         if( rehash_required ) rehash();
-    } else internal_copy( source.begin(), source.end() );
+    } else internal_copy( source.begin(), source.end(), source.my_size );
 }
 
 template<typename Key, typename T, typename HashCompare, typename A>
 template<typename I>
-void concurrent_hash_map<Key,T,HashCompare,A>::internal_copy(I first, I last) {
+void concurrent_hash_map<Key,T,HashCompare,A>::internal_copy(I first, I last, size_type reserve_size) {
+    reserve( reserve_size, my_allocator ); // TODO: load_factor?
     hashcode_t m = my_mask;
     for(; first != last; ++first) {
         hashcode_t h = my_hash_compare.hash( (*first).first );
         bucket *b = get_bucket( h & m );
         __TBB_ASSERT( b->node_list != internal::rehash_req, "Invalid bucket in destination table");
-        node *n = new( my_allocator ) node(*first);
-        add_to_bucket( b, n );
+        node* node_ptr = create_node(my_allocator, (*first).first, (*first).second);
+        add_to_bucket( b, node_ptr );
         ++my_size; // TODO: replace by non-atomic op
     }
 }
@@ -1496,4 +1644,7 @@ inline void swap(concurrent_hash_map<Key, T, HashCompare, A> &a, concurrent_hash
 
 } // namespace tbb
 
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_concurrent_hash_map_H_include_area
+
 #endif /* __TBB_concurrent_hash_map_H */
diff --git a/src/tbb/include/tbb/concurrent_lru_cache.h b/src/tbb/include/tbb/concurrent_lru_cache.h
index dc1532cf..a18dbf29 100644
--- a/src/tbb/include/tbb/concurrent_lru_cache.h
+++ b/src/tbb/include/tbb/concurrent_lru_cache.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,15 +12,14 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_concurrent_lru_cache_H
 #define __TBB_concurrent_lru_cache_H
 
+#define __TBB_concurrent_lru_cache_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #if ! TBB_PREVIEW_CONCURRENT_LRU_CACHE
     #error Set TBB_PREVIEW_CONCURRENT_LRU_CACHE to include concurrent_lru_cache.h
 #endif
@@ -284,4 +283,8 @@ class concurrent_lru_cache : internal::no_assign{
 using interface6::concurrent_lru_cache;
 
 } // namespace tbb
+
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_concurrent_lru_cache_H_include_area
+
 #endif //__TBB_concurrent_lru_cache_H
diff --git a/src/tbb/include/tbb/concurrent_map.h b/src/tbb/include/tbb/concurrent_map.h
new file mode 100644
index 00000000..32fbe684
--- /dev/null
+++ b/src/tbb/include/tbb/concurrent_map.h
@@ -0,0 +1,389 @@
+/*
+    Copyright (c) 2019-2020 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.
+*/
+
+#ifndef __TBB_concurrent_map_H
+#define __TBB_concurrent_map_H
+
+#define __TBB_concurrent_map_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
+#if !TBB_PREVIEW_CONCURRENT_ORDERED_CONTAINERS
+#error Set TBB_PREVIEW_CONCURRENT_ORDERED_CONTAINERS to include concurrent_map.h
+#endif
+
+#include "tbb_config.h"
+
+// concurrent_map requires C++11 support
+#if __TBB_CONCURRENT_ORDERED_CONTAINERS_PRESENT
+
+#include "internal/_concurrent_skip_list_impl.h"
+
+namespace tbb {
+
+namespace interface10 {
+
+template<typename Key, typename Value, typename KeyCompare, typename RandomGenerator,
+         size_t MAX_LEVELS, typename Allocator, bool AllowMultimapping>
+class map_traits {
+public:
+    static constexpr size_t MAX_LEVEL = MAX_LEVELS;
+    using random_level_generator_type = RandomGenerator;
+    using key_type = Key;
+    using mapped_type = Value;
+    using compare_type = KeyCompare;
+    using value_type = std::pair<const key_type, mapped_type>;
+    using reference = value_type&;
+    using const_reference = const value_type&;
+    using allocator_type = Allocator;
+    using mutex_type = tbb::spin_mutex;
+    using node_type = tbb::internal::node_handle<key_type, value_type, internal::skip_list_node<value_type, mutex_type>, allocator_type>;
+
+    static const bool allow_multimapping = AllowMultimapping;
+
+    class value_compare {
+    public:
+        // TODO: these member types are deprecated in C++17, do we need to let them
+        using result_type = bool;
+        using first_argument_type = value_type;
+        using second_argument_type = value_type;
+
+        bool operator()(const value_type& lhs, const value_type& rhs) const {
+            return comp(lhs.first, rhs.first);
+        }
+
+    protected:
+        value_compare(compare_type c) : comp(c) {}
+
+        friend class map_traits;
+
+        compare_type comp;
+    };
+
+    static value_compare value_comp(compare_type comp) { return value_compare(comp); }
+
+    static const key_type& get_key(const_reference val) {
+        return val.first;
+    }
+}; // class map_traits
+
+template <typename Key, typename Value, typename Comp, typename Allocator>
+class concurrent_multimap;
+
+template <typename Key, typename Value, typename Comp = std::less<Key>, typename Allocator = tbb_allocator<std::pair<const Key, Value>>>
+class concurrent_map
+    : public internal::concurrent_skip_list<map_traits<Key, Value, Comp, internal::concurrent_geometric_level_generator<64>, 64, Allocator, false>> {
+    using traits_type = map_traits<Key, Value, Comp, internal::concurrent_geometric_level_generator<64>, 64, Allocator, false>;
+    using base_type = internal::concurrent_skip_list<traits_type>;
+#if __TBB_EXTRA_DEBUG
+public:
+#endif
+    using base_type::allow_multimapping;
+public:
+    using key_type = Key;
+    using mapped_type = Value;
+    using value_type = typename traits_type::value_type;
+    using size_type = typename base_type::size_type;
+    using difference_type = typename base_type::difference_type;
+    using key_compare = Comp;
+    using value_compare = typename base_type::value_compare;
+    using allocator_type = Allocator;
+
+    using reference = typename base_type::reference;
+    using const_reference = typename base_type::const_reference;
+    using pointer = typename base_type::pointer;
+    using const_pointer = typename base_type::pointer;
+
+    using iterator = typename base_type::iterator;
+    using const_iterator = typename base_type::const_iterator;
+    using reverse_iterator = typename base_type::reverse_iterator;
+    using const_reverse_iterator = typename base_type::const_reverse_iterator;
+
+    using node_type = typename base_type::node_type;
+
+    using base_type::end;
+    using base_type::find;
+    using base_type::emplace;
+    using base_type::insert;
+
+    concurrent_map() = default;
+
+    explicit concurrent_map(const key_compare& comp, const allocator_type& alloc = allocator_type()) : base_type(comp, alloc) {}
+
+    explicit concurrent_map(const allocator_type& alloc) : base_type(key_compare(), alloc) {}
+
+    template< class InputIt >
+    concurrent_map(InputIt first, InputIt last, const key_compare& comp = Comp(), const allocator_type& alloc = allocator_type())
+        : base_type(first, last, comp, alloc) {}
+
+    template< class InputIt >
+    concurrent_map(InputIt first, InputIt last, const allocator_type& alloc) : base_type(first, last, key_compare(), alloc) {}
+
+    /** Copy constructor */
+    concurrent_map(const concurrent_map&) = default;
+
+    concurrent_map(const concurrent_map& other, const allocator_type& alloc) : base_type(other, alloc) {}
+
+    concurrent_map(concurrent_map&&) = default;
+
+    concurrent_map(concurrent_map&& other, const allocator_type& alloc) : base_type(std::move(other), alloc) {}
+
+    concurrent_map(std::initializer_list<value_type> init, const key_compare& comp = Comp(), const allocator_type& alloc = allocator_type())
+        : base_type(comp, alloc) {
+        insert(init);
+    }
+
+    concurrent_map(std::initializer_list<value_type> init, const allocator_type& alloc)
+        : base_type(key_compare(), alloc) {
+        insert(init);
+    }
+
+    concurrent_map& operator=(const concurrent_map& other) {
+        return static_cast<concurrent_map&>(base_type::operator=(other));
+    }
+
+    concurrent_map& operator=(concurrent_map&& other) {
+        return static_cast<concurrent_map&>(base_type::operator=(std::move(other)));
+    }
+
+    mapped_type& at(const key_type& key) {
+        iterator it = find(key);
+
+        if (it == end()) {
+            tbb::internal::throw_exception(tbb::internal::eid_invalid_key);
+        }
+
+        return it->second;
+    }
+
+    const mapped_type& at(const key_type& key) const {
+        const_iterator it = find(key);
+
+        if (it == end()) {
+            tbb::internal::throw_exception(tbb::internal::eid_invalid_key);
+        }
+
+        return it->second;
+    }
+
+    mapped_type& operator[](const key_type& key) {
+        iterator it = find(key);
+
+        if (it == end()) {
+            it = emplace(std::piecewise_construct, std::forward_as_tuple(key), std::tuple<>()).first;
+        }
+
+        return it->second;
+    }
+
+    mapped_type& operator[](key_type&& key) {
+        iterator it = find(key);
+
+        if (it == end()) {
+            it = emplace(std::piecewise_construct, std::forward_as_tuple(std::move(key)), std::tuple<>()).first;
+        }
+
+        return it->second;
+    }
+
+    template<typename P, typename std::enable_if<std::is_constructible<value_type, P&&>::value>::type>
+    std::pair<iterator, bool> insert(P&& value) {
+        return emplace(std::forward<P>(value));
+    }
+
+    template<typename P, typename std::enable_if<std::is_constructible<value_type, P&&>::value>::type>
+    iterator insert(const_iterator hint, P&& value) {
+            return emplace_hint(hint, std::forward<P>(value));
+        return end();
+    }
+
+    template<typename C2>
+    void merge(concurrent_map<key_type, mapped_type, C2, Allocator>& source) {
+        this->internal_merge(source);
+    }
+
+    template<typename C2>
+    void merge(concurrent_map<key_type, mapped_type, C2, Allocator>&& source) {
+        this->internal_merge(std::move(source));
+    }
+
+    template<typename C2>
+    void merge(concurrent_multimap<key_type, mapped_type, C2, Allocator>& source) {
+        this->internal_merge(source);
+    }
+
+    template<typename C2>
+    void merge(concurrent_multimap<key_type, mapped_type, C2, Allocator>&& source) {
+        this->internal_merge(std::move(source));
+    }
+}; // class concurrent_map
+
+#if __TBB_CPP17_DEDUCTION_GUIDES_PRESENT
+
+namespace internal {
+
+using namespace tbb::internal;
+
+template<template<typename...> typename Map, typename Key, typename T, typename... Args>
+using c_map_t = Map<Key, T,
+                    std::conditional_t< (sizeof...(Args) > 0) && !is_allocator_v<pack_element_t<0, Args...> >,
+                                        pack_element_t<0, Args...>, std::less<Key> >,
+                    std::conditional_t< (sizeof...(Args) > 0) && is_allocator_v<pack_element_t<sizeof...(Args)-1, Args...> >,
+                                        pack_element_t<sizeof...(Args)-1, Args...>, tbb_allocator<std::pair<const Key, T> > > >;
+} // namespace internal
+
+template<typename It, typename... Args>
+concurrent_map(It, It, Args...)
+-> internal::c_map_t<concurrent_map, internal::iterator_key_t<It>, internal::iterator_mapped_t<It>, Args...>;
+
+template<typename Key, typename T, typename... Args>
+concurrent_map(std::initializer_list<std::pair<const Key, T>>, Args...)
+-> internal::c_map_t<concurrent_map, Key, T, Args...>;
+
+#endif // __TBB_CPP17_DEDUCTION_GUIDES_PRESENT
+
+template <typename Key, typename Value, typename Comp = std::less<Key>, typename Allocator = tbb_allocator<std::pair<const Key, Value>>>
+class concurrent_multimap
+    : public internal::concurrent_skip_list<map_traits<Key, Value, Comp, internal::concurrent_geometric_level_generator<64>, 64, Allocator, true>> {
+    using traits_type = map_traits<Key, Value, Comp, internal::concurrent_geometric_level_generator<64>, 64, Allocator, true>;
+    using base_type = internal::concurrent_skip_list<traits_type>;
+#if __TBB_EXTRA_DEBUG
+public:
+#endif
+    using base_type::allow_multimapping;
+public:
+    using key_type = Key;
+    using mapped_type = Value;
+    using value_type = typename traits_type::value_type;
+    using size_type = typename base_type::size_type;
+    using difference_type = typename base_type::difference_type;
+    using key_compare = Comp;
+    using value_compare = typename base_type::value_compare;
+    using allocator_type = Allocator;
+
+    using reference = typename base_type::reference;
+    using const_reference = typename base_type::const_reference;
+    using pointer = typename base_type::pointer;
+    using const_pointer = typename base_type::pointer;
+
+    using iterator = typename base_type::iterator;
+    using const_iterator = typename base_type::const_iterator;
+    using reverse_iterator = typename base_type::reverse_iterator;
+    using const_reverse_iterator = typename base_type::const_reverse_iterator;
+
+    using node_type = typename base_type::node_type;
+
+    using base_type::end;
+    using base_type::find;
+    using base_type::emplace;
+    using base_type::insert;
+
+    concurrent_multimap() = default;
+
+    explicit concurrent_multimap(const key_compare& comp, const allocator_type& alloc = allocator_type()) : base_type(comp, alloc) {}
+
+    explicit concurrent_multimap(const allocator_type& alloc) : base_type(key_compare(), alloc) {}
+
+    template< class InputIt >
+    concurrent_multimap(InputIt first, InputIt last, const key_compare& comp = Comp(), const allocator_type& alloc = allocator_type())
+        : base_type(first, last, comp, alloc) {}
+
+    template< class InputIt >
+    concurrent_multimap(InputIt first, InputIt last, const allocator_type& alloc) : base_type(first, last, key_compare(), alloc) {}
+
+    /** Copy constructor */
+    concurrent_multimap(const concurrent_multimap&) = default;
+
+    concurrent_multimap(const concurrent_multimap& other, const allocator_type& alloc) : base_type(other, alloc) {}
+
+    concurrent_multimap(concurrent_multimap&&) = default;
+
+    concurrent_multimap(concurrent_multimap&& other, const allocator_type& alloc) : base_type(std::move(other), alloc) {}
+
+    concurrent_multimap(std::initializer_list<value_type> init, const key_compare& comp = Comp(), const allocator_type& alloc = allocator_type())
+        : base_type(comp, alloc) {
+        insert(init);
+    }
+
+    concurrent_multimap(std::initializer_list<value_type> init, const allocator_type& alloc)
+        : base_type(key_compare(), alloc) {
+        insert(init);
+    }
+
+    concurrent_multimap& operator=(const concurrent_multimap& other) {
+        return static_cast<concurrent_multimap&>(base_type::operator=(other));
+    }
+
+    concurrent_multimap& operator=(concurrent_multimap&& other) {
+        return static_cast<concurrent_multimap&>(base_type::operator=(std::move(other)));
+    }
+
+    template<typename P, typename std::enable_if<std::is_constructible<value_type, P&&>::value>::type>
+    std::pair<iterator, bool> insert(P&& value) {
+        return emplace(std::forward<P>(value));
+    }
+
+    template<typename P, typename std::enable_if<std::is_constructible<value_type, P&&>::value>::type>
+    iterator insert(const_iterator hint, P&& value) {
+            return emplace_hint(hint, std::forward<P>(value));
+        return end();
+    }
+
+    template<typename C2>
+    void merge(concurrent_multimap<key_type, mapped_type, C2, Allocator>& source) {
+        this->internal_merge(source);
+    }
+
+    template<typename C2>
+    void merge(concurrent_multimap<key_type, mapped_type, C2, Allocator>&& source) {
+        this->internal_merge(std::move(source));
+    }
+
+    template<typename C2>
+    void merge(concurrent_map<key_type, mapped_type, C2, Allocator>& source) {
+        this->internal_merge(source);
+    }
+
+    template<typename C2>
+    void merge(concurrent_map<key_type, mapped_type, C2, Allocator>&& source) {
+        this->internal_merge(std::move(source));
+    }
+
+}; // class concurrent_multimap
+
+#if __TBB_CPP17_DEDUCTION_GUIDES_PRESENT
+
+template<typename It, typename... Args>
+concurrent_multimap(It, It, Args...)
+-> internal::c_map_t<concurrent_multimap, internal::iterator_key_t<It>, internal::iterator_mapped_t<It>, Args...>;
+
+template<typename Key, typename T, typename... Args>
+concurrent_multimap(std::initializer_list<std::pair<const Key, T>>, Args...)
+-> internal::c_map_t<concurrent_multimap, Key, T, Args...>;
+
+#endif // __TBB_CPP17_DEDUCTION_GUIDES_PRESENT
+
+} // namespace interface10
+
+using interface10::concurrent_map;
+using interface10::concurrent_multimap;
+
+} // namespace tbb
+
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_concurrent_map_H_include_area
+
+#endif // __TBB_CONCURRENT_ORDERED_CONTAINERS_PRESENT
+#endif // __TBB_concurrent_map_H
diff --git a/src/tbb/include/tbb/concurrent_priority_queue.h b/src/tbb/include/tbb/concurrent_priority_queue.h
index 89297d85..9c70098b 100644
--- a/src/tbb/include/tbb/concurrent_priority_queue.h
+++ b/src/tbb/include/tbb/concurrent_priority_queue.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,21 +12,22 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_concurrent_priority_queue_H
 #define __TBB_concurrent_priority_queue_H
 
+#define __TBB_concurrent_priority_queue_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #include "atomic.h"
 #include "cache_aligned_allocator.h"
 #include "tbb_exception.h"
 #include "tbb_stddef.h"
 #include "tbb_profiling.h"
 #include "internal/_aggregator_impl.h"
+#include "internal/_template_helpers.h"
+#include "internal/_allocator_traits.h"
 #include <vector>
 #include <iterator>
 #include <functional>
@@ -85,14 +86,28 @@ class concurrent_priority_queue {
     typedef A allocator_type;
 
     //! Constructs a new concurrent_priority_queue with default capacity
-    explicit concurrent_priority_queue(const allocator_type& a = allocator_type()) : mark(0), my_size(0), data(a)
+    explicit concurrent_priority_queue(const allocator_type& a = allocator_type()) : mark(0), my_size(0), compare(), data(a)
+    {
+        my_aggregator.initialize_handler(my_functor_t(this));
+    }
+
+    //! Constructs a new concurrent_priority_queue with default capacity
+    explicit concurrent_priority_queue(const Compare& c, const allocator_type& a = allocator_type()) : mark(0), my_size(0), compare(c), data(a)
     {
         my_aggregator.initialize_handler(my_functor_t(this));
     }
 
     //! Constructs a new concurrent_priority_queue with init_sz capacity
     explicit concurrent_priority_queue(size_type init_capacity, const allocator_type& a = allocator_type()) :
-        mark(0), my_size(0), data(a)
+        mark(0), my_size(0), compare(), data(a)
+    {
+        data.reserve(init_capacity);
+        my_aggregator.initialize_handler(my_functor_t(this));
+    }
+
+    //! Constructs a new concurrent_priority_queue with init_sz capacity
+    explicit concurrent_priority_queue(size_type init_capacity, const Compare& c, const allocator_type& a = allocator_type()) :
+        mark(0), my_size(0), compare(c), data(a)
     {
         data.reserve(init_capacity);
         my_aggregator.initialize_handler(my_functor_t(this));
@@ -101,7 +116,17 @@ class concurrent_priority_queue {
     //! [begin,end) constructor
     template<typename InputIterator>
     concurrent_priority_queue(InputIterator begin, InputIterator end, const allocator_type& a = allocator_type()) :
-        mark(0), data(begin, end, a)
+        mark(0), compare(), data(begin, end, a)
+    {
+        my_aggregator.initialize_handler(my_functor_t(this));
+        heapify();
+        my_size = data.size();
+    }
+
+    //! [begin,end) constructor
+    template<typename InputIterator>
+    concurrent_priority_queue(InputIterator begin, InputIterator end, const Compare& c, const allocator_type& a = allocator_type()) :
+        mark(0), compare(c), data(begin, end, a)
     {
         my_aggregator.initialize_handler(my_functor_t(this));
         heapify();
@@ -111,7 +136,16 @@ class concurrent_priority_queue {
 #if __TBB_INITIALIZER_LISTS_PRESENT
     //! Constructor from std::initializer_list
     concurrent_priority_queue(std::initializer_list<T> init_list, const allocator_type &a = allocator_type()) :
-        mark(0),data(init_list.begin(), init_list.end(), a)
+        mark(0), compare(), data(init_list.begin(), init_list.end(), a)
+    {
+        my_aggregator.initialize_handler(my_functor_t(this));
+        heapify();
+        my_size = data.size();
+    }
+
+    //! Constructor from std::initializer_list
+    concurrent_priority_queue(std::initializer_list<T> init_list, const Compare& c, const allocator_type &a = allocator_type()) :
+        mark(0), compare(c), data(init_list.begin(), init_list.end(), a)
     {
         my_aggregator.initialize_handler(my_functor_t(this));
         heapify();
@@ -121,7 +155,7 @@ class concurrent_priority_queue {
 
     //! Copy constructor
     /** This operation is unsafe if there are pending concurrent operations on the src queue. */
-    explicit concurrent_priority_queue(const concurrent_priority_queue& src) : mark(src.mark),
+    concurrent_priority_queue(const concurrent_priority_queue& src) : mark(src.mark),
         my_size(src.my_size), data(src.data.begin(), src.data.end(), src.data.get_allocator())
     {
         my_aggregator.initialize_handler(my_functor_t(this));
@@ -481,10 +515,38 @@ class concurrent_priority_queue {
     }
 };
 
+#if __TBB_CPP17_DEDUCTION_GUIDES_PRESENT
+namespace internal {
+
+template<typename T, typename... Args>
+using priority_queue_t = concurrent_priority_queue<
+    T,
+    std::conditional_t< (sizeof...(Args)>0) && !is_allocator_v< pack_element_t<0, Args...> >,
+                        pack_element_t<0, Args...>, std::less<T> >,
+    std::conditional_t< (sizeof...(Args)>0) && is_allocator_v< pack_element_t<sizeof...(Args)-1, Args...> >,
+                         pack_element_t<sizeof...(Args)-1, Args...>, cache_aligned_allocator<T> >
+>;
+}
+
+// Deduction guide for the constructor from two iterators
+template<typename InputIterator,
+         typename T = typename std::iterator_traits<InputIterator>::value_type,
+         typename... Args
+> concurrent_priority_queue(InputIterator, InputIterator, Args...)
+-> internal::priority_queue_t<T, Args...>;
+
+template<typename T, typename CompareOrAllocalor>
+concurrent_priority_queue(std::initializer_list<T> init_list, CompareOrAllocalor)
+-> internal::priority_queue_t<T, CompareOrAllocalor>;
+
+#endif /* __TBB_CPP17_DEDUCTION_GUIDES_PRESENT */
 } // namespace interface5
 
 using interface5::concurrent_priority_queue;
 
 } // namespace tbb
 
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_concurrent_priority_queue_H_include_area
+
 #endif /* __TBB_concurrent_priority_queue_H */
diff --git a/src/tbb/include/tbb/concurrent_queue.h b/src/tbb/include/tbb/concurrent_queue.h
index 81db58a3..122f98e5 100644
--- a/src/tbb/include/tbb/concurrent_queue.h
+++ b/src/tbb/include/tbb/concurrent_queue.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,16 +12,16 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_concurrent_queue_H
 #define __TBB_concurrent_queue_H
 
+#define __TBB_concurrent_queue_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #include "internal/_concurrent_queue_impl.h"
+#include "internal/_allocator_traits.h"
 
 namespace tbb {
 
@@ -36,7 +36,7 @@ class concurrent_queue: public internal::concurrent_queue_base_v3<T> {
     template<typename Container, typename Value> friend class internal::concurrent_queue_iterator;
 
     //! Allocator type
-    typedef typename A::template rebind<char>::other page_allocator_type;
+    typedef typename tbb::internal::allocator_rebind<A, char>::type page_allocator_type;
     page_allocator_type my_allocator;
 
     //! Allocates a block of size n (bytes)
@@ -177,6 +177,15 @@ class concurrent_queue: public internal::concurrent_queue_base_v3<T> {
     const_iterator unsafe_end() const {return const_iterator();}
 } ;
 
+#if __TBB_CPP17_DEDUCTION_GUIDES_PRESENT
+// Deduction guide for the constructor from two iterators
+template<typename InputIterator,
+         typename T = typename std::iterator_traits<InputIterator>::value_type,
+         typename A = cache_aligned_allocator<T>
+> concurrent_queue(InputIterator, InputIterator, const A& = A())
+-> concurrent_queue<T, A>;
+#endif /* __TBB_CPP17_DEDUCTION_GUIDES_PRESENT */
+
 template<typename T, class A>
 concurrent_queue<T,A>::~concurrent_queue() {
     clear();
@@ -200,9 +209,9 @@ void concurrent_queue<T,A>::clear() {
 template<typename T, class A = cache_aligned_allocator<T> >
 class concurrent_bounded_queue: public internal::concurrent_queue_base_v8 {
     template<typename Container, typename Value> friend class internal::concurrent_queue_iterator;
+    typedef typename tbb::internal::allocator_rebind<A, char>::type page_allocator_type;
 
     //! Allocator type
-    typedef typename A::template rebind<char>::other page_allocator_type;
     page_allocator_type my_allocator;
 
     typedef typename concurrent_queue_base_v3::padded_page<T> padded_page;
@@ -439,6 +448,15 @@ class concurrent_bounded_queue: public internal::concurrent_queue_base_v8 {
 
 };
 
+#if __TBB_CPP17_DEDUCTION_GUIDES_PRESENT
+// guide for concurrent_bounded_queue(InputIterator, InputIterator, ...)
+template<typename InputIterator,
+         typename T = typename std::iterator_traits<InputIterator>::value_type,
+         typename A = cache_aligned_allocator<T>
+> concurrent_bounded_queue(InputIterator, InputIterator, const A& = A())
+-> concurrent_bounded_queue<T, A>;
+#endif /* __TBB_CPP17_DEDUCTION_GUIDES_PRESENT */
+
 template<typename T, class A>
 concurrent_bounded_queue<T,A>::~concurrent_bounded_queue() {
     clear();
@@ -455,4 +473,7 @@ using strict_ppl::concurrent_queue;
 
 } // namespace tbb
 
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_concurrent_queue_H_include_area
+
 #endif /* __TBB_concurrent_queue_H */
diff --git a/src/tbb/include/tbb/concurrent_set.h b/src/tbb/include/tbb/concurrent_set.h
new file mode 100644
index 00000000..ecb21624
--- /dev/null
+++ b/src/tbb/include/tbb/concurrent_set.h
@@ -0,0 +1,304 @@
+/*
+    Copyright (c) 2019-2020 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.
+*/
+
+#ifndef __TBB_concurrent_set_H
+#define __TBB_concurrent_set_H
+
+#define __TBB_concurrent_set_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
+#if !TBB_PREVIEW_CONCURRENT_ORDERED_CONTAINERS
+#error Set TBB_PREVIEW_CONCURRENT_ORDERED_CONTAINERS to include concurrent_set.h
+#endif
+
+#include "tbb/tbb_config.h"
+
+// concurrent_set requires C++11 support
+#if __TBB_CONCURRENT_ORDERED_CONTAINERS_PRESENT
+
+#include "internal/_concurrent_skip_list_impl.h"
+
+namespace tbb {
+namespace interface10 {
+
+// TODO: test this class
+template<typename Key, typename KeyCompare, typename RandomGenerator, size_t MAX_LEVELS, typename Allocator, bool AllowMultimapping>
+class set_traits {
+public:
+    static constexpr size_t MAX_LEVEL = MAX_LEVELS;
+    using random_level_generator_type = RandomGenerator;
+    using key_type = Key;
+    using value_type = key_type;
+    using compare_type = KeyCompare;
+    using value_compare = compare_type;
+    using reference = value_type & ;
+    using const_reference = const value_type&;
+    using allocator_type = Allocator;
+    using mutex_type = tbb::spin_mutex;
+    using node_type = tbb::internal::node_handle<key_type, value_type, internal::skip_list_node<value_type, mutex_type>, allocator_type>;
+
+    static const bool allow_multimapping = AllowMultimapping;
+
+    static const key_type& get_key(const_reference val) {
+        return val;
+    }
+
+    static value_compare value_comp(compare_type comp) { return comp; }
+};
+
+template <typename Key, typename Comp, typename Allocator>
+class concurrent_multiset;
+
+template <typename Key, typename Comp = std::less<Key>, typename Allocator = tbb_allocator<Key>>
+class concurrent_set
+    : public internal::concurrent_skip_list<set_traits<Key, Comp, internal::concurrent_geometric_level_generator<64>, 64, Allocator, false>> {
+    using traits_type = set_traits<Key, Comp, internal::concurrent_geometric_level_generator<64>, 64, Allocator, false>;
+    using base_type = internal::concurrent_skip_list<traits_type>;
+#if __TBB_EXTRA_DEBUG
+public:
+#endif
+    using base_type::allow_multimapping;
+public:
+    using key_type = Key;
+    using value_type = typename traits_type::value_type;
+    using size_type = typename base_type::size_type;
+    using difference_type = typename base_type::difference_type;
+    using key_compare = Comp;
+    using value_compare = typename base_type::value_compare;
+    using allocator_type = Allocator;
+
+    using reference = typename base_type::reference;
+    using const_reference = typename base_type::const_reference;
+    using pointer = typename base_type::pointer;
+    using const_pointer = typename base_type::pointer;
+
+    using iterator = typename base_type::iterator;
+    using const_iterator = typename base_type::const_iterator;
+    using reverse_iterator = typename base_type::reverse_iterator;
+    using const_reverse_iterator = typename base_type::const_reverse_iterator;
+
+    using node_type = typename base_type::node_type;
+
+    using base_type::insert;
+
+    concurrent_set() = default;
+
+    explicit concurrent_set(const key_compare& comp, const allocator_type& alloc = allocator_type()) : base_type(comp, alloc) {}
+
+    explicit concurrent_set(const allocator_type& alloc) : base_type(key_compare(), alloc) {}
+
+    template< class InputIt >
+    concurrent_set(InputIt first, InputIt last, const key_compare& comp = Comp(), const allocator_type& alloc = allocator_type())
+        : base_type(first, last, comp, alloc) {}
+
+    template< class InputIt >
+    concurrent_set(InputIt first, InputIt last, const allocator_type& alloc) : base_type(first, last, key_compare(), alloc) {}
+
+    /** Copy constructor */
+    concurrent_set(const concurrent_set&) = default;
+
+    concurrent_set(const concurrent_set& other, const allocator_type& alloc) : base_type(other, alloc) {}
+
+    concurrent_set(concurrent_set&&) = default;
+
+    concurrent_set(concurrent_set&& other, const allocator_type& alloc) : base_type(std::move(other), alloc) {}
+
+    concurrent_set(std::initializer_list<value_type> init, const key_compare& comp = Comp(), const allocator_type& alloc = allocator_type())
+        : base_type(comp, alloc) {
+        insert(init);
+    }
+
+    concurrent_set(std::initializer_list<value_type> init, const allocator_type& alloc)
+        : base_type(key_compare(), alloc) {
+        insert(init);
+    }
+
+    concurrent_set& operator=(const concurrent_set& other) {
+        return static_cast<concurrent_set&>(base_type::operator=(other));
+    }
+
+    concurrent_set& operator=(concurrent_set&& other) {
+        return static_cast<concurrent_set&>(base_type::operator=(std::move(other)));
+    }
+
+    template<typename C2>
+    void merge(concurrent_set<key_type, C2, Allocator>& source) {
+        this->internal_merge(source);
+    }
+
+    template<typename C2>
+    void merge(concurrent_set<key_type, C2, Allocator>&& source) {
+        this->internal_merge(std::move(source));
+    }
+
+    template<typename C2>
+    void merge(concurrent_multiset<key_type, C2, Allocator>& source) {
+        this->internal_merge(source);
+    }
+
+    template<typename C2>
+    void merge(concurrent_multiset<key_type, C2, Allocator>&& source) {
+        this->internal_merge(std::move(source));
+    }
+}; // class concurrent_set
+
+#if __TBB_CPP17_DEDUCTION_GUIDES_PRESENT
+
+namespace internal {
+
+using namespace tbb::internal;
+
+template<template<typename...> typename Set, typename Key, typename... Args>
+using c_set_t = Set<Key,
+                    std::conditional_t< (sizeof...(Args) > 0) && !is_allocator_v<pack_element_t<0, Args...> >,
+                                        pack_element_t<0, Args...>, std::less<Key> >,
+                    std::conditional_t< (sizeof...(Args) > 0) && is_allocator_v<pack_element_t<sizeof...(Args)-1, Args...> >,
+                                        pack_element_t<sizeof...(Args)-1, Args...>, tbb_allocator<Key> > >;
+} // namespace internal
+
+template<typename It, typename... Args>
+concurrent_set(It, It, Args...)
+-> internal::c_set_t<concurrent_set, internal::iterator_value_t<It>, Args...>;
+
+template<typename Key, typename... Args>
+concurrent_set(std::initializer_list<Key>, Args...)
+-> internal::c_set_t<concurrent_set, Key, Args...>;
+
+#endif // __TBB_CPP17_DEDUCTION_GUIDES_PRESENT
+
+template <typename Key, typename Comp = std::less<Key>, typename Allocator = tbb_allocator<Key>>
+class concurrent_multiset
+    : public internal::concurrent_skip_list<set_traits<Key, Comp, internal::concurrent_geometric_level_generator<64>, 64, Allocator, true>> {
+    using traits_type = set_traits<Key, Comp, internal::concurrent_geometric_level_generator<64>, 64, Allocator, true>;
+    using base_type = internal::concurrent_skip_list<traits_type>;
+#if __TBB_EXTRA_DEBUG
+public:
+#endif
+    using base_type::allow_multimapping;
+public:
+    using key_type = Key;
+    using value_type = typename traits_type::value_type;
+    using size_type = typename base_type::size_type;
+    using difference_type = typename base_type::difference_type;
+    using key_compare = Comp;
+    using value_compare = typename base_type::value_compare;
+    using allocator_type = Allocator;
+
+    using reference = typename base_type::reference;
+    using const_reference = typename base_type::const_reference;
+    using pointer = typename base_type::pointer;
+    using const_pointer = typename base_type::pointer;
+
+    using iterator = typename base_type::iterator;
+    using const_iterator = typename base_type::const_iterator;
+    using reverse_iterator = typename base_type::reverse_iterator;
+    using const_reverse_iterator = typename base_type::const_reverse_iterator;
+
+    using node_type = typename base_type::node_type;
+
+    using base_type::insert;
+
+    concurrent_multiset() = default;
+
+    explicit concurrent_multiset(const key_compare& comp, const allocator_type& alloc = allocator_type()) : base_type(comp, alloc) {}
+
+    explicit concurrent_multiset(const allocator_type& alloc) : base_type(key_compare(), alloc) {}
+
+    template< class InputIt >
+    concurrent_multiset(InputIt first, InputIt last, const key_compare& comp = Comp(), const allocator_type& alloc = allocator_type())
+        : base_type(comp, alloc) {
+        insert(first, last);
+    }
+
+    template< class InputIt >
+    concurrent_multiset(InputIt first, InputIt last, const allocator_type& alloc) : base_type(key_compare(), alloc) {
+        insert(first, last);
+    }
+
+    /** Copy constructor */
+    concurrent_multiset(const concurrent_multiset&) = default;
+
+    concurrent_multiset(const concurrent_multiset& other, const allocator_type& alloc) : base_type(other, alloc) {}
+
+    concurrent_multiset(concurrent_multiset&&) = default;
+
+    concurrent_multiset(concurrent_multiset&& other, const allocator_type& alloc) : base_type(std::move(other), alloc) {}
+
+    concurrent_multiset(std::initializer_list<value_type> init, const key_compare& comp = Comp(), const allocator_type& alloc = allocator_type())
+        : base_type(comp, alloc) {
+        insert(init);
+    }
+
+    concurrent_multiset(std::initializer_list<value_type> init, const allocator_type& alloc)
+        : base_type(key_compare(), alloc) {
+        insert(init);
+    }
+
+    concurrent_multiset& operator=(const concurrent_multiset& other) {
+        return static_cast<concurrent_multiset&>(base_type::operator=(other));
+    }
+
+    concurrent_multiset& operator=(concurrent_multiset&& other) {
+        return static_cast<concurrent_multiset&>(base_type::operator=(std::move(other)));
+    }
+
+    template<typename C2>
+    void merge(concurrent_set<key_type, C2, Allocator>& source) {
+        this->internal_merge(source);
+    }
+
+    template<typename C2>
+    void merge(concurrent_set<key_type, C2, Allocator>&& source) {
+        this->internal_merge(std::move(source));
+    }
+
+    template<typename C2>
+    void merge(concurrent_multiset<key_type, C2, Allocator>& source) {
+        this->internal_merge(source);
+    }
+
+    template<typename C2>
+    void merge(concurrent_multiset<key_type, C2, Allocator>&& source) {
+        this->internal_merge(std::move(source));
+    }
+}; // class concurrent_multiset
+
+#if __TBB_CPP17_DEDUCTION_GUIDES_PRESENT
+
+
+template<typename It, typename... Args>
+concurrent_multiset(It, It, Args...)
+-> internal::c_set_t<concurrent_multiset, internal::iterator_value_t<It>, Args...>;
+
+template<typename Key, typename... Args>
+concurrent_multiset(std::initializer_list<Key>, Args...)
+-> internal::c_set_t<concurrent_multiset, Key, Args...>;
+
+#endif // __TBB_CPP17_DEDUCTION_GUIDES_PRESENT
+
+} // namespace interface10
+
+using interface10::concurrent_set;
+using interface10::concurrent_multiset;
+
+} // namespace tbb
+
+#endif // __TBB_CONCURRENT_ORDERED_CONTAINERS_PRESENT
+
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_concurrent_set_H_include_area
+
+#endif // __TBB_concurrent_set_H
diff --git a/src/tbb/include/tbb/concurrent_unordered_map.h b/src/tbb/include/tbb/concurrent_unordered_map.h
index c959a7ec..a9d8df8a 100644
--- a/src/tbb/include/tbb/concurrent_unordered_map.h
+++ b/src/tbb/include/tbb/concurrent_unordered_map.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 /* Container implementations in this header are based on PPL implementations
@@ -24,6 +20,9 @@
 #ifndef __TBB_concurrent_unordered_map_H
 #define __TBB_concurrent_unordered_map_H
 
+#define __TBB_concurrent_unordered_map_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #include "internal/_concurrent_unordered_impl.h"
 
 namespace tbb
@@ -39,7 +38,13 @@ class concurrent_unordered_map_traits
     typedef std::pair<const Key, T> value_type;
     typedef Key key_type;
     typedef Hash_compare hash_compare;
-    typedef typename Allocator::template rebind<value_type>::other allocator_type;
+    typedef typename tbb::internal::allocator_rebind<Allocator, value_type>::type allocator_type;
+#if __TBB_UNORDERED_NODE_HANDLE_PRESENT
+    typedef tbb::internal::node_handle<key_type, value_type,
+                                  typename internal::split_ordered_list<value_type, allocator_type>::node,
+                                  allocator_type> node_type;
+#endif // __TBB_UNORDERED_NODE_HANDLE_PRESENT
+
     enum { allow_multimapping = Allow_multimapping };
 
     concurrent_unordered_map_traits() : my_hash_compare() {}
@@ -53,6 +58,9 @@ class concurrent_unordered_map_traits
     hash_compare my_hash_compare; // the comparator predicate for keys
 };
 
+template<typename Key, typename T, typename Hasher, typename Key_equality, typename Allocator>
+class concurrent_unordered_multimap;
+
 template <typename Key, typename T, typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>,
          typename Allocator = tbb::tbb_allocator<std::pair<const Key, T> > >
 class concurrent_unordered_map :
@@ -93,12 +101,23 @@ class concurrent_unordered_map :
     typedef typename base_type::const_iterator const_iterator;
     typedef typename base_type::iterator local_iterator;
     typedef typename base_type::const_iterator const_local_iterator;
+#if __TBB_UNORDERED_NODE_HANDLE_PRESENT
+    typedef typename base_type::node_type node_type;
+#endif // __TBB_UNORDERED_NODE_HANDLE_PRESENT
 
     // Construction/destruction/copying
     explicit concurrent_unordered_map(size_type n_of_buckets = base_type::initial_bucket_number,
-        const hasher& _Hasher = hasher(), const key_equal& _Key_equality = key_equal(),
+        const hasher& a_hasher = hasher(), const key_equal& a_keyeq = key_equal(),
         const allocator_type& a = allocator_type())
-        : base_type(n_of_buckets, key_compare(_Hasher, _Key_equality), a)
+        : base_type(n_of_buckets, key_compare(a_hasher, a_keyeq), a)
+    {}
+
+    concurrent_unordered_map(size_type n_of_buckets, const allocator_type& a)
+        : base_type(n_of_buckets, key_compare(hasher(), key_equal()), a)
+    {}
+
+    concurrent_unordered_map(size_type n_of_buckets, const hasher& a_hasher, const allocator_type& a)
+        : base_type(n_of_buckets, key_compare(a_hasher, key_equal()), a)
     {}
 
     explicit concurrent_unordered_map(const Allocator& a) : base_type(base_type::initial_bucket_number, key_compare(), a)
@@ -106,9 +125,24 @@ class concurrent_unordered_map :
 
     template <typename Iterator>
     concurrent_unordered_map(Iterator first, Iterator last, size_type n_of_buckets = base_type::initial_bucket_number,
-        const hasher& _Hasher = hasher(), const key_equal& _Key_equality = key_equal(),
+        const hasher& a_hasher = hasher(), const key_equal& a_keyeq = key_equal(),
         const allocator_type& a = allocator_type())
-        : base_type(n_of_buckets, key_compare(_Hasher, _Key_equality), a)
+        : base_type(n_of_buckets, key_compare(a_hasher, a_keyeq), a)
+    {
+        insert(first, last);
+    }
+
+    template <typename Iterator>
+    concurrent_unordered_map(Iterator first, Iterator last, size_type n_of_buckets, const allocator_type& a)
+        : base_type(n_of_buckets, key_compare(hasher(), key_equal()), a)
+    {
+        insert(first, last);
+    }
+
+    template <typename Iterator>
+    concurrent_unordered_map(Iterator first, Iterator last, size_type n_of_buckets, const hasher& a_hasher,
+        const allocator_type& a)
+        : base_type(n_of_buckets, key_compare(a_hasher, key_equal()), a)
     {
         insert(first, last);
     }
@@ -116,16 +150,30 @@ class concurrent_unordered_map :
 #if __TBB_INITIALIZER_LISTS_PRESENT
     //! Constructor from initializer_list
     concurrent_unordered_map(std::initializer_list<value_type> il, size_type n_of_buckets = base_type::initial_bucket_number,
-        const hasher& _Hasher = hasher(), const key_equal& _Key_equality = key_equal(),
+        const hasher& a_hasher = hasher(), const key_equal& a_keyeq = key_equal(),
         const allocator_type& a = allocator_type())
-        : base_type(n_of_buckets, key_compare(_Hasher, _Key_equality), a)
+        : base_type(n_of_buckets, key_compare(a_hasher, a_keyeq), a)
+    {
+        insert(il.begin(),il.end());
+    }
+
+    concurrent_unordered_map(std::initializer_list<value_type> il, size_type n_of_buckets, const allocator_type& a)
+        : base_type(n_of_buckets, key_compare(hasher(), key_equal()), a)
+    {
+        insert(il.begin(), il.end());
+    }
+
+    concurrent_unordered_map(std::initializer_list<value_type> il, size_type n_of_buckets, const hasher& a_hasher,
+        const allocator_type& a)
+        : base_type(n_of_buckets, key_compare(a_hasher, key_equal()), a)
     {
-        this->insert(il.begin(),il.end());
+        insert(il.begin(), il.end());
     }
+
 #endif //# __TBB_INITIALIZER_LISTS_PRESENT
 
-#if __TBB_CPP11_RVALUE_REF_PRESENT
-#if !__TBB_IMPLICIT_MOVE_PRESENT
+
+#if __TBB_CPP11_RVALUE_REF_PRESENT && !__TBB_IMPLICIT_MOVE_PRESENT
     concurrent_unordered_map(const concurrent_unordered_map& table)
         : base_type(table)
     {}
@@ -143,11 +191,31 @@ class concurrent_unordered_map :
     {
         return static_cast<concurrent_unordered_map&>(base_type::operator=(std::move(table)));
     }
-#endif //!__TBB_IMPLICIT_MOVE_PRESENT
+#endif //__TBB_CPP11_RVALUE_REF_PRESENT && !__TBB_IMPLICIT_MOVE_PRESENT
 
+#if __TBB_CPP11_RVALUE_REF_PRESENT
     concurrent_unordered_map(concurrent_unordered_map&& table, const Allocator& a) : base_type(std::move(table), a)
     {}
-#endif //__TBB_CPP11_RVALUE_REF_PRESENT
+#endif /*__TBB_CPP11_RVALUE_REF_PRESENT*/
+
+#if __TBB_UNORDERED_NODE_HANDLE_PRESENT
+    template<typename Hash, typename Equality>
+    void merge(concurrent_unordered_map<Key, T, Hash, Equality, Allocator>& source)
+              { this->internal_merge(source); }
+
+    template<typename Hash, typename Equality>
+    void merge(concurrent_unordered_map<Key, T, Hash, Equality, Allocator>&& source)
+              { this->internal_merge(source); }
+
+    template<typename Hash, typename Equality>
+    void merge(concurrent_unordered_multimap<Key, T, Hash, Equality, Allocator>& source)
+              { this->internal_merge(source); }
+
+    template<typename Hash, typename Equality>
+    void merge(concurrent_unordered_multimap<Key, T, Hash, Equality, Allocator>&& source)
+              { this->internal_merge(source); }
+
+#endif //__TBB_UNORDERED_NODE_HANDLE_PRESENT
 
     concurrent_unordered_map(const concurrent_unordered_map& table, const Allocator& a)
         : base_type(table, a)
@@ -191,6 +259,45 @@ class concurrent_unordered_map :
     }
 };
 
+#if __TBB_CPP17_DEDUCTION_GUIDES_PRESENT
+
+namespace internal {
+using namespace tbb::internal;
+
+template<template<typename...> typename Map, typename Key, typename Element, typename... Args>
+using cu_map_t = Map<
+    Key, Element,
+    std::conditional_t< (sizeof...(Args)>0) && !is_allocator_v< pack_element_t<0, Args...> >,
+                        pack_element_t<0, Args...>, tbb_hash<Key> >,
+    std::conditional_t< (sizeof...(Args)>1) && !is_allocator_v< pack_element_t<1, Args...> >,
+                        pack_element_t<1, Args...>, std::equal_to<Key> >,
+    std::conditional_t< (sizeof...(Args)>0) && is_allocator_v< pack_element_t<sizeof...(Args)-1, Args...> >,
+                        pack_element_t<sizeof...(Args)-1, Args...>, tbb_allocator<std::pair<const Key, Element> > >
+>;
+}
+
+// Deduction guide for the constructor from two iterators
+template<typename I>
+concurrent_unordered_map (I, I)
+-> internal::cu_map_t<concurrent_unordered_map, internal::iterator_key_t<I>, internal::iterator_mapped_t<I>>;
+
+// Deduction guide for the constructor from two iterators and hasher/equality/allocator
+template<typename I, typename... Args>
+concurrent_unordered_map(I, I, size_t, Args...)
+-> internal::cu_map_t<concurrent_unordered_map, internal::iterator_key_t<I>, internal::iterator_mapped_t<I>, Args...>;
+
+// Deduction guide for the constructor from an initializer_list
+template<typename Key, typename Element>
+concurrent_unordered_map(std::initializer_list<std::pair<const Key, Element>>)
+-> internal::cu_map_t<concurrent_unordered_map, Key, Element>;
+
+// Deduction guide for the constructor from an initializer_list and hasher/equality/allocator
+template<typename Key, typename Element, typename... Args>
+concurrent_unordered_map(std::initializer_list<std::pair<const Key, Element>>, size_t, Args...)
+-> internal::cu_map_t<concurrent_unordered_map, Key, Element, Args...>;
+
+#endif /* __TBB_CPP17_DEDUCTION_GUIDES_PRESENT */
+
 template < typename Key, typename T, typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>,
         typename Allocator = tbb::tbb_allocator<std::pair<const Key, T> > >
 class concurrent_unordered_multimap :
@@ -229,12 +336,23 @@ class concurrent_unordered_multimap :
     typedef typename base_type::const_iterator const_iterator;
     typedef typename base_type::iterator local_iterator;
     typedef typename base_type::const_iterator const_local_iterator;
+#if __TBB_UNORDERED_NODE_HANDLE_PRESENT
+    typedef typename base_type::node_type node_type;
+#endif //__TBB_UNORDERED_NODE_HANDLE_PRESENT
 
     // Construction/destruction/copying
     explicit concurrent_unordered_multimap(size_type n_of_buckets = base_type::initial_bucket_number,
-        const hasher& _Hasher = hasher(), const key_equal& _Key_equality = key_equal(),
+        const hasher& a_hasher = hasher(), const key_equal& a_keyeq = key_equal(),
         const allocator_type& a = allocator_type())
-        : base_type(n_of_buckets, key_compare(_Hasher, _Key_equality), a)
+        : base_type(n_of_buckets, key_compare(a_hasher, a_keyeq), a)
+    {}
+
+    concurrent_unordered_multimap(size_type n_of_buckets, const allocator_type& a)
+        : base_type(n_of_buckets, key_compare(hasher(), key_equal()), a)
+    {}
+
+    concurrent_unordered_multimap(size_type n_of_buckets, const hasher& a_hasher, const allocator_type& a)
+        : base_type(n_of_buckets, key_compare(a_hasher, key_equal()), a)
     {}
 
     explicit concurrent_unordered_multimap(const Allocator& a) : base_type(base_type::initial_bucket_number, key_compare(), a)
@@ -242,9 +360,24 @@ class concurrent_unordered_multimap :
 
     template <typename Iterator>
     concurrent_unordered_multimap(Iterator first, Iterator last, size_type n_of_buckets = base_type::initial_bucket_number,
-        const hasher& _Hasher = hasher(), const key_equal& _Key_equality = key_equal(),
+        const hasher& a_hasher = hasher(), const key_equal& a_keyeq = key_equal(),
         const allocator_type& a = allocator_type())
-        : base_type(n_of_buckets,key_compare(_Hasher,_Key_equality), a)
+        : base_type(n_of_buckets,key_compare(a_hasher,a_keyeq), a)
+    {
+        insert(first, last);
+    }
+
+    template <typename Iterator>
+    concurrent_unordered_multimap(Iterator first, Iterator last, size_type n_of_buckets, const allocator_type& a)
+        : base_type(n_of_buckets, key_compare(hasher(), key_equal()), a)
+    {
+        insert(first, last);
+    }
+
+    template <typename Iterator>
+    concurrent_unordered_multimap(Iterator first, Iterator last, size_type n_of_buckets, const hasher& a_hasher,
+        const allocator_type& a)
+        : base_type(n_of_buckets, key_compare(a_hasher, key_equal()), a)
     {
         insert(first, last);
     }
@@ -252,16 +385,29 @@ class concurrent_unordered_multimap :
 #if __TBB_INITIALIZER_LISTS_PRESENT
     //! Constructor from initializer_list
     concurrent_unordered_multimap(std::initializer_list<value_type> il, size_type n_of_buckets = base_type::initial_bucket_number,
-        const hasher& _Hasher = hasher(), const key_equal& _Key_equality = key_equal(),
+        const hasher& a_hasher = hasher(), const key_equal& a_keyeq = key_equal(),
         const allocator_type& a = allocator_type())
-        : base_type(n_of_buckets, key_compare(_Hasher, _Key_equality), a)
+        : base_type(n_of_buckets, key_compare(a_hasher, a_keyeq), a)
+    {
+        insert(il.begin(),il.end());
+    }
+
+    concurrent_unordered_multimap(std::initializer_list<value_type> il, size_type n_of_buckets, const allocator_type& a)
+        : base_type(n_of_buckets, key_compare(hasher(), key_equal()), a)
     {
-        this->insert(il.begin(),il.end());
+        insert(il.begin(), il.end());
     }
+
+    concurrent_unordered_multimap(std::initializer_list<value_type> il, size_type n_of_buckets, const hasher& a_hasher,
+        const allocator_type& a)
+        : base_type(n_of_buckets, key_compare(a_hasher, key_equal()), a)
+    {
+        insert(il.begin(), il.end());
+    }
+
 #endif //# __TBB_INITIALIZER_LISTS_PRESENT
 
-#if __TBB_CPP11_RVALUE_REF_PRESENT
-#if !__TBB_IMPLICIT_MOVE_PRESENT
+#if __TBB_CPP11_RVALUE_REF_PRESENT && !__TBB_IMPLICIT_MOVE_PRESENT
     concurrent_unordered_multimap(const concurrent_unordered_multimap& table)
         : base_type(table)
     {}
@@ -279,16 +425,60 @@ class concurrent_unordered_multimap :
     {
         return static_cast<concurrent_unordered_multimap&>(base_type::operator=(std::move(table)));
     }
-#endif //!__TBB_IMPLICIT_MOVE_PRESENT
+#endif //__TBB_CPP11_RVALUE_REF_PRESENT && !__TBB_IMPLICIT_MOVE_PRESENT
 
+#if __TBB_CPP11_RVALUE_REF_PRESENT
     concurrent_unordered_multimap(concurrent_unordered_multimap&& table, const Allocator& a) : base_type(std::move(table), a)
     {}
-#endif //__TBB_CPP11_RVALUE_REF_PRESENT
+#endif /*__TBB_CPP11_RVALUE_REF_PRESENT*/
+
+#if __TBB_UNORDERED_NODE_HANDLE_PRESENT
+    template<typename Hash, typename Equality>
+    void merge(concurrent_unordered_map<Key, T, Hash, Equality, Allocator>& source)
+              { this->internal_merge(source); }
+
+    template<typename Hash, typename Equality>
+    void merge(concurrent_unordered_map<Key, T, Hash, Equality, Allocator>&& source)
+              { this->internal_merge(source); }
+
+    template<typename Hash, typename Equality>
+    void merge(concurrent_unordered_multimap<Key, T, Hash, Equality, Allocator>& source)
+              { this->internal_merge(source); }
+
+    template<typename Hash, typename Equality>
+    void merge(concurrent_unordered_multimap<Key, T, Hash, Equality, Allocator>&& source)
+              { this->internal_merge(source); }
+
+#endif //__TBB_UNORDERED_NODE_HANDLE_PRESENT
 
     concurrent_unordered_multimap(const concurrent_unordered_multimap& table, const Allocator& a)
         : base_type(table, a)
     {}
 };
+
+#if __TBB_CPP17_DEDUCTION_GUIDES_PRESENT
+
+// Deduction guide for the constructor from two iterators
+template<typename I>
+concurrent_unordered_multimap (I, I)
+-> internal::cu_map_t<concurrent_unordered_multimap, internal::iterator_key_t<I>, internal::iterator_mapped_t<I>>;
+
+// Deduction guide for the constructor from two iterators and hasher/equality/allocator
+template<typename I, typename... Args>
+concurrent_unordered_multimap(I, I, size_t, Args...)
+-> internal::cu_map_t<concurrent_unordered_multimap, internal::iterator_key_t<I>, internal::iterator_mapped_t<I>, Args...>;
+
+// Deduction guide for the constructor from an initializer_list
+template<typename Key, typename Element>
+concurrent_unordered_multimap(std::initializer_list<std::pair<const Key, Element>>)
+-> internal::cu_map_t<concurrent_unordered_multimap, Key, Element>;
+
+// Deduction guide for the constructor from an initializer_list and hasher/equality/allocator
+template<typename Key, typename Element, typename... Args>
+concurrent_unordered_multimap(std::initializer_list<std::pair<const Key, Element>>, size_t, Args...)
+-> internal::cu_map_t<concurrent_unordered_multimap, Key, Element, Args...>;
+
+#endif /* __TBB_CPP17_DEDUCTION_GUIDES_PRESENT */
 } // namespace interface5
 
 using interface5::concurrent_unordered_map;
@@ -296,4 +486,7 @@ using interface5::concurrent_unordered_multimap;
 
 } // namespace tbb
 
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_concurrent_unordered_map_H_include_area
+
 #endif// __TBB_concurrent_unordered_map_H
diff --git a/src/tbb/include/tbb/concurrent_unordered_set.h b/src/tbb/include/tbb/concurrent_unordered_set.h
index a26fee1a..edb02565 100644
--- a/src/tbb/include/tbb/concurrent_unordered_set.h
+++ b/src/tbb/include/tbb/concurrent_unordered_set.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 /* Container implementations in this header are based on PPL implementations
@@ -24,6 +20,9 @@
 #ifndef __TBB_concurrent_unordered_set_H
 #define __TBB_concurrent_unordered_set_H
 
+#define __TBB_concurrent_unordered_set_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #include "internal/_concurrent_unordered_impl.h"
 
 namespace tbb
@@ -39,7 +38,13 @@ class concurrent_unordered_set_traits
     typedef Key value_type;
     typedef Key key_type;
     typedef Hash_compare hash_compare;
-    typedef typename Allocator::template rebind<value_type>::other allocator_type;
+    typedef typename tbb::internal::allocator_rebind<Allocator, value_type>::type allocator_type;
+#if __TBB_UNORDERED_NODE_HANDLE_PRESENT
+    typedef tbb::internal::node_handle<key_type, key_type,
+                                  typename internal::split_ordered_list<key_type, allocator_type>::node,
+                                  allocator_type> node_type;
+#endif // __TBB_UNORDERED_NODE_HANDLE_PRESENT
+
     enum { allow_multimapping = Allow_multimapping };
 
     concurrent_unordered_set_traits() : my_hash_compare() {}
@@ -52,6 +57,9 @@ class concurrent_unordered_set_traits
     hash_compare my_hash_compare; // the comparator predicate for keys
 };
 
+template<typename Key, typename Hasher, typename Key_equality, typename Allocator>
+class concurrent_unordered_multiset;
+
 template <typename Key, typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<Key> >
 class concurrent_unordered_set : public internal::concurrent_unordered_base< concurrent_unordered_set_traits<Key, internal::hash_compare<Key, Hasher, Key_equality>, Allocator, false> >
 {
@@ -87,6 +95,9 @@ class concurrent_unordered_set : public internal::concurrent_unordered_base< con
     typedef typename base_type::const_iterator const_iterator;
     typedef typename base_type::iterator local_iterator;
     typedef typename base_type::const_iterator const_local_iterator;
+#if __TBB_UNORDERED_NODE_HANDLE_PRESENT
+    typedef typename base_type::node_type node_type;
+#endif /*__TBB_UNORDERED_NODE_HANDLE_PRESENT*/
 
     // Construction/destruction/copying
     explicit concurrent_unordered_set(size_type n_of_buckets = base_type::initial_bucket_number, const hasher& a_hasher = hasher(),
@@ -94,29 +105,63 @@ class concurrent_unordered_set : public internal::concurrent_unordered_base< con
         : base_type(n_of_buckets, key_compare(a_hasher, a_keyeq), a)
     {}
 
+    concurrent_unordered_set(size_type n_of_buckets, const allocator_type& a)
+        : base_type(n_of_buckets, key_compare(hasher(), key_equal()), a)
+    {}
+
+    concurrent_unordered_set(size_type n_of_buckets, const hasher& a_hasher, const allocator_type& a)
+        : base_type(n_of_buckets, key_compare(a_hasher, key_equal()), a)
+    {}
+
     explicit concurrent_unordered_set(const Allocator& a) : base_type(base_type::initial_bucket_number, key_compare(), a)
     {}
 
     template <typename Iterator>
-    concurrent_unordered_set(Iterator first, Iterator last, size_type n_of_buckets = base_type::initial_bucket_number, const hasher& a_hasher = hasher(),
-        const key_equal& a_keyeq = key_equal(), const allocator_type& a = allocator_type())
+    concurrent_unordered_set(Iterator first, Iterator last, size_type n_of_buckets = base_type::initial_bucket_number,
+        const hasher& a_hasher = hasher(), const key_equal& a_keyeq = key_equal(), const allocator_type& a = allocator_type())
         : base_type(n_of_buckets, key_compare(a_hasher, a_keyeq), a)
     {
         insert(first, last);
     }
 
+    template <typename Iterator>
+    concurrent_unordered_set(Iterator first, Iterator last, size_type n_of_buckets, const allocator_type& a)
+        : base_type(n_of_buckets, key_compare(hasher(), key_equal()), a)
+    {
+        insert(first, last);
+    }
+
+    template <typename Iterator>
+    concurrent_unordered_set(Iterator first, Iterator last, size_type n_of_buckets, const hasher& a_hasher, const allocator_type& a)
+        : base_type(n_of_buckets, key_compare(a_hasher, key_equal()), a)
+    {
+        insert(first, last);
+    }
+
 #if __TBB_INITIALIZER_LISTS_PRESENT
     //! Constructor from initializer_list
     concurrent_unordered_set(std::initializer_list<value_type> il, size_type n_of_buckets = base_type::initial_bucket_number, const hasher& a_hasher = hasher(),
         const key_equal& a_keyeq = key_equal(), const allocator_type& a = allocator_type())
         : base_type(n_of_buckets, key_compare(a_hasher, a_keyeq), a)
     {
-        this->insert(il.begin(),il.end());
+        insert(il.begin(),il.end());
+    }
+
+    concurrent_unordered_set(std::initializer_list<value_type> il, size_type n_of_buckets, const allocator_type& a)
+        : base_type(n_of_buckets, key_compare(hasher(), key_equal()), a)
+    {
+        insert(il.begin(), il.end());
     }
+
+    concurrent_unordered_set(std::initializer_list<value_type> il, size_type n_of_buckets, const hasher& a_hasher, const allocator_type& a)
+        : base_type(n_of_buckets, key_compare(a_hasher, key_equal()), a)
+    {
+        insert(il.begin(), il.end());
+    }
+
 #endif //# __TBB_INITIALIZER_LISTS_PRESENT
 
-#if __TBB_CPP11_RVALUE_REF_PRESENT
-#if !__TBB_IMPLICIT_MOVE_PRESENT
+#if __TBB_CPP11_RVALUE_REF_PRESENT && !__TBB_IMPLICIT_MOVE_PRESENT
     concurrent_unordered_set(const concurrent_unordered_set& table)
         : base_type(table)
     {}
@@ -134,12 +179,32 @@ class concurrent_unordered_set : public internal::concurrent_unordered_base< con
     {
         return static_cast<concurrent_unordered_set&>(base_type::operator=(std::move(table)));
     }
-#endif //!__TBB_IMPLICIT_MOVE_PRESENT
+#endif //__TBB_CPP11_RVALUE_REF_PRESENT && !__TBB_IMPLICIT_MOVE_PRESENT
 
+#if __TBB_CPP11_RVALUE_REF_PRESENT
     concurrent_unordered_set(concurrent_unordered_set&& table, const Allocator& a)
         : base_type(std::move(table), a)
     {}
-#endif //__TBB_CPP11_RVALUE_REF_PRESENT
+#endif /*__TBB_CPP11_RVALUE_REF_PRESENT*/
+
+#if __TBB_UNORDERED_NODE_HANDLE_PRESENT
+    template<typename Hash, typename Equality>
+    void merge(concurrent_unordered_set<Key, Hash, Equality, Allocator>& source)
+              { this->internal_merge(source); }
+
+    template<typename Hash, typename Equality>
+    void merge(concurrent_unordered_set<Key, Hash, Equality, Allocator>&& source)
+              { this->internal_merge(source); }
+
+    template<typename Hash, typename Equality>
+    void merge(concurrent_unordered_multiset<Key, Hash, Equality, Allocator>& source)
+              { this->internal_merge(source); }
+
+    template<typename Hash, typename Equality>
+    void merge(concurrent_unordered_multiset<Key, Hash, Equality, Allocator>&& source)
+              { this->internal_merge(source); }
+
+#endif //__TBB_UNORDERED_NODE_HANDLE_PRESENT
 
     concurrent_unordered_set(const concurrent_unordered_set& table, const Allocator& a)
         : base_type(table, a)
@@ -147,6 +212,45 @@ class concurrent_unordered_set : public internal::concurrent_unordered_base< con
 
 };
 
+#if __TBB_CPP17_DEDUCTION_GUIDES_PRESENT
+
+namespace internal {
+using namespace tbb::internal;
+
+template <template<typename...> typename Set, typename T, typename... Args>
+using cu_set_t = Set <
+    T,
+    std::conditional_t< (sizeof...(Args)>0) && !is_allocator_v< pack_element_t<0, Args...> >,
+                        pack_element_t<0, Args...>, tbb_hash<T> >,
+    std::conditional_t< (sizeof...(Args)>1) && !is_allocator_v< pack_element_t<1, Args...> >,
+                        pack_element_t<1, Args...>, std::equal_to<T> >,
+    std::conditional_t< (sizeof...(Args)>0) && is_allocator_v< pack_element_t<sizeof...(Args)-1, Args...> >,
+                        pack_element_t<sizeof...(Args)-1, Args...>, tbb_allocator<T> >
+>;
+}
+
+// Deduction guide for the constructor from two iterators
+template<typename I>
+concurrent_unordered_set(I, I)
+-> internal::cu_set_t<concurrent_unordered_set, internal::iterator_value_t<I>>;
+
+// Deduction guide for the constructor from two iterators and hasher/equality/allocator
+template<typename I, typename... Args>
+concurrent_unordered_set(I, I, size_t, Args...)
+-> internal::cu_set_t<concurrent_unordered_set, internal::iterator_value_t<I>, Args...>;
+
+// Deduction guide for the constructor from an initializer_list
+template<typename T>
+concurrent_unordered_set(std::initializer_list<T>)
+-> internal::cu_set_t<concurrent_unordered_set, T>;
+
+// Deduction guide for the constructor from an initializer_list and hasher/equality/allocator
+template<typename T, typename... Args>
+concurrent_unordered_set(std::initializer_list<T>, size_t, Args...)
+-> internal::cu_set_t<concurrent_unordered_set, T, Args...>;
+
+#endif /*__TBB_CPP17_DEDUCTION_GUIDES_PRESENT */
+
 template <typename Key, typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>,
          typename Allocator = tbb::tbb_allocator<Key> >
 class concurrent_unordered_multiset :
@@ -185,12 +289,24 @@ class concurrent_unordered_multiset :
     typedef typename base_type::const_iterator const_iterator;
     typedef typename base_type::iterator local_iterator;
     typedef typename base_type::const_iterator const_local_iterator;
+#if __TBB_UNORDERED_NODE_HANDLE_PRESENT
+    typedef typename base_type::node_type node_type;
+#endif // __TBB_UNORDERED_NODE_HANDLE_PRESENT
 
     // Construction/destruction/copying
     explicit concurrent_unordered_multiset(size_type n_of_buckets = base_type::initial_bucket_number,
-        const hasher& _Hasher = hasher(), const key_equal& _Key_equality = key_equal(),
+        const hasher& a_hasher = hasher(), const key_equal& a_keyeq = key_equal(),
         const allocator_type& a = allocator_type())
-        : base_type(n_of_buckets, key_compare(_Hasher, _Key_equality), a)
+        : base_type(n_of_buckets, key_compare(a_hasher, a_keyeq), a)
+    {}
+
+    concurrent_unordered_multiset(size_type n_of_buckets, const allocator_type& a)
+        : base_type(n_of_buckets, key_compare(hasher(), key_equal()), a)
+    {}
+
+    concurrent_unordered_multiset(size_type n_of_buckets, const hasher& a_hasher,
+        const allocator_type& a)
+        : base_type(n_of_buckets, key_compare(a_hasher, key_equal()), a)
     {}
 
     explicit concurrent_unordered_multiset(const Allocator& a) : base_type(base_type::initial_bucket_number, key_compare(), a)
@@ -198,25 +314,54 @@ class concurrent_unordered_multiset :
 
     template <typename Iterator>
     concurrent_unordered_multiset(Iterator first, Iterator last, size_type n_of_buckets = base_type::initial_bucket_number,
-        const hasher& _Hasher = hasher(), const key_equal& _Key_equality = key_equal(),
+        const hasher& a_hasher = hasher(), const key_equal& a_keyeq = key_equal(),
         const allocator_type& a = allocator_type())
-        : base_type(n_of_buckets, key_compare(_Hasher, _Key_equality), a)
+        : base_type(n_of_buckets, key_compare(a_hasher, a_keyeq), a)
+    {
+        insert(first, last);
+    }
+
+    template <typename Iterator>
+    concurrent_unordered_multiset(Iterator first, Iterator last, size_type n_of_buckets, const allocator_type& a)
+        : base_type(n_of_buckets, key_compare(hasher(), key_equal()), a)
+    {
+        insert(first, last);
+    }
+
+    template <typename Iterator>
+    concurrent_unordered_multiset(Iterator first, Iterator last, size_type n_of_buckets, const hasher& a_hasher,
+        const allocator_type& a)
+        : base_type(n_of_buckets, key_compare(a_hasher, key_equal()), a)
     {
         insert(first, last);
     }
 
 #if __TBB_INITIALIZER_LISTS_PRESENT
     //! Constructor from initializer_list
-    concurrent_unordered_multiset(std::initializer_list<value_type> il, size_type n_of_buckets = base_type::initial_bucket_number, const hasher& a_hasher = hasher(),
-        const key_equal& a_keyeq = key_equal(), const allocator_type& a = allocator_type())
+    concurrent_unordered_multiset(std::initializer_list<value_type> il, size_type n_of_buckets = base_type::initial_bucket_number,
+        const hasher& a_hasher = hasher(), const key_equal& a_keyeq = key_equal(), const allocator_type& a = allocator_type())
         : base_type(n_of_buckets, key_compare(a_hasher, a_keyeq), a)
     {
-        this->insert(il.begin(),il.end());
+        insert(il.begin(),il.end());
+    }
+
+    concurrent_unordered_multiset(std::initializer_list<value_type> il, size_type n_of_buckets, const allocator_type& a)
+        : base_type(n_of_buckets, key_compare(hasher(), key_equal()), a)
+    {
+        insert(il.begin(), il.end());
     }
+
+    concurrent_unordered_multiset(std::initializer_list<value_type> il, size_type n_of_buckets, const hasher& a_hasher,
+        const allocator_type& a)
+        : base_type(n_of_buckets, key_compare(a_hasher, key_equal()), a)
+    {
+        insert(il.begin(), il.end());
+    }
+
 #endif //# __TBB_INITIALIZER_LISTS_PRESENT
 
-#if __TBB_CPP11_RVALUE_REF_PRESENT
-#if !__TBB_IMPLICIT_MOVE_PRESENT
+
+#if __TBB_CPP11_RVALUE_REF_PRESENT && !__TBB_IMPLICIT_MOVE_PRESENT
     concurrent_unordered_multiset(const concurrent_unordered_multiset& table)
         : base_type(table)
     {}
@@ -234,18 +379,62 @@ class concurrent_unordered_multiset :
     {
         return static_cast<concurrent_unordered_multiset&>(base_type::operator=(std::move(table)));
     }
-#endif //!__TBB_IMPLICIT_MOVE_PRESENT
+#endif //__TBB_CPP11_RVALUE_REF_PRESENT && !__TBB_IMPLICIT_MOVE_PRESENT
 
+#if __TBB_CPP11_RVALUE_REF_PRESENT
     concurrent_unordered_multiset(concurrent_unordered_multiset&& table, const Allocator& a)
         : base_type(std::move(table), a)
     {
     }
-#endif //__TBB_CPP11_RVALUE_REF_PRESENT
+#endif /*__TBB_CPP11_RVALUE_REF_PRESENT*/
+
+#if __TBB_UNORDERED_NODE_HANDLE_PRESENT
+    template<typename Hash, typename Equality>
+    void merge(concurrent_unordered_set<Key, Hash, Equality, Allocator>& source)
+              { this->internal_merge(source); }
+
+    template<typename Hash, typename Equality>
+    void merge(concurrent_unordered_set<Key, Hash, Equality, Allocator>&& source)
+              { this->internal_merge(source); }
+
+    template<typename Hash, typename Equality>
+    void merge(concurrent_unordered_multiset<Key, Hash, Equality, Allocator>& source)
+              { this->internal_merge(source); }
+
+    template<typename Hash, typename Equality>
+    void merge(concurrent_unordered_multiset<Key, Hash, Equality, Allocator>&& source)
+              { this->internal_merge(source); }
+
+#endif //__TBB_UNORDERED_NODE_HANDLE_PRESENT
 
     concurrent_unordered_multiset(const concurrent_unordered_multiset& table, const Allocator& a)
         : base_type(table, a)
     {}
 };
+
+#if __TBB_CPP17_DEDUCTION_GUIDES_PRESENT
+
+// Deduction guide for the constructor from two iterators
+template<typename I>
+concurrent_unordered_multiset(I, I)
+-> internal::cu_set_t<concurrent_unordered_multiset, internal::iterator_value_t<I>>;
+
+// Deduction guide for the constructor from two iterators and hasher/equality/allocator
+template<typename I, typename... Args>
+concurrent_unordered_multiset(I, I, size_t, Args...)
+-> internal::cu_set_t<concurrent_unordered_multiset, internal::iterator_value_t<I>, Args...>;
+
+// Deduction guide for the constructor from an initializer_list
+template<typename T>
+concurrent_unordered_multiset(std::initializer_list<T>)
+-> internal::cu_set_t<concurrent_unordered_multiset, T>;
+
+// Deduction guide for the constructor from an initializer_list and hasher/equality/allocator
+template<typename T, typename... Args>
+concurrent_unordered_multiset(std::initializer_list<T>, size_t, Args...)
+-> internal::cu_set_t<concurrent_unordered_multiset, T, Args...>;
+
+#endif /* __TBB_CPP17_DEDUCTION_GUIDES_PRESENT */
 } // namespace interface5
 
 using interface5::concurrent_unordered_set;
@@ -253,4 +442,7 @@ using interface5::concurrent_unordered_multiset;
 
 } // namespace tbb
 
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_concurrent_unordered_set_H_include_area
+
 #endif// __TBB_concurrent_unordered_set_H
diff --git a/src/tbb/include/tbb/concurrent_vector.h b/src/tbb/include/tbb/concurrent_vector.h
index b9bd5559..a4988aaa 100644
--- a/src/tbb/include/tbb/concurrent_vector.h
+++ b/src/tbb/include/tbb/concurrent_vector.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,15 +12,14 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_concurrent_vector_H
 #define __TBB_concurrent_vector_H
 
+#define __TBB_concurrent_vector_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #include "tbb_stddef.h"
 #include "tbb_exception.h"
 #include "atomic.h"
@@ -34,6 +33,8 @@
 #include <algorithm>
 #include <iterator>
 
+#include "internal/_allocator_traits.h"
+
 #if _MSC_VER==1500 && !__INTEL_COMPILER
     // VS2008/VC9 seems to have an issue; limits pull in math.h
     #pragma warning( push )
@@ -74,7 +75,7 @@ namespace internal {
     //! Exception helper function
     template<typename T>
     void handle_unconstructed_elements(T* array, size_t n_of_elements){
-        std::memset((void*) array, 0, n_of_elements * sizeof( T ));
+        std::memset( static_cast<void*>(array), 0, n_of_elements * sizeof( T ) );
     }
 
     //! Base class of concurrent vector implementation.
@@ -94,11 +95,11 @@ namespace internal {
             pointers_per_short_table = 3, // to fit into 8 words of entire structure
             pointers_per_long_table = sizeof(segment_index_t) * 8 // one segment per bit
         };
-    public:
+
         struct segment_not_used {};
         struct segment_allocated {};
         struct segment_allocation_failed {};
-    protected:
+
         class segment_t;
         class segment_value_t {
             void* array;
@@ -340,6 +341,14 @@ namespace internal {
             my_item(other.my_item)
         {}
 
+        vector_iterator& operator=( const vector_iterator<Container,typename Container::value_type>& other )
+        {
+            my_vector=other.my_vector;
+            my_index=other.my_index;
+            my_item=other.my_item;
+            return *this;
+        }
+
         vector_iterator operator+( ptrdiff_t offset ) const {
             return vector_iterator( *my_vector, my_index+offset );
         }
@@ -467,12 +476,9 @@ namespace internal {
     template<typename T, class A>
     class allocator_base {
     public:
-        typedef typename A::template
-            rebind<T>::other allocator_type;
+        typedef typename tbb::internal::allocator_rebind<A, T>::type allocator_type;
         allocator_type my_allocator;
-
         allocator_base(const allocator_type &a = allocator_type() ) : my_allocator(a) {}
-
     };
 
 } // namespace internal
@@ -671,7 +677,7 @@ class concurrent_vector: protected internal::allocator_base<T, A>,
 
     //! Copying constructor for vector with different allocator type
     template<class M>
-    concurrent_vector( const concurrent_vector<T, M>& vector, const allocator_type& a = allocator_type() )
+    __TBB_DEPRECATED concurrent_vector( const concurrent_vector<T, M>& vector, const allocator_type& a = allocator_type() )
         : internal::allocator_base<T, A>(a), internal::concurrent_vector_base()
     {
         vector_allocator_ptr = &internal_allocator;
@@ -742,9 +748,7 @@ class concurrent_vector: protected internal::allocator_base<T, A>,
         if(pocma_t::value || this->my_allocator == other.my_allocator) {
             concurrent_vector trash (std::move(*this));
             internal_swap(other);
-            if (pocma_t::value) {
-                this->my_allocator = std::move(other.my_allocator);
-            }
+            tbb::internal::allocator_move_assignment(this->my_allocator, other.my_allocator, pocma_t());
         } else {
             internal_assign(other, sizeof(T), &destroy_array, &move_assign_array, &move_array);
         }
@@ -755,7 +759,7 @@ class concurrent_vector: protected internal::allocator_base<T, A>,
 
     //! Assignment for vector with different allocator type
     template<class M>
-    concurrent_vector& operator=( const concurrent_vector<T, M>& vector ) {
+    __TBB_DEPRECATED concurrent_vector& operator=( const concurrent_vector<T, M>& vector ) {
         if( static_cast<void*>( this ) != static_cast<const void*>( &vector ) )
             internal_assign(vector.internal_vector_base(),
                 sizeof(T), &destroy_array, &assign_array, &copy_array);
@@ -1002,10 +1006,10 @@ class concurrent_vector: protected internal::allocator_base<T, A>,
 
     //! swap two instances
     void swap(concurrent_vector &vector) {
-        using std::swap;
-        if( this != &vector ) {
+        typedef typename tbb::internal::allocator_traits<A>::propagate_on_container_swap pocs_t;
+        if( this != &vector && (this->my_allocator == vector.my_allocator || pocs_t::value) ) {
             concurrent_vector_base_v3::internal_swap(static_cast<concurrent_vector_base_v3&>(vector));
-            swap(this->my_allocator, vector.my_allocator);
+            tbb::internal::allocator_swap(this->my_allocator, vector.my_allocator, pocs_t());
         }
     }
 
@@ -1042,7 +1046,13 @@ class concurrent_vector: protected internal::allocator_base<T, A>,
         internal_resize( n, sizeof(T), max_size(), static_cast<const void*>(p), &destroy_array, p? &initialize_array_by : &initialize_array );
     }
 
-    //! helper class
+    //! True/false function override helper
+    /* Functions declarations:
+     *     void foo(is_integer_tag<true>*);
+     *     void foo(is_integer_tag<false>*);
+     * Usage example:
+     *     foo(static_cast<is_integer_tag<std::numeric_limits<T>::is_integer>*>(0));
+     */
     template<bool B> class is_integer_tag;
 
     //! assign integer items by copying when arguments are treated as iterators. See C++ Standard 2003 23.1.1p9
@@ -1156,6 +1166,25 @@ class concurrent_vector: protected internal::allocator_base<T, A>,
     };
 };
 
+#if __TBB_CPP17_DEDUCTION_GUIDES_PRESENT
+// Deduction guide for the constructor from two iterators
+template<typename I,
+         typename T = typename std::iterator_traits<I>::value_type,
+         typename A = cache_aligned_allocator<T>
+> concurrent_vector(I, I, const A& = A())
+-> concurrent_vector<T, A>;
+
+// Deduction guide for the constructor from a vector and allocator
+template<typename T, typename A1, typename A2>
+concurrent_vector(const concurrent_vector<T, A1> &, const A2 &)
+-> concurrent_vector<T, A2>;
+
+// Deduction guide for the constructor from an initializer_list
+template<typename T, typename A = cache_aligned_allocator<T>
+> concurrent_vector(std::initializer_list<T>, const A& = A())
+-> concurrent_vector<T, A>;
+#endif /* __TBB_CPP17_DEDUCTION_GUIDES_PRESENT */
+
 #if defined(_MSC_VER) && !defined(__INTEL_COMPILER)
 #pragma warning (push)
 #pragma warning (disable: 4701) // potentially uninitialized local variable "old"
@@ -1293,8 +1322,8 @@ void concurrent_vector<T, A>::move_array_if_noexcept( void* dst, const void* src
 template<typename T, class A>
 template<typename I>
 void concurrent_vector<T, A>::copy_range( void* dst, const void* p_type_erased_iterator, size_type n ){
-    I & iterator ((*const_cast<I*>(static_cast<const I*>(p_type_erased_iterator))));
-    internal_loop_guide loop(n, dst); loop.iterate(iterator);
+    internal_loop_guide loop(n, dst);
+    loop.iterate( *(static_cast<I*>(const_cast<void*>(p_type_erased_iterator))) );
 }
 
 template<typename T, class A>
@@ -1360,4 +1389,8 @@ inline void swap(concurrent_vector<T, A> &a, concurrent_vector<T, A> &b)
     #pragma warning (pop)
 #endif // warning 4267,4127 are back
 
+
+#undef __TBB_concurrent_vector_H_include_area
+#include "internal/_warning_suppress_disable_notice.h"
+
 #endif /* __TBB_concurrent_vector_H */
diff --git a/src/tbb/include/tbb/critical_section.h b/src/tbb/include/tbb/critical_section.h
index 324b3e13..fb3332b2 100644
--- a/src/tbb/include/tbb/critical_section.h
+++ b/src/tbb/include/tbb/critical_section.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,15 +12,25 @@
     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 "internal/_deprecated_header_message_guard.h"
 
+#if !defined(__TBB_show_deprecation_message_critical_section_H) && defined(__TBB_show_deprecated_header_message)
+#define  __TBB_show_deprecation_message_critical_section_H
+#pragma message("TBB Warning: tbb/critical_section.h is deprecated. For details, please see Deprecated Features appendix in the TBB reference manual.")
+#endif
 
-
-*/
+#if defined(__TBB_show_deprecated_header_message)
+#undef __TBB_show_deprecated_header_message
+#endif
 
 #ifndef _TBB_CRITICAL_SECTION_H_
 #define _TBB_CRITICAL_SECTION_H_
 
+#define __TBB_critical_section_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #if _WIN32||_WIN64
 #include "machine/windows_api.h"
 #else
@@ -126,8 +136,12 @@ class critical_section_v4 : internal::no_copy {
     static const bool is_fair_mutex = true;
 }; // critical_section_v4
 } // namespace internal
-typedef internal::critical_section_v4 critical_section;
+__TBB_DEPRECATED_IN_VERBOSE_MODE_MSG("tbb::critical_section is deprecated, use std::mutex") typedef internal::critical_section_v4 critical_section;
 
 __TBB_DEFINE_PROFILING_SET_NAME(critical_section)
 } // namespace tbb
+
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_critical_section_H_include_area
+
 #endif  // _TBB_CRITICAL_SECTION_H_
diff --git a/src/tbb/include/tbb/enumerable_thread_specific.h b/src/tbb/include/tbb/enumerable_thread_specific.h
index f31f533b..248597f2 100644
--- a/src/tbb/include/tbb/enumerable_thread_specific.h
+++ b/src/tbb/include/tbb/enumerable_thread_specific.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,15 +12,14 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_enumerable_thread_specific_H
 #define __TBB_enumerable_thread_specific_H
 
+#define __TBB_enumerable_thread_specific_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #include "atomic.h"
 #include "concurrent_vector.h"
 #include "tbb_thread.h"
@@ -32,6 +31,10 @@
 #include "tbb_profiling.h"
 #include <string.h>  // for memcpy
 
+#if __TBB_PREVIEW_RESUMABLE_TASKS
+#include "task.h" // for task::suspend_point
+#endif
+
 #if _WIN32||_WIN64
 #include "machine/windows_api.h"
 #else
@@ -45,7 +48,13 @@
 namespace tbb {
 
 //! enum for selecting between single key and key-per-instance versions
-enum ets_key_usage_type { ets_key_per_instance, ets_no_key };
+enum ets_key_usage_type {
+    ets_key_per_instance
+    , ets_no_key
+#if __TBB_PREVIEW_RESUMABLE_TASKS
+    , ets_suspend_aware
+#endif
+};
 
 namespace interface6 {
 
@@ -58,10 +67,33 @@ namespace interface6 {
 
         using namespace tbb::internal;
 
+        template <ets_key_usage_type ETS_key_type>
+        struct ets_key_selector {
+            typedef tbb_thread::id key_type;
+            static key_type current_key() {
+                return tbb::internal::thread_get_id_v3();
+            }
+        };
+
+#if __TBB_PREVIEW_RESUMABLE_TASKS
+        template <>
+        struct ets_key_selector<ets_suspend_aware> {
+            typedef task::suspend_point key_type;
+            static key_type current_key() {
+                return internal_current_suspend_point();
+            }
+        };
+
+        inline task::suspend_point atomic_compare_and_swap(task::suspend_point& location,
+                const task::suspend_point& value, const task::suspend_point& comparand) {
+            return as_atomic(location).compare_and_swap(value, comparand);
+        }
+#endif
+
         template<ets_key_usage_type ETS_key_type>
         class ets_base: tbb::internal::no_copy {
         protected:
-            typedef tbb_thread::id key_type;
+            typedef typename ets_key_selector<ETS_key_type>::key_type key_type;
 #if __TBB_PROTECTED_NESTED_CLASS_BROKEN
         public:
 #endif
@@ -119,8 +151,9 @@ namespace interface6 {
             void table_clear();
             // The following functions are not used in concurrent context,
             // so we don't need synchronization and ITT annotations there.
+            template <ets_key_usage_type E2>
             void table_elementwise_copy( const ets_base& other,
-                                         void*(*add_element)(ets_base&, void*) ) {
+                                         void*(*add_element)(ets_base<E2>&, void*) ) {
                 __TBB_ASSERT(!my_root,NULL);
                 __TBB_ASSERT(!my_count,NULL);
                 if( !other.my_root ) return;
@@ -135,7 +168,7 @@ namespace interface6 {
                             for( size_t j = root->start(tbb::tbb_hash<key_type>()(s1.key)); ; j=(j+1)&mask ) {
                                 slot& s2 = root->at(j);
                                 if( s2.empty() ) {
-                                    s2.ptr = add_element(*this, s1.ptr);
+                                    s2.ptr = add_element(static_cast<ets_base<E2>&>(*this), s1.ptr);
                                     s2.key = s1.key;
                                     break;
                                 }
@@ -169,7 +202,7 @@ namespace interface6 {
 
         template<ets_key_usage_type ETS_key_type>
         void* ets_base<ETS_key_type>::table_lookup( bool& exists ) {
-            const key_type k = tbb::this_tbb_thread::get_id();
+            const key_type k = ets_key_selector<ETS_key_type>::current_key();
 
             __TBB_ASSERT(k != key_type(),NULL);
             void* found;
@@ -242,7 +275,7 @@ namespace interface6 {
 
         //! Specialization that exploits native TLS
         template <>
-        class ets_base<ets_key_per_instance>: protected ets_base<ets_no_key> {
+        class ets_base<ets_key_per_instance>: public ets_base<ets_no_key> {
             typedef ets_base<ets_no_key> super;
 #if _WIN32||_WIN64
 #if __TBB_WIN8UI_SUPPORT
@@ -799,7 +832,7 @@ namespace interface6 {
             return lref.value_committed();
         }
 
-        static void* create_local_by_copy( internal::ets_base<ets_no_key>& base, void* p ) {
+        static void* create_local_by_copy( internal::ets_base<ETS_key_type>& base, void* p ) {
             enumerable_thread_specific& ets = static_cast<enumerable_thread_specific&>(base);
             padded_element& lref = *ets.my_locals.grow_by(1);
             new(lref.value()) T(*static_cast<T*>(p));
@@ -807,7 +840,7 @@ namespace interface6 {
         }
 
 #if __TBB_ETS_USE_CPP11
-        static void* create_local_by_move( internal::ets_base<ets_no_key>& base, void* p ) {
+        static void* create_local_by_move( internal::ets_base<ETS_key_type>& base, void* p ) {
             enumerable_thread_specific& ets = static_cast<enumerable_thread_specific&>(base);
             padded_element& lref = *ets.my_locals.grow_by(1);
             new(lref.value()) T(std::move(*static_cast<T*>(p)));
@@ -888,7 +921,7 @@ namespace interface6 {
         ~enumerable_thread_specific() {
             if(my_construct_callback) my_construct_callback->destroy();
             // Deallocate the hash table before overridden free_array() becomes inaccessible
-            this->internal::ets_base<ets_no_key>::table_clear();
+            this->internal::ets_base<ETS_key_type>::table_clear();
         }
 
         //! returns reference to local, discarding exists
@@ -1134,4 +1167,7 @@ using interface6::flatten2d;
 
 } // namespace tbb
 
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_enumerable_thread_specific_H_include_area
+
 #endif
diff --git a/src/tbb/include/tbb/flow_graph.h b/src/tbb/include/tbb/flow_graph.h
index fb839ac1..03020f79 100644
--- a/src/tbb/include/tbb/flow_graph.h
+++ b/src/tbb/include/tbb/flow_graph.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,15 +12,14 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_flow_graph_H
 #define __TBB_flow_graph_H
 
+#define __TBB_flow_graph_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #include "tbb_stddef.h"
 #include "atomic.h"
 #include "spin_mutex.h"
@@ -30,11 +29,23 @@
 #include "task.h"
 #include "cache_aligned_allocator.h"
 #include "tbb_exception.h"
+#include "pipeline.h"
 #include "internal/_template_helpers.h"
 #include "internal/_aggregator_impl.h"
+#include "tbb/internal/_allocator_traits.h"
 #include "tbb_profiling.h"
 #include "task_arena.h"
-#include "flow_graph_abstractions.h"
+
+#if TBB_USE_THREADING_TOOLS && TBB_PREVIEW_FLOW_GRAPH_TRACE && ( __linux__ || __APPLE__ )
+   #if __INTEL_COMPILER
+       // Disabled warning "routine is both inline and noinline"
+       #pragma warning (push)
+       #pragma warning( disable: 2196 )
+   #endif
+   #define __TBB_NOINLINE_SYM __attribute__((noinline))
+#else
+   #define __TBB_NOINLINE_SYM
+#endif 
 
 #if __TBB_PREVIEW_ASYNC_MSG
 #include <vector>    // std::vector in internal::async_storage
@@ -54,6 +65,12 @@
 #define FLOW_SPAWN(a) tbb::task::spawn((a))
 #endif
 
+#if TBB_DEPRECATED_FLOW_NODE_ALLOCATOR
+#define __TBB_DEFAULT_NODE_ALLOCATOR(T) cache_aligned_allocator<T>
+#else
+#define __TBB_DEFAULT_NODE_ALLOCATOR(T) null_type
+#endif
+
 // use the VC10 or gcc version of tuple if it is available.
 #if __TBB_CPP11_TUPLE_PRESENT
     #include <tuple>
@@ -88,7 +105,7 @@ namespace flow {
 //! An enumeration the provides the two most common concurrency levels: unlimited and serial
 enum concurrency { unlimited = 0, serial = 1 };
 
-namespace interface10 {
+namespace interface11 {
 
 //! A generic null type
 struct null_type {};
@@ -100,7 +117,9 @@ class continue_msg {};
 template< typename T > class sender;
 template< typename T > class receiver;
 class continue_receiver;
-template< typename T > class limiter_node;  // needed for resetting decrementer
+
+template< typename T, typename U > class limiter_node;  // needed for resetting decrementer
+
 template< typename R, typename B > class run_and_put_task;
 
 namespace internal {
@@ -111,7 +130,15 @@ template<typename T, typename M> class round_robin_cache;
 template<typename T, typename M> class predecessor_cache;
 template<typename T, typename M> class reservable_predecessor_cache;
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+namespace order {
+struct following;
+struct preceding;
+}
+template<typename Order, typename... Args> struct node_set;
+#endif
+
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
 // Holder of edges both for caches and for those nodes which do not have predecessor caches.
 // C == receiver< ... > or sender< ... >, depending.
 template<typename C>
@@ -153,11 +180,11 @@ class edge_container {
 private:
     edge_list_type built_edges;
 };  // class edge_container
-#endif  /* TBB_PREVIEW_FLOW_GRAPH_FEATURES */
+#endif  /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
 
 } // namespace internal
 
-} // namespace interface10
+} // namespace interfaceX
 } // namespace flow
 } // namespace tbb
 
@@ -166,7 +193,7 @@ class edge_container {
 
 namespace tbb {
 namespace flow {
-namespace interface10 {
+namespace interface11 {
 
 // enqueue left task if necessary. Returns the non-enqueued task if there is one.
 static inline tbb::task *combine_tasks(graph& g, tbb::task * left, tbb::task * right) {
@@ -186,7 +213,7 @@ static inline tbb::task *combine_tasks(graph& g, tbb::task * left, tbb::task * r
 
 #if __TBB_PREVIEW_ASYNC_MSG
 
-template < typename T > class async_msg;
+template < typename T > class __TBB_DEPRECATED async_msg;
 
 namespace internal {
 
@@ -301,7 +328,7 @@ class untyped_sender {
     //! Consumes the reserved item
     virtual bool try_consume( ) { return false; }
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
     //! interface to record edges for traversal & deletion
     typedef internal::edge_container<successor_type> built_successors_type;
     typedef built_successors_type::edge_list_type successor_list_type;
@@ -310,7 +337,7 @@ class untyped_sender {
     virtual void    internal_delete_built_successor( successor_type & ) = 0;
     virtual void    copy_successors( successor_list_type &)             = 0;
     virtual size_t  successor_count()                                   = 0;
-#endif
+#endif /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
 protected:
     //! Request an item from the sender
     template< typename X >
@@ -330,7 +357,6 @@ class untyped_sender {
 
 class untyped_receiver  {
     template< typename, typename > friend class run_and_put_task;
-    template< typename > friend class limiter_node;
 
     template< typename, typename > friend class internal::broadcast_cache;
     template< typename, typename > friend class internal::round_robin_cache;
@@ -365,7 +391,7 @@ class untyped_receiver  {
     //! Remove a predecessor from the node
     virtual bool remove_predecessor( predecessor_type & ) { return false; }
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
     typedef internal::edge_container<predecessor_type> built_predecessors_type;
     typedef built_predecessors_type::edge_list_type predecessor_list_type;
     virtual built_predecessors_type &built_predecessors()                  = 0;
@@ -373,7 +399,7 @@ class untyped_receiver  {
     virtual void   internal_delete_built_predecessor( predecessor_type & ) = 0;
     virtual void   copy_predecessors( predecessor_list_type & )            = 0;
     virtual size_t predecessor_count()                                     = 0;
-#endif
+#endif /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
 protected:
     template<typename X>
     task *try_put_task(const X& t) {
@@ -382,7 +408,7 @@ class untyped_receiver  {
 
     virtual task* try_put_task_wrapper( const void* p, bool is_async ) = 0;
 
-    virtual graph& graph_reference() = 0;
+    virtual graph& graph_reference() const = 0;
 
     // NOTE: Following part of PROTECTED and PRIVATE sections is copy-paste from original receiver<T> class
 
@@ -399,9 +425,9 @@ template< typename T >
 class sender : public internal::untyped_sender {
 public:
     //! The output type of this sender
-    typedef T output_type;
+    __TBB_DEPRECATED typedef T output_type;
 
-    typedef typename internal::async_helpers<T>::filtered_type filtered_type;
+    __TBB_DEPRECATED typedef typename internal::async_helpers<T>::filtered_type filtered_type;
 
     //! Request an item from the sender
     virtual bool try_get( T & ) { return false; }
@@ -438,9 +464,9 @@ class receiver : public internal::untyped_receiver {
     template< typename, typename > friend struct internal::async_helpers;
 public:
     //! The input type of this receiver
-    typedef T input_type;
+    __TBB_DEPRECATED typedef T input_type;
 
-    typedef typename internal::async_helpers<T>::filtered_type filtered_type;
+    __TBB_DEPRECATED typedef typename internal::async_helpers<T>::filtered_type filtered_type;
 
     //! Put an item to the receiver
     bool try_put( const typename internal::async_helpers<T>::filtered_type& t ) {
@@ -468,20 +494,20 @@ template< typename T >
 class sender {
 public:
     //! The output type of this sender
-    typedef T output_type;
+    __TBB_DEPRECATED typedef T output_type;
 
     //! The successor type for this node
-    typedef receiver<T> successor_type;
+    __TBB_DEPRECATED typedef receiver<T> successor_type;
 
     virtual ~sender() {}
 
     // NOTE: Following part of PUBLIC section is partly copy-pasted in sender<T> under #if __TBB_PREVIEW_ASYNC_MSG
 
     //! Add a new successor to this node
-    virtual bool register_successor( successor_type &r ) = 0;
+    __TBB_DEPRECATED virtual bool register_successor( successor_type &r ) = 0;
 
     //! Removes a successor from this node
-    virtual bool remove_successor( successor_type &r ) = 0;
+    __TBB_DEPRECATED virtual bool remove_successor( successor_type &r ) = 0;
 
     //! Request an item from the sender
     virtual bool try_get( T & ) { return false; }
@@ -495,16 +521,16 @@ class sender {
     //! Consumes the reserved item
     virtual bool try_consume( ) { return false; }
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
     //! interface to record edges for traversal & deletion
-    typedef typename  internal::edge_container<successor_type> built_successors_type;
-    typedef typename  built_successors_type::edge_list_type successor_list_type;
-    virtual built_successors_type &built_successors()                   = 0;
-    virtual void    internal_add_built_successor( successor_type & )    = 0;
-    virtual void    internal_delete_built_successor( successor_type & ) = 0;
-    virtual void    copy_successors( successor_list_type &)             = 0;
-    virtual size_t  successor_count()                                   = 0;
-#endif
+    __TBB_DEPRECATED typedef typename  internal::edge_container<successor_type> built_successors_type;
+    __TBB_DEPRECATED typedef typename  built_successors_type::edge_list_type successor_list_type;
+    __TBB_DEPRECATED virtual built_successors_type &built_successors()                   = 0;
+    __TBB_DEPRECATED virtual void    internal_add_built_successor( successor_type & )    = 0;
+    __TBB_DEPRECATED virtual void    internal_delete_built_successor( successor_type & ) = 0;
+    __TBB_DEPRECATED virtual void    copy_successors( successor_list_type &)             = 0;
+    __TBB_DEPRECATED virtual size_t  successor_count()                                   = 0;
+#endif /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
 };  // class sender<T>
 
 //! Pure virtual template class that defines a receiver of messages of type T
@@ -512,10 +538,10 @@ template< typename T >
 class receiver {
 public:
     //! The input type of this receiver
-    typedef T input_type;
+    __TBB_DEPRECATED typedef T input_type;
 
     //! The predecessor type for this node
-    typedef sender<T> predecessor_type;
+    __TBB_DEPRECATED typedef sender<T> predecessor_type;
 
     //! Destructor
     virtual ~receiver() {}
@@ -534,29 +560,28 @@ class receiver {
     template< typename X, typename Y > friend class internal::broadcast_cache;
     template< typename X, typename Y > friend class internal::round_robin_cache;
     virtual task *try_put_task(const T& t) = 0;
-    virtual graph& graph_reference() = 0;
+    virtual graph& graph_reference() const = 0;
 public:
     // NOTE: Following part of PUBLIC and PROTECTED sections is copy-pasted in receiver<T> under #if __TBB_PREVIEW_ASYNC_MSG
 
     //! Add a predecessor to the node
-    virtual bool register_predecessor( predecessor_type & ) { return false; }
+    __TBB_DEPRECATED virtual bool register_predecessor( predecessor_type & ) { return false; }
 
     //! Remove a predecessor from the node
-    virtual bool remove_predecessor( predecessor_type & ) { return false; }
-
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
-    typedef typename internal::edge_container<predecessor_type> built_predecessors_type;
-    typedef typename built_predecessors_type::edge_list_type predecessor_list_type;
-    virtual built_predecessors_type &built_predecessors()                  = 0;
-    virtual void   internal_add_built_predecessor( predecessor_type & )    = 0;
-    virtual void   internal_delete_built_predecessor( predecessor_type & ) = 0;
-    virtual void   copy_predecessors( predecessor_list_type & )            = 0;
-    virtual size_t predecessor_count()                                     = 0;
-#endif
+    __TBB_DEPRECATED virtual bool remove_predecessor( predecessor_type & ) { return false; }
+
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
+    __TBB_DEPRECATED typedef typename internal::edge_container<predecessor_type> built_predecessors_type;
+    __TBB_DEPRECATED typedef typename built_predecessors_type::edge_list_type predecessor_list_type;
+    __TBB_DEPRECATED virtual built_predecessors_type &built_predecessors()                  = 0;
+    __TBB_DEPRECATED virtual void   internal_add_built_predecessor( predecessor_type & )    = 0;
+    __TBB_DEPRECATED virtual void   internal_delete_built_predecessor( predecessor_type & ) = 0;
+    __TBB_DEPRECATED virtual void   copy_predecessors( predecessor_list_type & )            = 0;
+    __TBB_DEPRECATED virtual size_t predecessor_count()                                     = 0;
+#endif /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
 
 protected:
     //! put receiver back in initial state
-    template<typename U> friend class limiter_node;
     virtual void reset_receiver(reset_flags f = rf_reset_protocol) = 0;
 
     template<typename TT, typename M> friend class internal::successor_cache;
@@ -575,25 +600,28 @@ class continue_receiver : public receiver< continue_msg > {
 public:
 
     //! The input type
-    typedef continue_msg input_type;
+    __TBB_DEPRECATED typedef continue_msg input_type;
 
     //! The predecessor type for this node
-    typedef receiver<input_type>::predecessor_type predecessor_type;
+    __TBB_DEPRECATED typedef receiver<input_type>::predecessor_type predecessor_type;
 
     //! Constructor
-    explicit continue_receiver( int number_of_predecessors = 0 ) {
+    __TBB_DEPRECATED explicit continue_receiver(
+        __TBB_FLOW_GRAPH_PRIORITY_ARG1(int number_of_predecessors, node_priority_t priority)) {
         my_predecessor_count = my_initial_predecessor_count = number_of_predecessors;
         my_current_count = 0;
+        __TBB_FLOW_GRAPH_PRIORITY_EXPR( my_priority = priority; )
     }
 
     //! Copy constructor
-    continue_receiver( const continue_receiver& src ) : receiver<continue_msg>() {
+    __TBB_DEPRECATED continue_receiver( const continue_receiver& src ) : receiver<continue_msg>() {
         my_predecessor_count = my_initial_predecessor_count = src.my_initial_predecessor_count;
         my_current_count = 0;
+        __TBB_FLOW_GRAPH_PRIORITY_EXPR( my_priority = src.my_priority; )
     }
 
     //! Increments the trigger threshold
-    bool register_predecessor( predecessor_type & ) __TBB_override {
+    __TBB_DEPRECATED bool register_predecessor( predecessor_type & ) __TBB_override {
         spin_mutex::scoped_lock l(my_mutex);
         ++my_predecessor_count;
         return true;
@@ -603,38 +631,38 @@ class continue_receiver : public receiver< continue_msg > {
     /** Does not check to see if the removal of the predecessor now makes the current count
         exceed the new threshold.  So removing a predecessor while the graph is active can cause
         unexpected results. */
-    bool remove_predecessor( predecessor_type & ) __TBB_override {
+    __TBB_DEPRECATED bool remove_predecessor( predecessor_type & ) __TBB_override {
         spin_mutex::scoped_lock l(my_mutex);
         --my_predecessor_count;
         return true;
     }
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
-    typedef internal::edge_container<predecessor_type> built_predecessors_type;
-    typedef built_predecessors_type::edge_list_type predecessor_list_type;
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
+    __TBB_DEPRECATED typedef internal::edge_container<predecessor_type> built_predecessors_type;
+    __TBB_DEPRECATED typedef built_predecessors_type::edge_list_type predecessor_list_type;
     built_predecessors_type &built_predecessors() __TBB_override { return my_built_predecessors; }
 
-    void internal_add_built_predecessor( predecessor_type &s) __TBB_override {
+    __TBB_DEPRECATED void internal_add_built_predecessor( predecessor_type &s) __TBB_override {
         spin_mutex::scoped_lock l(my_mutex);
         my_built_predecessors.add_edge( s );
     }
 
-    void internal_delete_built_predecessor( predecessor_type &s) __TBB_override {
+    __TBB_DEPRECATED void internal_delete_built_predecessor( predecessor_type &s) __TBB_override {
         spin_mutex::scoped_lock l(my_mutex);
         my_built_predecessors.delete_edge(s);
     }
 
-    void copy_predecessors( predecessor_list_type &v) __TBB_override {
+    __TBB_DEPRECATED void copy_predecessors( predecessor_list_type &v) __TBB_override {
         spin_mutex::scoped_lock l(my_mutex);
         my_built_predecessors.copy_edges(v);
     }
 
-    size_t predecessor_count() __TBB_override {
+    __TBB_DEPRECATED size_t predecessor_count() __TBB_override {
         spin_mutex::scoped_lock l(my_mutex);
         return my_built_predecessors.edge_count();
     }
 
-#endif  /* TBB_PREVIEW_FLOW_GRAPH_FEATURES */
+#endif  /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
 
 protected:
     template< typename R, typename B > friend class run_and_put_task;
@@ -653,7 +681,7 @@ class continue_receiver : public receiver< continue_msg > {
         return res? res : SUCCESSFULLY_ENQUEUED;
     }
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
     // continue_receiver must contain its own built_predecessors because it does
     // not have a node_cache.
     built_predecessors_type my_built_predecessors;
@@ -662,14 +690,15 @@ class continue_receiver : public receiver< continue_msg > {
     int my_predecessor_count;
     int my_current_count;
     int my_initial_predecessor_count;
+    __TBB_FLOW_GRAPH_PRIORITY_EXPR( node_priority_t my_priority; )
     // the friend declaration in the base class did not eliminate the "protected class"
     // error in gcc 4.1.2
-    template<typename U> friend class limiter_node;
+    template<typename U, typename V> friend class tbb::flow::interface11::limiter_node;
 
     void reset_receiver( reset_flags f ) __TBB_override {
         my_current_count = 0;
         if (f & rf_clear_edges) {
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
             my_built_predecessors.clear();
 #endif
             my_predecessor_count = my_initial_predecessor_count;
@@ -694,9 +723,9 @@ class continue_receiver : public receiver< continue_msg > {
     }
 #endif /* __TBB_PREVIEW_MESSAGE_BASED_KEY_MATCHING */
 
-    using interface10::sender;
-    using interface10::receiver;
-    using interface10::continue_receiver;
+    using interface11::sender;
+    using interface11::receiver;
+    using interface11::continue_receiver;
 }  // flow
 }  // tbb
 
@@ -705,7 +734,7 @@ class continue_receiver : public receiver< continue_msg > {
 
 namespace tbb {
 namespace flow {
-namespace interface10 {
+namespace interface11 {
 
 #include "internal/_flow_graph_body_impl.h"
 #include "internal/_flow_graph_cache_impl.h"
@@ -738,13 +767,16 @@ void graph_iterator<C,N>::internal_forward() {
     if (current_node) current_node = current_node->next;
 }
 
+} // namespace interfaceX
+
+namespace interface10 {
 //! Constructs a graph with isolated task_group_context
 inline graph::graph() : my_nodes(NULL), my_nodes_last(NULL), my_task_arena(NULL) {
     prepare_task_arena();
     own_context = true;
     cancelled = false;
     caught_exception = false;
-    my_context = new task_group_context();
+    my_context = new task_group_context(tbb::internal::FLOW_TASKS);
     my_root_task = (new (task::allocate_root(*my_context)) empty_task);
     my_root_task->set_ref_count(1);
     tbb::internal::fgt_graph(this);
@@ -755,13 +787,23 @@ inline graph::graph(task_group_context& use_this_context) :
     my_context(&use_this_context), my_nodes(NULL), my_nodes_last(NULL), my_task_arena(NULL) {
     prepare_task_arena();
     own_context = false;
+    cancelled = false;
+    caught_exception = false;
     my_root_task = (new (task::allocate_root(*my_context)) empty_task);
     my_root_task->set_ref_count(1);
     tbb::internal::fgt_graph(this);
     my_is_active = true;
 }
 
-inline  void graph::reserve_wait() {
+inline graph::~graph() {
+    wait_for_all();
+    my_root_task->set_ref_count(0);
+    tbb::task::destroy(*my_root_task);
+    if (own_context) delete my_context;
+    delete my_task_arena;
+}
+
+inline void graph::reserve_wait() {
     if (my_root_task) {
         my_root_task->increment_ref_count();
         tbb::internal::fgt_reserve_wait(this);
@@ -775,7 +817,7 @@ inline void graph::release_wait() {
     }
 }
 
-inline void graph::register_node(graph_node *n) {
+inline void graph::register_node(tbb::flow::interface11::graph_node *n) {
     n->next = NULL;
     {
         spin_mutex::scoped_lock lock(nodelist_mutex);
@@ -786,7 +828,7 @@ inline void graph::register_node(graph_node *n) {
     }
 }
 
-inline void graph::remove_node(graph_node *n) {
+inline void graph::remove_node(tbb::flow::interface11::graph_node *n) {
     {
         spin_mutex::scoped_lock lock(nodelist_mutex);
         __TBB_ASSERT(my_nodes && my_nodes_last, "graph::remove_node: Error: no registered nodes");
@@ -798,40 +840,68 @@ inline void graph::remove_node(graph_node *n) {
     n->prev = n->next = NULL;
 }
 
-inline void graph::reset( reset_flags f ) {
+inline void graph::reset( tbb::flow::interface11::reset_flags f ) {
     // reset context
-    internal::deactivate_graph(*this);
+    tbb::flow::interface11::internal::deactivate_graph(*this);
 
     if(my_context) my_context->reset();
     cancelled = false;
     caught_exception = false;
     // reset all the nodes comprising the graph
     for(iterator ii = begin(); ii != end(); ++ii) {
-        graph_node *my_p = &(*ii);
+        tbb::flow::interface11::graph_node *my_p = &(*ii);
         my_p->reset_node(f);
     }
     // Reattach the arena. Might be useful to run the graph in a particular task_arena
     // while not limiting graph lifetime to a single task_arena::execute() call.
     prepare_task_arena( /*reinit=*/true );
-    internal::activate_graph(*this);
+    tbb::flow::interface11::internal::activate_graph(*this);
     // now spawn the tasks necessary to start the graph
     for(task_list_type::iterator rti = my_reset_task_list.begin(); rti != my_reset_task_list.end(); ++rti) {
-        my_task_arena->execute(graph::spawn_functor(*(*rti)));
+        tbb::flow::interface11::internal::spawn_in_graph_arena(*this, *(*rti));
     }
     my_reset_task_list.clear();
 }
 
+inline graph::iterator graph::begin() { return iterator(this, true); }
+
+inline graph::iterator graph::end() { return iterator(this, false); }
+
+inline graph::const_iterator graph::begin() const { return const_iterator(this, true); }
+
+inline graph::const_iterator graph::end() const { return const_iterator(this, false); }
+
+inline graph::const_iterator graph::cbegin() const { return const_iterator(this, true); }
+
+inline graph::const_iterator graph::cend() const { return const_iterator(this, false); }
+
 #if TBB_PREVIEW_FLOW_GRAPH_TRACE
 inline void graph::set_name(const char *name) {
     tbb::internal::fgt_graph_desc(this, name);
 }
 #endif
 
+} // namespace interface10
+
+namespace interface11 {
+
+inline graph_node::graph_node(graph& g) : my_graph(g) {
+    my_graph.register_node(this);
+}
+
+inline graph_node::~graph_node() {
+    my_graph.remove_node(this);
+}
+
 #include "internal/_flow_graph_node_impl.h"
 
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+using internal::node_set;
+#endif
+
 //! An executable node that acts as a source, i.e. it has no predecessors
 template < typename Output >
-class source_node : public graph_node, public sender< Output > {
+class input_node : public graph_node, public sender< Output > {
 public:
     //! The type of the output message, which is complete
     typedef Output output_type;
@@ -842,38 +912,46 @@ class source_node : public graph_node, public sender< Output > {
     //Source node has no input type
     typedef null_type input_type;
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
     typedef typename sender<output_type>::built_successors_type built_successors_type;
     typedef typename sender<output_type>::successor_list_type successor_list_type;
 #endif
 
     //! Constructor for a node with a successor
     template< typename Body >
-    source_node( graph &g, Body body, bool is_active = true )
-        : graph_node(g), my_active(is_active), init_my_active(is_active),
-        my_body( new internal::source_body_leaf< output_type, Body>(body) ),
-        my_init_body( new internal::source_body_leaf< output_type, Body>(body) ),
+     __TBB_NOINLINE_SYM input_node( graph &g, Body body )
+        : graph_node(g), my_active(false),
+        my_body( new internal::input_body_leaf< output_type, Body>(body) ),
+        my_init_body( new internal::input_body_leaf< output_type, Body>(body) ),
         my_reserved(false), my_has_cached_item(false)
     {
         my_successors.set_owner(this);
-        tbb::internal::fgt_node_with_body( tbb::internal::FLOW_SOURCE_NODE, &this->my_graph,
+        tbb::internal::fgt_node_with_body( CODEPTR(), tbb::internal::FLOW_SOURCE_NODE, &this->my_graph,
                                            static_cast<sender<output_type> *>(this), this->my_body );
     }
 
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+    template <typename Body, typename... Successors>
+    input_node( const node_set<internal::order::preceding, Successors...>& successors, Body body )
+        : input_node(successors.graph_reference(), body) {
+        make_edges(*this, successors);
+    }
+#endif
+
     //! Copy constructor
-    source_node( const source_node& src ) :
+    __TBB_NOINLINE_SYM input_node( const input_node& src ) :
         graph_node(src.my_graph), sender<Output>(),
-        my_active(src.init_my_active),
-        init_my_active(src.init_my_active), my_body( src.my_init_body->clone() ), my_init_body(src.my_init_body->clone() ),
+        my_active(false),
+        my_body( src.my_init_body->clone() ), my_init_body(src.my_init_body->clone() ),
         my_reserved(false), my_has_cached_item(false)
     {
         my_successors.set_owner(this);
-        tbb::internal::fgt_node_with_body( tbb::internal::FLOW_SOURCE_NODE, &this->my_graph,
+        tbb::internal::fgt_node_with_body(CODEPTR(), tbb::internal::FLOW_SOURCE_NODE, &this->my_graph,
                                            static_cast<sender<output_type> *>(this), this->my_body );
     }
 
     //! The destructor
-    ~source_node() { delete my_body; delete my_init_body; }
+    ~input_node() { delete my_body; delete my_init_body; }
 
 #if TBB_PREVIEW_FLOW_GRAPH_TRACE
     void set_name( const char *name ) __TBB_override {
@@ -897,7 +975,7 @@ class source_node : public graph_node, public sender< Output > {
         return true;
     }
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
 
     built_successors_type &built_successors() __TBB_override { return my_successors.built_successors(); }
 
@@ -920,7 +998,7 @@ class source_node : public graph_node, public sender< Output > {
         spin_mutex::scoped_lock l(my_mutex);
         my_successors.copy_successors(v);
     }
-#endif  /* TBB_PREVIEW_FLOW_GRAPH_FEATURES */
+#endif  /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
 
     //! Request an item from the node
     bool try_get( output_type &v ) __TBB_override {
@@ -935,7 +1013,8 @@ class source_node : public graph_node, public sender< Output > {
         }
         // we've been asked to provide an item, but we have none.  enqueue a task to
         // provide one.
-        spawn_put();
+        if ( my_active )
+            spawn_put();
         return false;
     }
 
@@ -988,14 +1067,14 @@ class source_node : public graph_node, public sender< Output > {
 
     template<typename Body>
     Body copy_function_object() {
-        internal::source_body<output_type> &body_ref = *this->my_body;
-        return dynamic_cast< internal::source_body_leaf<output_type, Body> & >(body_ref).get_body();
+        internal::input_body<output_type> &body_ref = *this->my_body;
+        return dynamic_cast< internal::input_body_leaf<output_type, Body> & >(body_ref).get_body();
     }
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
     void extract( ) __TBB_override {
         my_successors.built_successors().sender_extract(*this);   // removes "my_owner" == this from each successor
-        my_active = init_my_active;
+        my_active = false;
         my_reserved = false;
         if(my_has_cached_item) my_has_cached_item = false;
     }
@@ -1003,29 +1082,25 @@ class source_node : public graph_node, public sender< Output > {
 
 protected:
 
-    //! resets the source_node to its initial state
+    //! resets the input_node to its initial state
     void reset_node( reset_flags f) __TBB_override {
-        my_active = init_my_active;
-        my_reserved =false;
-        if(my_has_cached_item) {
-            my_has_cached_item = false;
-        }
+        my_active = false;
+        my_reserved = false;
+        my_has_cached_item = false;
+
         if(f & rf_clear_edges) my_successors.clear();
         if(f & rf_reset_bodies) {
-            internal::source_body<output_type> *tmp = my_init_body->clone();
+            internal::input_body<output_type> *tmp = my_init_body->clone();
             delete my_body;
             my_body = tmp;
         }
-        if(my_active)
-            internal::add_task_to_graph_reset_list(this->my_graph, create_put_task());
     }
 
 private:
     spin_mutex my_mutex;
     bool my_active;
-    bool init_my_active;
-    internal::source_body<output_type> *my_body;
-    internal::source_body<output_type> *my_init_body;
+    internal::input_body<output_type> *my_body;
+    internal::input_body<output_type> *my_init_body;
     internal::broadcast_cache< output_type > my_successors;
     bool my_reserved;
     bool my_has_cached_item;
@@ -1039,11 +1114,18 @@ class source_node : public graph_node, public sender< Output > {
         }
         if ( !my_has_cached_item ) {
             tbb::internal::fgt_begin_body( my_body );
+
+#if TBB_DEPRECATED_INPUT_NODE_BODY
             bool r = (*my_body)(my_cached_item);
-            tbb::internal::fgt_end_body( my_body );
             if (r) {
                 my_has_cached_item = true;
             }
+#else
+            flow_control control;
+            my_cached_item = (*my_body)(control);
+            my_has_cached_item = !control.is_pipeline_stopped;
+#endif
+            tbb::internal::fgt_end_body( my_body );
         }
         if ( my_has_cached_item ) {
             v = my_cached_item;
@@ -1054,13 +1136,9 @@ class source_node : public graph_node, public sender< Output > {
         }
     }
 
-    // when resetting, and if the source_node was created with my_active == true, then
-    // when we reset the node we must store a task to run the node, and spawn it only
-    // after the reset is complete and is_active() is again true.  This is why we don't
-    // test for is_active() here.
     task* create_put_task() {
         return ( new ( task::allocate_additional_child_of( *(this->my_graph.root_task()) ) )
-                        internal:: source_task_bypass < source_node< output_type > >( *this ) );
+                        internal:: source_task_bypass < input_node< output_type > >( *this ) );
     }
 
     //! Spawns a task that applies the body
@@ -1070,7 +1148,7 @@ class source_node : public graph_node, public sender< Output > {
         }
     }
 
-    friend class internal::source_task_bypass< source_node< output_type > >;
+    friend class internal::source_task_bypass< input_node< output_type > >;
     //! Applies the body.  Returning SUCCESSFULLY_ENQUEUED okay; forward_task_bypass will handle it.
     task * apply_body_bypass( ) {
         output_type v;
@@ -1084,267 +1162,377 @@ class source_node : public graph_node, public sender< Output > {
             try_release();
         return last_task;
     }
-};  // class source_node
+};  // class input_node
 
-template<typename T>
-struct allocate_buffer {
-    static const bool value = false;
-};
+#if TBB_USE_SOURCE_NODE_AS_ALIAS
+template < typename Output >
+class source_node : public input_node <Output> {
+public:
+    //! Constructor for a node with a successor
+    template< typename Body >
+     __TBB_NOINLINE_SYM source_node( graph &g, Body body )
+         : input_node<Output>(g, body)
+    {
+    }
 
-template<>
-struct allocate_buffer<queueing> {
-    static const bool value = true;
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+    template <typename Body, typename... Successors>
+    source_node( const node_set<internal::order::preceding, Successors...>& successors, Body body )
+        : input_node<Output>(successors, body) {
+     }
+#endif
 };
-
-//! Implements a function node that supports Input -> Output
-template < typename Input, typename Output = continue_msg, typename Policy = queueing, typename Allocator=cache_aligned_allocator<Input> >
-class function_node : public graph_node, public internal::function_input<Input,Output,Allocator>, public internal::function_output<Output> {
+#else // TBB_USE_SOURCE_NODE_AS_ALIAS
+//! An executable node that acts as a source, i.e. it has no predecessors
+template < typename Output > class
+__TBB_DEPRECATED_MSG("TBB Warning: tbb::flow::source_node is deprecated, use tbb::flow::input_node." )
+source_node : public graph_node, public sender< Output > {
 public:
-    typedef Input input_type;
+    //! The type of the output message, which is complete
     typedef Output output_type;
-    typedef internal::function_input<input_type,output_type,Allocator> fInput_type;
-    typedef internal::function_input_queue<input_type, Allocator> input_queue_type;
-    typedef internal::function_output<output_type> fOutput_type;
-    typedef typename fInput_type::predecessor_type predecessor_type;
-    typedef typename fOutput_type::successor_type successor_type;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
-    typedef typename fInput_type::predecessor_list_type predecessor_list_type;
-    typedef typename fOutput_type::successor_list_type successor_list_type;
+
+    //! The type of successors of this node
+    typedef typename sender<output_type>::successor_type successor_type;
+
+    //Source node has no input type
+    typedef null_type input_type;
+
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
+    typedef typename sender<output_type>::built_successors_type built_successors_type;
+    typedef typename sender<output_type>::successor_list_type successor_list_type;
 #endif
-    using fInput_type::my_predecessors;
 
-    //! Constructor
-    // input_queue_type is allocated here, but destroyed in the function_input_base.
-    // TODO: pass the graph_buffer_policy to the function_input_base so it can all
-    // be done in one place.  This would be an interface-breaking change.
+    //! Constructor for a node with a successor
     template< typename Body >
-    function_node( graph &g, size_t concurrency, Body body ) :
-        graph_node(g), fInput_type(g, concurrency, body, allocate_buffer<Policy>::value ?
-               new input_queue_type( ) : NULL ) {
-        tbb::internal::fgt_node_with_body( tbb::internal::FLOW_FUNCTION_NODE, &this->my_graph,
-                static_cast<receiver<input_type> *>(this), static_cast<sender<output_type> *>(this), this->my_body );
+     __TBB_NOINLINE_SYM source_node( graph &g, Body body, bool is_active = true )
+        : graph_node(g), my_active(is_active), init_my_active(is_active),
+        my_body( new internal::source_body_leaf< output_type, Body>(body) ),
+        my_init_body( new internal::source_body_leaf< output_type, Body>(body) ),
+        my_reserved(false), my_has_cached_item(false)
+    {
+        my_successors.set_owner(this);
+	tbb::internal::fgt_node_with_body( CODEPTR(), tbb::internal::FLOW_SOURCE_NODE, &this->my_graph,
+                                           static_cast<sender<output_type> *>(this), this->my_body );
+    }
+
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+    template <typename Body, typename... Successors>
+    source_node( const node_set<internal::order::preceding, Successors...>& successors, Body body, bool is_active = true )
+        : source_node(successors.graph_reference(), body, is_active) {
+        make_edges(*this, successors);
     }
+#endif
 
     //! Copy constructor
-    function_node( const function_node& src ) :
-        graph_node(src.my_graph),
-        fInput_type(src, allocate_buffer<Policy>::value ? new input_queue_type : NULL),
-        fOutput_type() {
-        tbb::internal::fgt_node_with_body( tbb::internal::FLOW_FUNCTION_NODE, &this->my_graph,
-                static_cast<receiver<input_type> *>(this), static_cast<sender<output_type> *>(this), this->my_body );
+    __TBB_NOINLINE_SYM source_node( const source_node& src ) :
+        graph_node(src.my_graph), sender<Output>(),
+        my_active(src.init_my_active),
+        init_my_active(src.init_my_active), my_body( src.my_init_body->clone() ), my_init_body(src.my_init_body->clone() ),
+        my_reserved(false), my_has_cached_item(false)
+    {
+        my_successors.set_owner(this);
+        tbb::internal::fgt_node_with_body(CODEPTR(), tbb::internal::FLOW_SOURCE_NODE, &this->my_graph,
+                                           static_cast<sender<output_type> *>(this), this->my_body );
     }
 
+    //! The destructor
+    ~source_node() { delete my_body; delete my_init_body; }
+
 #if TBB_PREVIEW_FLOW_GRAPH_TRACE
     void set_name( const char *name ) __TBB_override {
         tbb::internal::fgt_node_desc( this, name );
     }
 #endif
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
-    void extract( ) __TBB_override {
-        my_predecessors.built_predecessors().receiver_extract(*this);
-        successors().built_successors().sender_extract(*this);
+    //! Add a new successor to this node
+    bool register_successor( successor_type &r ) __TBB_override {
+        spin_mutex::scoped_lock lock(my_mutex);
+        my_successors.register_successor(r);
+        if ( my_active )
+            spawn_put();
+        return true;
     }
-#endif
-
-protected:
-    template< typename R, typename B > friend class run_and_put_task;
-    template<typename X, typename Y> friend class internal::broadcast_cache;
-    template<typename X, typename Y> friend class internal::round_robin_cache;
-    using fInput_type::try_put_task;
 
-    internal::broadcast_cache<output_type> &successors () __TBB_override { return fOutput_type::my_successors; }
-
-    void reset_node(reset_flags f) __TBB_override {
-        fInput_type::reset_function_input(f);
-        // TODO: use clear() instead.
-        if(f & rf_clear_edges) {
-            successors().clear();
-            my_predecessors.clear();
-        }
-        __TBB_ASSERT(!(f & rf_clear_edges) || successors().empty(), "function_node successors not empty");
-        __TBB_ASSERT(this->my_predecessors.empty(), "function_node predecessors not empty");
+    //! Removes a successor from this node
+    bool remove_successor( successor_type &r ) __TBB_override {
+        spin_mutex::scoped_lock lock(my_mutex);
+        my_successors.remove_successor(r);
+        return true;
     }
 
-};  // class function_node
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
 
-//! implements a function node that supports Input -> (set of outputs)
-// Output is a tuple of output types.
-template < typename Input, typename Output, typename Policy = queueing, typename Allocator=cache_aligned_allocator<Input> >
-class multifunction_node :
-    public graph_node,
-    public internal::multifunction_input
-    <
-        Input,
-        typename internal::wrap_tuple_elements<
-            tbb::flow::tuple_size<Output>::value,  // #elements in tuple
-            internal::multifunction_output,  // wrap this around each element
-            Output // the tuple providing the types
-        >::type,
-        Allocator
-    > {
-protected:
-    static const int N = tbb::flow::tuple_size<Output>::value;
-public:
-    typedef Input input_type;
-    typedef null_type output_type;
-    typedef typename internal::wrap_tuple_elements<N,internal::multifunction_output, Output>::type output_ports_type;
-    typedef internal::multifunction_input<input_type, output_ports_type, Allocator> fInput_type;
-    typedef internal::function_input_queue<input_type, Allocator> input_queue_type;
-private:
-    typedef typename internal::multifunction_input<input_type, output_ports_type, Allocator> base_type;
-    using fInput_type::my_predecessors;
-public:
-    template<typename Body>
-    multifunction_node( graph &g, size_t concurrency, Body body ) :
-        graph_node(g), base_type(g,concurrency, body,  allocate_buffer<Policy>::value ? new input_queue_type : NULL) {
-        tbb::internal::fgt_multioutput_node_with_body<N>( tbb::internal::FLOW_MULTIFUNCTION_NODE,
-                &this->my_graph, static_cast<receiver<input_type> *>(this),
-                this->output_ports(), this->my_body );
+    built_successors_type &built_successors() __TBB_override { return my_successors.built_successors(); }
+
+    void internal_add_built_successor( successor_type &r) __TBB_override {
+        spin_mutex::scoped_lock lock(my_mutex);
+        my_successors.internal_add_built_successor(r);
     }
 
-    multifunction_node( const multifunction_node &other) :
-        graph_node(other.my_graph), base_type(other,  allocate_buffer<Policy>::value ? new input_queue_type : NULL) {
-        tbb::internal::fgt_multioutput_node_with_body<N>( tbb::internal::FLOW_MULTIFUNCTION_NODE,
-                &this->my_graph, static_cast<receiver<input_type> *>(this),
-                this->output_ports(), this->my_body );
+    void internal_delete_built_successor( successor_type &r) __TBB_override {
+        spin_mutex::scoped_lock lock(my_mutex);
+        my_successors.internal_delete_built_successor(r);
     }
 
-#if TBB_PREVIEW_FLOW_GRAPH_TRACE
-    void set_name( const char *name ) __TBB_override {
-        tbb::internal::fgt_multioutput_node_desc( this, name );
+    size_t successor_count() __TBB_override {
+        spin_mutex::scoped_lock lock(my_mutex);
+        return my_successors.successor_count();
     }
-#endif
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
-    void extract( ) __TBB_override {
-        my_predecessors.built_predecessors().receiver_extract(*this);
-        base_type::extract();
+    void copy_successors(successor_list_type &v) __TBB_override {
+        spin_mutex::scoped_lock l(my_mutex);
+        my_successors.copy_successors(v);
     }
-#endif
-    // all the guts are in multifunction_input...
-protected:
-    void reset_node(reset_flags f) __TBB_override { base_type::reset(f); }
-};  // multifunction_node
+#endif  /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
 
-//! split_node: accepts a tuple as input, forwards each element of the tuple to its
-//  successors.  The node has unlimited concurrency, so it does not reject inputs.
-template<typename TupleType, typename Allocator=cache_aligned_allocator<TupleType> >
-class split_node : public graph_node, public receiver<TupleType> {
-    static const int N = tbb::flow::tuple_size<TupleType>::value;
-    typedef receiver<TupleType> base_type;
-public:
-    typedef TupleType input_type;
-    typedef Allocator allocator_type;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
-    typedef typename base_type::predecessor_type predecessor_type;
-    typedef typename base_type::predecessor_list_type predecessor_list_type;
-    typedef internal::predecessor_cache<input_type, null_mutex > predecessor_cache_type;
-    typedef typename predecessor_cache_type::built_predecessors_type built_predecessors_type;
-#endif
+    //! Request an item from the node
+    bool try_get( output_type &v ) __TBB_override {
+        spin_mutex::scoped_lock lock(my_mutex);
+        if ( my_reserved )
+            return false;
 
-    typedef typename internal::wrap_tuple_elements<
-            N,  // #elements in tuple
-            internal::multifunction_output,  // wrap this around each element
-            TupleType // the tuple providing the types
-        >::type  output_ports_type;
+        if ( my_has_cached_item ) {
+            v = my_cached_item;
+            my_has_cached_item = false;
+            return true;
+        }
+        // we've been asked to provide an item, but we have none.  enqueue a task to
+        // provide one.
+        spawn_put();
+        return false;
+    }
 
-    explicit split_node(graph &g) : graph_node(g)
-    {
-        tbb::internal::fgt_multioutput_node<N>(tbb::internal::FLOW_SPLIT_NODE, &this->my_graph,
-            static_cast<receiver<input_type> *>(this), this->output_ports());
+    //! Reserves an item.
+    bool try_reserve( output_type &v ) __TBB_override {
+        spin_mutex::scoped_lock lock(my_mutex);
+        if ( my_reserved ) {
+            return false;
+        }
+
+        if ( my_has_cached_item ) {
+            v = my_cached_item;
+            my_reserved = true;
+            return true;
+        } else {
+            return false;
+        }
     }
-    split_node( const split_node & other) : graph_node(other.my_graph), base_type(other)
-    {
-        tbb::internal::fgt_multioutput_node<N>(tbb::internal::FLOW_SPLIT_NODE, &this->my_graph,
-            static_cast<receiver<input_type> *>(this), this->output_ports());
+
+    //! Release a reserved item.
+    /** true = item has been released and so remains in sender, dest must request or reserve future items */
+    bool try_release( ) __TBB_override {
+        spin_mutex::scoped_lock lock(my_mutex);
+        __TBB_ASSERT( my_reserved && my_has_cached_item, "releasing non-existent reservation" );
+        my_reserved = false;
+        if(!my_successors.empty())
+            spawn_put();
+        return true;
     }
 
-#if TBB_PREVIEW_FLOW_GRAPH_TRACE
-    void set_name( const char *name ) __TBB_override {
-        tbb::internal::fgt_multioutput_node_desc( this, name );
+    //! Consumes a reserved item
+    bool try_consume( ) __TBB_override {
+        spin_mutex::scoped_lock lock(my_mutex);
+        __TBB_ASSERT( my_reserved && my_has_cached_item, "consuming non-existent reservation" );
+        my_reserved = false;
+        my_has_cached_item = false;
+        if ( !my_successors.empty() ) {
+            spawn_put();
+        }
+        return true;
     }
-#endif
 
-    output_ports_type &output_ports() { return my_output_ports; }
+    //! Activates a node that was created in the inactive state
+    void activate() {
+        spin_mutex::scoped_lock lock(my_mutex);
+        my_active = true;
+        if (!my_successors.empty())
+            spawn_put();
+    }
 
-protected:
-    task *try_put_task(const TupleType& t) __TBB_override {
-        // Sending split messages in parallel is not justified, as overheads would prevail.
-        // Also, we do not have successors here. So we just tell the task returned here is successful.
-        return internal::emit_element<N>::emit_this(this->my_graph, t, output_ports());
+    template<typename Body>
+    Body copy_function_object() {
+        internal::source_body<output_type> &body_ref = *this->my_body;
+        return dynamic_cast< internal::source_body_leaf<output_type, Body> & >(body_ref).get_body();
     }
-    void reset_node(reset_flags f) __TBB_override {
-        if (f & rf_clear_edges)
-            internal::clear_element<N>::clear_this(my_output_ports);
 
-        __TBB_ASSERT(!(f & rf_clear_edges) || internal::clear_element<N>::this_empty(my_output_ports), "split_node reset failed");
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
+    void extract( ) __TBB_override {
+        my_successors.built_successors().sender_extract(*this);   // removes "my_owner" == this from each successor
+        my_active = init_my_active;
+        my_reserved = false;
+        if(my_has_cached_item) my_has_cached_item = false;
     }
-    void reset_receiver(reset_flags /*f*/) __TBB_override {}
-    graph& graph_reference() __TBB_override {
-        return my_graph;
+#endif
+
+protected:
+
+    //! resets the source_node to its initial state
+    void reset_node( reset_flags f) __TBB_override {
+        my_active = init_my_active;
+        my_reserved =false;
+        if(my_has_cached_item) {
+            my_has_cached_item = false;
+        }
+        if(f & rf_clear_edges) my_successors.clear();
+        if(f & rf_reset_bodies) {
+            internal::source_body<output_type> *tmp = my_init_body->clone();
+            delete my_body;
+            my_body = tmp;
+        }
+        if(my_active)
+            internal::add_task_to_graph_reset_list(this->my_graph, create_put_task());
     }
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
-private: //! split_node doesn't use this "predecessors" functionality; so, we have "dummies" here;
-    void extract() __TBB_override {}
 
-    //! Adds to list of predecessors added by make_edge
-    void internal_add_built_predecessor(predecessor_type&) __TBB_override {}
+private:
+    spin_mutex my_mutex;
+    bool my_active;
+    bool init_my_active;
+    internal::source_body<output_type> *my_body;
+    internal::source_body<output_type> *my_init_body;
+    internal::broadcast_cache< output_type > my_successors;
+    bool my_reserved;
+    bool my_has_cached_item;
+    output_type my_cached_item;
 
-    //! removes from to list of predecessors (used by remove_edge)
-    void internal_delete_built_predecessor(predecessor_type&) __TBB_override {}
+    // used by apply_body_bypass, can invoke body of node.
+    bool try_reserve_apply_body(output_type &v) {
+        spin_mutex::scoped_lock lock(my_mutex);
+        if ( my_reserved ) {
+            return false;
+        }
+        if ( !my_has_cached_item ) {
+            tbb::internal::fgt_begin_body( my_body );
+            bool r = (*my_body)(my_cached_item);
+            tbb::internal::fgt_end_body( my_body );
+            if (r) {
+                my_has_cached_item = true;
+            }
+        }
+        if ( my_has_cached_item ) {
+            v = my_cached_item;
+            my_reserved = true;
+            return true;
+        } else {
+            return false;
+        }
+    }
 
-    size_t predecessor_count() __TBB_override { return 0; }
+    // when resetting, and if the source_node was created with my_active == true, then
+    // when we reset the node we must store a task to run the node, and spawn it only
+    // after the reset is complete and is_active() is again true.  This is why we don't
+    // test for is_active() here.
+    task* create_put_task() {
+        return ( new ( task::allocate_additional_child_of( *(this->my_graph.root_task()) ) )
+                        internal:: source_task_bypass < source_node< output_type > >( *this ) );
+    }
 
-    void copy_predecessors(predecessor_list_type&) __TBB_override {}
+    //! Spawns a task that applies the body
+    void spawn_put( ) {
+        if(internal::is_graph_active(this->my_graph)) {
+            internal::spawn_in_graph_arena(this->my_graph, *create_put_task());
+        }
+    }
 
-    built_predecessors_type &built_predecessors() __TBB_override { return my_predessors; }
+    friend class internal::source_task_bypass< source_node< output_type > >;
+    //! Applies the body.  Returning SUCCESSFULLY_ENQUEUED okay; forward_task_bypass will handle it.
+    task * apply_body_bypass( ) {
+        output_type v;
+        if ( !try_reserve_apply_body(v) )
+            return NULL;
 
-    //! dummy member
-    built_predecessors_type my_predessors;
-#endif  /* TBB_PREVIEW_FLOW_GRAPH_FEATURES */
+        task *last_task = my_successors.try_put_task(v);
+        if ( last_task )
+            try_consume();
+        else
+            try_release();
+        return last_task;
+    }
+};  // class source_node
+#endif // TBB_USE_SOURCE_NODE_AS_ALIAS
 
-private:
-    output_ports_type my_output_ports;
-};
+//! Implements a function node that supports Input -> Output
+template<typename Input, typename Output = continue_msg, typename Policy = queueing,
+         typename Allocator=__TBB_DEFAULT_NODE_ALLOCATOR(Input)>
+class function_node
+    : public graph_node
+#if TBB_DEPRECATED_FLOW_NODE_ALLOCATOR
+    , public internal::function_input< Input, Output, Policy, Allocator >
+#else
+    , public internal::function_input< Input, Output, Policy, cache_aligned_allocator<Input> >
+#endif
+    , public internal::function_output<Output> {
+
+#if TBB_DEPRECATED_FLOW_NODE_ALLOCATOR
+    typedef Allocator internals_allocator;
+#else
+    typedef cache_aligned_allocator<Input> internals_allocator;
+
+    __TBB_STATIC_ASSERT(
+        (tbb::internal::is_same_type<Allocator, null_type>::value),
+        "Allocator template parameter for flow graph nodes is deprecated and will be removed. "
+        "Specify TBB_DEPRECATED_FLOW_NODE_ALLOCATOR to temporary enable the deprecated interface."
+    );
+#endif
 
-//! Implements an executable node that supports continue_msg -> Output
-template <typename Output>
-class continue_node : public graph_node, public internal::continue_input<Output>, public internal::function_output<Output> {
 public:
-    typedef continue_msg input_type;
+    typedef Input input_type;
     typedef Output output_type;
-    typedef internal::continue_input<Output> fInput_type;
+    typedef internal::function_input<input_type,output_type,Policy,internals_allocator> input_impl_type;
+    typedef internal::function_input_queue<input_type, internals_allocator> input_queue_type;
     typedef internal::function_output<output_type> fOutput_type;
-    typedef typename fInput_type::predecessor_type predecessor_type;
+    typedef typename input_impl_type::predecessor_type predecessor_type;
     typedef typename fOutput_type::successor_type successor_type;
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
+    typedef typename input_impl_type::predecessor_list_type predecessor_list_type;
+    typedef typename fOutput_type::successor_list_type successor_list_type;
+#endif
+    using input_impl_type::my_predecessors;
 
-    //! Constructor for executable node with continue_msg -> Output
-    template <typename Body >
-    continue_node( graph &g, Body body ) :
-        graph_node(g), internal::continue_input<output_type>( g, body ) {
-        tbb::internal::fgt_node_with_body( tbb::internal::FLOW_CONTINUE_NODE, &this->my_graph,
-                                           static_cast<receiver<input_type> *>(this),
-                                           static_cast<sender<output_type> *>(this), this->my_body );
+    //! Constructor
+    // input_queue_type is allocated here, but destroyed in the function_input_base.
+    // TODO: pass the graph_buffer_policy to the function_input_base so it can all
+    // be done in one place.  This would be an interface-breaking change.
+    template< typename Body >
+     __TBB_NOINLINE_SYM function_node( graph &g, size_t concurrency,
+#if __TBB_CPP11_PRESENT
+                   Body body, __TBB_FLOW_GRAPH_PRIORITY_ARG1( Policy = Policy(), node_priority_t priority = tbb::flow::internal::no_priority ))
+#else
+                   __TBB_FLOW_GRAPH_PRIORITY_ARG1( Body body, node_priority_t priority = tbb::flow::internal::no_priority ))
+#endif
+        : graph_node(g), input_impl_type(g, concurrency, __TBB_FLOW_GRAPH_PRIORITY_ARG1(body, priority)),
+          fOutput_type(g) {
+        tbb::internal::fgt_node_with_body( CODEPTR(), tbb::internal::FLOW_FUNCTION_NODE, &this->my_graph,
+                static_cast<receiver<input_type> *>(this), static_cast<sender<output_type> *>(this), this->my_body );
     }
 
+#if __TBB_PREVIEW_FLOW_GRAPH_PRIORITIES && __TBB_CPP11_PRESENT
+    template <typename Body>
+    function_node( graph& g, size_t concurrency, Body body, node_priority_t priority )
+        : function_node(g, concurrency, body, Policy(), priority) {}
+#endif // __TBB_PREVIEW_FLOW_GRAPH_PRIORITIES && __TBB_CPP11_PRESENT
 
-    //! Constructor for executable node with continue_msg -> Output
-    template <typename Body >
-    continue_node( graph &g, int number_of_predecessors, Body body ) :
-        graph_node(g), internal::continue_input<output_type>( g, number_of_predecessors, body ) {
-        tbb::internal::fgt_node_with_body( tbb::internal::FLOW_CONTINUE_NODE, &this->my_graph,
-                                           static_cast<receiver<input_type> *>(this),
-                                           static_cast<sender<output_type> *>(this), this->my_body );
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+    template <typename Body, typename... Args>
+    function_node( const node_set<Args...>& nodes, size_t concurrency, Body body,
+                   __TBB_FLOW_GRAPH_PRIORITY_ARG1( Policy p = Policy(), node_priority_t priority = tbb::flow::internal::no_priority ))
+        : function_node(nodes.graph_reference(), concurrency, body, __TBB_FLOW_GRAPH_PRIORITY_ARG1(p, priority)) {
+        make_edges_in_order(nodes, *this);
     }
 
+#if __TBB_PREVIEW_FLOW_GRAPH_PRIORITIES
+    template <typename Body, typename... Args>
+    function_node( const node_set<Args...>& nodes, size_t concurrency, Body body, node_priority_t priority )
+        : function_node(nodes, concurrency, body, Policy(), priority) {}
+#endif // __TBB_PREVIEW_FLOW_GRAPH_PRIORITIES
+#endif // __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+
     //! Copy constructor
-    continue_node( const continue_node& src ) :
-        graph_node(src.my_graph), internal::continue_input<output_type>(src),
-        internal::function_output<Output>() {
-        tbb::internal::fgt_node_with_body( tbb::internal::FLOW_CONTINUE_NODE, &this->my_graph,
-                                           static_cast<receiver<input_type> *>(this),
-                                           static_cast<sender<output_type> *>(this), this->my_body );
+    __TBB_NOINLINE_SYM function_node( const function_node& src ) :
+        graph_node(src.my_graph),
+        input_impl_type(src),
+        fOutput_type(src.my_graph) {
+        tbb::internal::fgt_node_with_body( CODEPTR(), tbb::internal::FLOW_FUNCTION_NODE, &this->my_graph,
+                static_cast<receiver<input_type> *>(this), static_cast<sender<output_type> *>(this), this->my_body );
     }
 
 #if TBB_PREVIEW_FLOW_GRAPH_TRACE
@@ -1353,9 +1541,9 @@ class continue_node : public graph_node, public internal::continue_input<Output>
     }
 #endif
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
-    void extract() __TBB_override {
-        fInput_type::my_built_predecessors.receiver_extract(*this);
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
+    void extract( ) __TBB_override {
+        my_predecessors.built_predecessors().receiver_extract(*this);
         successors().built_successors().sender_extract(*this);
     }
 #endif
@@ -1364,255 +1552,325 @@ class continue_node : public graph_node, public internal::continue_input<Output>
     template< typename R, typename B > friend class run_and_put_task;
     template<typename X, typename Y> friend class internal::broadcast_cache;
     template<typename X, typename Y> friend class internal::round_robin_cache;
-    using fInput_type::try_put_task;
+    using input_impl_type::try_put_task;
+
     internal::broadcast_cache<output_type> &successors () __TBB_override { return fOutput_type::my_successors; }
 
     void reset_node(reset_flags f) __TBB_override {
-        fInput_type::reset_receiver(f);
-        if(f & rf_clear_edges)successors().clear();
-        __TBB_ASSERT(!(f & rf_clear_edges) || successors().empty(), "continue_node not reset");
-    }
-};  // continue_node
-
-template< typename T >
-class overwrite_node : public graph_node, public receiver<T>, public sender<T> {
-public:
-    typedef T input_type;
-    typedef T output_type;
-    typedef typename receiver<input_type>::predecessor_type predecessor_type;
-    typedef typename sender<output_type>::successor_type successor_type;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
-    typedef typename receiver<input_type>::built_predecessors_type built_predecessors_type;
-    typedef typename sender<output_type>::built_successors_type built_successors_type;
-    typedef typename receiver<input_type>::predecessor_list_type predecessor_list_type;
-    typedef typename sender<output_type>::successor_list_type successor_list_type;
-#endif
-
-    explicit overwrite_node(graph &g) : graph_node(g), my_buffer_is_valid(false) {
-        my_successors.set_owner( this );
-        tbb::internal::fgt_node( tbb::internal::FLOW_OVERWRITE_NODE, &this->my_graph,
-                                 static_cast<receiver<input_type> *>(this), static_cast<sender<output_type> *>(this) );
+        input_impl_type::reset_function_input(f);
+        // TODO: use clear() instead.
+        if(f & rf_clear_edges) {
+            successors().clear();
+            my_predecessors.clear();
+        }
+        __TBB_ASSERT(!(f & rf_clear_edges) || successors().empty(), "function_node successors not empty");
+        __TBB_ASSERT(this->my_predecessors.empty(), "function_node predecessors not empty");
     }
 
-    //! Copy constructor; doesn't take anything from src; default won't work
-    overwrite_node( const overwrite_node& src ) :
-        graph_node(src.my_graph), receiver<T>(), sender<T>(), my_buffer_is_valid(false)
-    {
-        my_successors.set_owner( this );
-        tbb::internal::fgt_node( tbb::internal::FLOW_OVERWRITE_NODE, &this->my_graph,
-                                 static_cast<receiver<input_type> *>(this), static_cast<sender<output_type> *>(this) );
-    }
+};  // class function_node
 
-    ~overwrite_node() {}
+//! implements a function node that supports Input -> (set of outputs)
+// Output is a tuple of output types.
+template<typename Input, typename Output, typename Policy = queueing,
+         typename Allocator=__TBB_DEFAULT_NODE_ALLOCATOR(Input)>
+class multifunction_node :
+    public graph_node,
+    public internal::multifunction_input
+    <
+        Input,
+        typename internal::wrap_tuple_elements<
+            tbb::flow::tuple_size<Output>::value,  // #elements in tuple
+            internal::multifunction_output,  // wrap this around each element
+            Output // the tuple providing the types
+        >::type,
+        Policy,
+#if TBB_DEPRECATED_FLOW_NODE_ALLOCATOR
+        Allocator
+#else
+        cache_aligned_allocator<Input>
+#endif
+    > {
+#if TBB_DEPRECATED_FLOW_NODE_ALLOCATOR
+    typedef Allocator internals_allocator;
+#else
+    typedef cache_aligned_allocator<Input> internals_allocator;
 
-#if TBB_PREVIEW_FLOW_GRAPH_TRACE
-    void set_name( const char *name ) __TBB_override {
-        tbb::internal::fgt_node_desc( this, name );
-    }
+    __TBB_STATIC_ASSERT(
+        (tbb::internal::is_same_type<Allocator, null_type>::value),
+        "Allocator template parameter for flow graph nodes is deprecated and will be removed. "
+        "Specify TBB_DEPRECATED_FLOW_NODE_ALLOCATOR to temporary enable the deprecated interface."
+    );
 #endif
 
-   bool register_successor( successor_type &s ) __TBB_override {
-        spin_mutex::scoped_lock l( my_mutex );
-        if (my_buffer_is_valid && internal::is_graph_active( my_graph )) {
-            // We have a valid value that must be forwarded immediately.
-            bool ret = s.try_put( my_buffer );
-#if TBB_PREVIEW_RESERVABLE_OVERWRITE_NODE
-            if ( ret ) {
-                // We add the successor that accepted our put
-                my_successors.register_successor( s );
-            } else {
-                // In case of reservation a race between the moment of reservation and register_successor can appear,
-                // because failed reserve does not mean that register_successor is not ready to put a message immediately. 
-                // We have some sort of infinite loop: reserving node tries to set pull state for the edge,
-                // but overwrite_node tries to return push state back. That is why we have to break this loop with task creation.
-                task *rtask = new ( task::allocate_additional_child_of( *( my_graph.root_task() ) ) )
-                    register_predecessor_task( *this, s );
-                internal::spawn_in_graph_arena( my_graph, *rtask );
-            }
+protected:
+    static const int N = tbb::flow::tuple_size<Output>::value;
+public:
+    typedef Input input_type;
+    typedef null_type output_type;
+    typedef typename internal::wrap_tuple_elements<N,internal::multifunction_output, Output>::type output_ports_type;
+    typedef internal::multifunction_input<
+        input_type, output_ports_type, Policy, internals_allocator> input_impl_type;
+    typedef internal::function_input_queue<input_type, internals_allocator> input_queue_type;
+private:
+    using input_impl_type::my_predecessors;
+public:
+    template<typename Body>
+    __TBB_NOINLINE_SYM multifunction_node(
+        graph &g, size_t concurrency,
+#if __TBB_CPP11_PRESENT
+        Body body, __TBB_FLOW_GRAPH_PRIORITY_ARG1( Policy = Policy(), node_priority_t priority = tbb::flow::internal::no_priority )
 #else
-            if ( ret || !s.register_predecessor( *this  ) ) {
-                // We add the successor: it accepted our put or it rejected it but won't let us become a predecessor
-                my_successors.register_successor( s );
-            } else {
-                // We don't add the successor: it rejected our put and we became its predecessor instead
-                return false;
-            }
+        __TBB_FLOW_GRAPH_PRIORITY_ARG1(Body body, node_priority_t priority = tbb::flow::internal::no_priority)
 #endif
-        } else {
-            // No valid value yet, just add as successor
-            my_successors.register_successor( s );
-        }
-        return true;
-    }
-
-    bool remove_successor( successor_type &s ) __TBB_override {
-        spin_mutex::scoped_lock l( my_mutex );
-        my_successors.remove_successor(s);
-        return true;
-    }
-
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
-    built_predecessors_type &built_predecessors() __TBB_override { return my_built_predecessors; }
-    built_successors_type   &built_successors()   __TBB_override { return my_successors.built_successors(); }
-
-    void internal_add_built_successor( successor_type &s) __TBB_override {
-        spin_mutex::scoped_lock l( my_mutex );
-        my_successors.internal_add_built_successor(s);
+    ) : graph_node(g), input_impl_type(g, concurrency, __TBB_FLOW_GRAPH_PRIORITY_ARG1(body, priority)) {
+        tbb::internal::fgt_multioutput_node_with_body<N>(
+            CODEPTR(), tbb::internal::FLOW_MULTIFUNCTION_NODE,
+            &this->my_graph, static_cast<receiver<input_type> *>(this),
+            this->output_ports(), this->my_body
+        );
+    }
+
+#if __TBB_PREVIEW_FLOW_GRAPH_PRIORITIES && __TBB_CPP11_PRESENT
+    template <typename Body>
+    __TBB_NOINLINE_SYM multifunction_node(graph& g, size_t concurrency, Body body, node_priority_t priority)
+        : multifunction_node(g, concurrency, body, Policy(), priority) {}
+#endif // TBB_PREVIEW_FLOW_GRAPH_PRIORITIES && __TBB_CPP11_PRESENT
+
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+    template <typename Body, typename... Args>
+    __TBB_NOINLINE_SYM multifunction_node(const node_set<Args...>& nodes, size_t concurrency, Body body,
+                       __TBB_FLOW_GRAPH_PRIORITY_ARG1(Policy p = Policy(), node_priority_t priority = tbb::flow::internal::no_priority))
+        : multifunction_node(nodes.graph_reference(), concurrency, body, __TBB_FLOW_GRAPH_PRIORITY_ARG1(p, priority)) {
+        make_edges_in_order(nodes, *this);
+    }
+
+#if __TBB_PREVIEW_FLOW_GRAPH_PRIORITIES
+    template <typename Body, typename... Args>
+    __TBB_NOINLINE_SYM multifunction_node(const node_set<Args...>& nodes, size_t concurrency, Body body, node_priority_t priority)
+        : multifunction_node(nodes, concurrency, body, Policy(), priority) {}
+#endif // __TBB_PREVIEW_FLOW_GRAPH_PRIORITIES
+#endif // __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+
+    __TBB_NOINLINE_SYM multifunction_node( const multifunction_node &other) :
+        graph_node(other.my_graph), input_impl_type(other) {
+        tbb::internal::fgt_multioutput_node_with_body<N>( CODEPTR(), tbb::internal::FLOW_MULTIFUNCTION_NODE,
+                &this->my_graph, static_cast<receiver<input_type> *>(this),
+                this->output_ports(), this->my_body );
     }
 
-    void internal_delete_built_successor( successor_type &s) __TBB_override {
-        spin_mutex::scoped_lock l( my_mutex );
-        my_successors.internal_delete_built_successor(s);
+#if TBB_PREVIEW_FLOW_GRAPH_TRACE
+    void set_name( const char *name ) __TBB_override {
+        tbb::internal::fgt_multioutput_node_desc( this, name );
     }
+#endif
 
-    size_t successor_count() __TBB_override {
-        spin_mutex::scoped_lock l( my_mutex );
-        return my_successors.successor_count();
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
+    void extract( ) __TBB_override {
+        my_predecessors.built_predecessors().receiver_extract(*this);
+        input_impl_type::extract();
     }
+#endif
+    // all the guts are in multifunction_input...
+protected:
+    void reset_node(reset_flags f) __TBB_override { input_impl_type::reset(f); }
+};  // multifunction_node
 
-    void copy_successors(successor_list_type &v) __TBB_override {
-        spin_mutex::scoped_lock l( my_mutex );
-        my_successors.copy_successors(v);
-    }
+//! split_node: accepts a tuple as input, forwards each element of the tuple to its
+//  successors.  The node has unlimited concurrency, so it does not reject inputs.
+template<typename TupleType, typename Allocator=__TBB_DEFAULT_NODE_ALLOCATOR(TupleType)>
+class split_node : public graph_node, public receiver<TupleType> {
+    static const int N = tbb::flow::tuple_size<TupleType>::value;
+    typedef receiver<TupleType> base_type;
+public:
+    typedef TupleType input_type;
+#if TBB_DEPRECATED_FLOW_NODE_ALLOCATOR
+    typedef Allocator allocator_type;
+#else
+    __TBB_STATIC_ASSERT(
+        (tbb::internal::is_same_type<Allocator, null_type>::value),
+        "Allocator template parameter for flow graph nodes is deprecated and will be removed. "
+        "Specify TBB_DEPRECATED_FLOW_NODE_ALLOCATOR to temporary enable the deprecated interface."
+    );
+#endif
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
+    typedef typename base_type::predecessor_type predecessor_type;
+    typedef typename base_type::predecessor_list_type predecessor_list_type;
+    typedef internal::predecessor_cache<input_type, null_mutex > predecessor_cache_type;
+    typedef typename predecessor_cache_type::built_predecessors_type built_predecessors_type;
+#endif
 
-    void internal_add_built_predecessor( predecessor_type &p) __TBB_override {
-        spin_mutex::scoped_lock l( my_mutex );
-        my_built_predecessors.add_edge(p);
-    }
+    typedef typename internal::wrap_tuple_elements<
+            N,  // #elements in tuple
+            internal::multifunction_output,  // wrap this around each element
+            TupleType // the tuple providing the types
+        >::type  output_ports_type;
 
-    void internal_delete_built_predecessor( predecessor_type &p) __TBB_override {
-        spin_mutex::scoped_lock l( my_mutex );
-        my_built_predecessors.delete_edge(p);
+    __TBB_NOINLINE_SYM explicit split_node(graph &g)
+        : graph_node(g),
+          my_output_ports(internal::init_output_ports<output_ports_type>::call(g, my_output_ports))
+    {
+        tbb::internal::fgt_multioutput_node<N>(CODEPTR(), tbb::internal::FLOW_SPLIT_NODE, &this->my_graph,
+            static_cast<receiver<input_type> *>(this), this->output_ports());
     }
 
-    size_t predecessor_count() __TBB_override {
-        spin_mutex::scoped_lock l( my_mutex );
-        return my_built_predecessors.edge_count();
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+    template <typename... Args>
+    __TBB_NOINLINE_SYM split_node(const node_set<Args...>& nodes) : split_node(nodes.graph_reference()) {
+        make_edges_in_order(nodes, *this);
     }
+#endif
 
-    void copy_predecessors( predecessor_list_type &v ) __TBB_override {
-        spin_mutex::scoped_lock l( my_mutex );
-        my_built_predecessors.copy_edges(v);
+    __TBB_NOINLINE_SYM split_node(const split_node& other)
+        : graph_node(other.my_graph), base_type(other),
+          my_output_ports(internal::init_output_ports<output_ports_type>::call(other.my_graph, my_output_ports))
+    {
+        tbb::internal::fgt_multioutput_node<N>(CODEPTR(), tbb::internal::FLOW_SPLIT_NODE, &this->my_graph,
+            static_cast<receiver<input_type> *>(this), this->output_ports());
     }
 
-    void extract() __TBB_override {
-        my_buffer_is_valid = false;
-        built_successors().sender_extract(*this);
-        built_predecessors().receiver_extract(*this);
+#if TBB_PREVIEW_FLOW_GRAPH_TRACE
+    void set_name( const char *name ) __TBB_override {
+        tbb::internal::fgt_multioutput_node_desc( this, name );
     }
+#endif
 
-#endif  /* TBB_PREVIEW_FLOW_GRAPH_FEATURES */
+    output_ports_type &output_ports() { return my_output_ports; }
 
-    bool try_get( input_type &v ) __TBB_override {
-        spin_mutex::scoped_lock l( my_mutex );
-        if ( my_buffer_is_valid ) {
-            v = my_buffer;
-            return true;
-        }
-        return false;
+protected:
+    task *try_put_task(const TupleType& t) __TBB_override {
+        // Sending split messages in parallel is not justified, as overheads would prevail.
+        // Also, we do not have successors here. So we just tell the task returned here is successful.
+        return internal::emit_element<N>::emit_this(this->my_graph, t, output_ports());
     }
+    void reset_node(reset_flags f) __TBB_override {
+        if (f & rf_clear_edges)
+            internal::clear_element<N>::clear_this(my_output_ports);
 
-#if TBB_PREVIEW_RESERVABLE_OVERWRITE_NODE
-    //! Reserves an item
-    bool try_reserve( T &v ) __TBB_override {
-        return try_get(v);
+        __TBB_ASSERT(!(f & rf_clear_edges) || internal::clear_element<N>::this_empty(my_output_ports), "split_node reset failed");
     }
-
-    //! Releases the reserved item
-    bool try_release() __TBB_override { return true; }
-
-    //! Consumes the reserved item
-    bool try_consume() __TBB_override { return true; }
-#endif
- 
-    bool is_valid() {
-       spin_mutex::scoped_lock l( my_mutex );
-       return my_buffer_is_valid;
+    void reset_receiver(reset_flags /*f*/) __TBB_override {}
+    graph& graph_reference() const __TBB_override {
+        return my_graph;
     }
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
+private: //! split_node doesn't use this "predecessors" functionality; so, we have "dummies" here;
+    void extract() __TBB_override {}
 
-    void clear() {
-       spin_mutex::scoped_lock l( my_mutex );
-       my_buffer_is_valid = false;
-    }
+    //! Adds to list of predecessors added by make_edge
+    void internal_add_built_predecessor(predecessor_type&) __TBB_override {}
 
-protected:
+    //! removes from to list of predecessors (used by remove_edge)
+    void internal_delete_built_predecessor(predecessor_type&) __TBB_override {}
 
-    template< typename R, typename B > friend class run_and_put_task;
-    template<typename X, typename Y> friend class internal::broadcast_cache;
-    template<typename X, typename Y> friend class internal::round_robin_cache;
-    task * try_put_task( const input_type &v ) __TBB_override {
-        spin_mutex::scoped_lock l( my_mutex );
-        return try_put_task_impl(v);
-    }
+    size_t predecessor_count() __TBB_override { return 0; }
 
-    task * try_put_task_impl(const input_type &v) {
-        my_buffer = v;
-        my_buffer_is_valid = true;
-        task * rtask = my_successors.try_put_task(v);
-        if (!rtask) rtask = SUCCESSFULLY_ENQUEUED;
-        return rtask;
-    }
+    void copy_predecessors(predecessor_list_type&) __TBB_override {}
 
-    graph& graph_reference() __TBB_override {
-        return my_graph;
-    }
+    built_predecessors_type &built_predecessors() __TBB_override { return my_predessors; }
 
-#if TBB_PREVIEW_RESERVABLE_OVERWRITE_NODE
-    //! Breaks an infinite loop between the node reservation and register_successor call
-    struct register_predecessor_task : public task {
-        register_predecessor_task(sender<T>& owner, receiver<T>& succ) :
-            o(owner), s(succ) {};
+    //! dummy member
+    built_predecessors_type my_predessors;
+#endif  /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
 
-        tbb::task* execute() __TBB_override {
-            if (!s.register_predecessor(o)) {
-                o.register_successor(s);
-            }
-            return NULL;
-        }
+private:
+    output_ports_type my_output_ports;
+};
 
-        sender<T>& o;
-        receiver<T>& s;
-    };
+//! Implements an executable node that supports continue_msg -> Output
+template <typename Output, typename Policy = internal::Policy<void> >
+class continue_node : public graph_node, public internal::continue_input<Output, Policy>,
+                      public internal::function_output<Output> {
+public:
+    typedef continue_msg input_type;
+    typedef Output output_type;
+    typedef internal::continue_input<Output, Policy> input_impl_type;
+    typedef internal::function_output<output_type> fOutput_type;
+    typedef typename input_impl_type::predecessor_type predecessor_type;
+    typedef typename fOutput_type::successor_type successor_type;
+
+    //! Constructor for executable node with continue_msg -> Output
+    template <typename Body >
+    __TBB_NOINLINE_SYM continue_node(
+        graph &g,
+#if __TBB_CPP11_PRESENT
+        Body body, __TBB_FLOW_GRAPH_PRIORITY_ARG1( Policy = Policy(), node_priority_t priority = tbb::flow::internal::no_priority )
+#else
+        __TBB_FLOW_GRAPH_PRIORITY_ARG1( Body body, node_priority_t priority = tbb::flow::internal::no_priority )
 #endif
+    ) : graph_node(g), input_impl_type( g, __TBB_FLOW_GRAPH_PRIORITY_ARG1(body, priority) ),
+        fOutput_type(g) {
+        tbb::internal::fgt_node_with_body( CODEPTR(), tbb::internal::FLOW_CONTINUE_NODE, &this->my_graph,
 
-    spin_mutex my_mutex;
-    internal::broadcast_cache< input_type, null_rw_mutex > my_successors;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
-    internal::edge_container<predecessor_type> my_built_predecessors;
+                                           static_cast<receiver<input_type> *>(this),
+                                           static_cast<sender<output_type> *>(this), this->my_body );
+    }
+
+#if __TBB_PREVIEW_FLOW_GRAPH_PRIORITIES && __TBB_CPP11_PRESENT
+    template <typename Body>
+    continue_node( graph& g, Body body, node_priority_t priority )
+        : continue_node(g, body, Policy(), priority) {}
 #endif
-    input_type my_buffer;
-    bool my_buffer_is_valid;
-    void reset_receiver(reset_flags /*f*/) __TBB_override {}
 
-    void reset_node( reset_flags f) __TBB_override {
-        my_buffer_is_valid = false;
-       if (f&rf_clear_edges) {
-           my_successors.clear();
-       }
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+    template <typename Body, typename... Args>
+    continue_node( const node_set<Args...>& nodes, Body body,
+                   __TBB_FLOW_GRAPH_PRIORITY_ARG1( Policy p = Policy(), node_priority_t priority = tbb::flow::internal::no_priority))
+        : continue_node(nodes.graph_reference(), body, __TBB_FLOW_GRAPH_PRIORITY_ARG1(p, priority) ) {
+        make_edges_in_order(nodes, *this);
     }
-};  // overwrite_node
+#if __TBB_PREVIEW_FLOW_GRAPH_PRIORITIES
+    template <typename Body, typename... Args>
+    continue_node( const node_set<Args...>& nodes, Body body, node_priority_t priority)
+        : continue_node(nodes, body, Policy(), priority) {}
+#endif // __TBB_PREVIEW_FLOW_GRAPH_PRIORITIES
+#endif // __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
 
-template< typename T >
-class write_once_node : public overwrite_node<T> {
-public:
-    typedef T input_type;
-    typedef T output_type;
-    typedef overwrite_node<T> base_type;
-    typedef typename receiver<input_type>::predecessor_type predecessor_type;
-    typedef typename sender<output_type>::successor_type successor_type;
+    //! Constructor for executable node with continue_msg -> Output
+    template <typename Body >
+    __TBB_NOINLINE_SYM continue_node(
+        graph &g, int number_of_predecessors,
+#if __TBB_CPP11_PRESENT
+        Body body, __TBB_FLOW_GRAPH_PRIORITY_ARG1( Policy = Policy(), node_priority_t priority = tbb::flow::internal::no_priority )
+#else
+        __TBB_FLOW_GRAPH_PRIORITY_ARG1( Body body, node_priority_t priority = tbb::flow::internal::no_priority )
+#endif
+    ) : graph_node(g)
+      , input_impl_type(g, number_of_predecessors, __TBB_FLOW_GRAPH_PRIORITY_ARG1(body, priority)),
+        fOutput_type(g) {
+        tbb::internal::fgt_node_with_body( CODEPTR(), tbb::internal::FLOW_CONTINUE_NODE, &this->my_graph,
+                                           static_cast<receiver<input_type> *>(this),
+                                           static_cast<sender<output_type> *>(this), this->my_body );
+    }
 
-    //! Constructor
-    explicit write_once_node(graph& g) : base_type(g) {
-        tbb::internal::fgt_node( tbb::internal::FLOW_WRITE_ONCE_NODE, &(this->my_graph),
-                                 static_cast<receiver<input_type> *>(this),
-                                 static_cast<sender<output_type> *>(this) );
+#if __TBB_PREVIEW_FLOW_GRAPH_PRIORITIES && __TBB_CPP11_PRESENT
+    template <typename Body>
+    continue_node( graph& g, int number_of_predecessors, Body body, node_priority_t priority)
+        : continue_node(g, number_of_predecessors, body, Policy(), priority) {}
+#endif
+
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+    template <typename Body, typename... Args>
+    continue_node( const node_set<Args...>& nodes, int number_of_predecessors,
+                   Body body, __TBB_FLOW_GRAPH_PRIORITY_ARG1( Policy p = Policy(), node_priority_t priority = tbb::flow::internal::no_priority ))
+        : continue_node(nodes.graph_reference(), number_of_predecessors, body, __TBB_FLOW_GRAPH_PRIORITY_ARG1(p, priority)) {
+        make_edges_in_order(nodes, *this);
     }
 
-    //! Copy constructor: call base class copy constructor
-    write_once_node( const write_once_node& src ) : base_type(src) {
-        tbb::internal::fgt_node( tbb::internal::FLOW_WRITE_ONCE_NODE, &(this->my_graph),
-                                 static_cast<receiver<input_type> *>(this),
-                                 static_cast<sender<output_type> *>(this) );
+#if __TBB_PREVIEW_FLOW_GRAPH_PRIORITIES
+    template <typename Body, typename... Args>
+    continue_node( const node_set<Args...>& nodes, int number_of_predecessors,
+                   Body body, node_priority_t priority )
+        : continue_node(nodes, number_of_predecessors, body, Policy(), priority) {}
+#endif
+#endif
+
+    //! Copy constructor
+    __TBB_NOINLINE_SYM continue_node( const continue_node& src ) :
+        graph_node(src.my_graph), input_impl_type(src),
+        internal::function_output<Output>(src.my_graph) {
+        tbb::internal::fgt_node_with_body( CODEPTR(), tbb::internal::FLOW_CONTINUE_NODE, &this->my_graph,
+                                           static_cast<receiver<input_type> *>(this),
+                                           static_cast<sender<output_type> *>(this), this->my_body );
     }
 
 #if TBB_PREVIEW_FLOW_GRAPH_TRACE
@@ -1621,15 +1879,26 @@ class write_once_node : public overwrite_node<T> {
     }
 #endif
 
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
+    void extract() __TBB_override {
+        input_impl_type::my_built_predecessors.receiver_extract(*this);
+        successors().built_successors().sender_extract(*this);
+    }
+#endif
+
 protected:
     template< typename R, typename B > friend class run_and_put_task;
     template<typename X, typename Y> friend class internal::broadcast_cache;
     template<typename X, typename Y> friend class internal::round_robin_cache;
-    task *try_put_task( const T &v ) __TBB_override {
-        spin_mutex::scoped_lock l( this->my_mutex );
-        return this->my_buffer_is_valid ? NULL : this->try_put_task_impl(v);
+    using input_impl_type::try_put_task;
+    internal::broadcast_cache<output_type> &successors () __TBB_override { return fOutput_type::my_successors; }
+
+    void reset_node(reset_flags f) __TBB_override {
+        input_impl_type::reset_receiver(f);
+        if(f & rf_clear_edges)successors().clear();
+        __TBB_ASSERT(!(f & rf_clear_edges) || successors().empty(), "continue_node not reset");
     }
-};
+};  // continue_node
 
 //! Forwards messages of type T to all successors
 template <typename T>
@@ -1639,30 +1908,37 @@ class broadcast_node : public graph_node, public receiver<T>, public sender<T> {
     typedef T output_type;
     typedef typename receiver<input_type>::predecessor_type predecessor_type;
     typedef typename sender<output_type>::successor_type successor_type;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
     typedef typename receiver<input_type>::predecessor_list_type predecessor_list_type;
     typedef typename sender<output_type>::successor_list_type successor_list_type;
 #endif
 private:
     internal::broadcast_cache<input_type> my_successors;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
     internal::edge_container<predecessor_type> my_built_predecessors;
     spin_mutex pred_mutex;  // serialize accesses on edge_container
 #endif
 public:
 
-    explicit broadcast_node(graph& g) : graph_node(g) {
+    __TBB_NOINLINE_SYM explicit broadcast_node(graph& g) : graph_node(g) {
         my_successors.set_owner( this );
-        tbb::internal::fgt_node( tbb::internal::FLOW_BROADCAST_NODE, &this->my_graph,
+        tbb::internal::fgt_node( CODEPTR(), tbb::internal::FLOW_BROADCAST_NODE, &this->my_graph,
                                  static_cast<receiver<input_type> *>(this), static_cast<sender<output_type> *>(this) );
     }
 
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+    template <typename... Args>
+    broadcast_node(const node_set<Args...>& nodes) : broadcast_node(nodes.graph_reference()) {
+        make_edges_in_order(nodes, *this);
+    }
+#endif
+
     // Copy constructor
-    broadcast_node( const broadcast_node& src ) :
+    __TBB_NOINLINE_SYM broadcast_node( const broadcast_node& src ) :
         graph_node(src.my_graph), receiver<T>(), sender<T>()
     {
         my_successors.set_owner( this );
-        tbb::internal::fgt_node( tbb::internal::FLOW_BROADCAST_NODE, &this->my_graph,
+        tbb::internal::fgt_node( CODEPTR(), tbb::internal::FLOW_BROADCAST_NODE, &this->my_graph,
                                  static_cast<receiver<input_type> *>(this), static_cast<sender<output_type> *>(this) );
     }
 
@@ -1684,7 +1960,7 @@ class broadcast_node : public graph_node, public receiver<T>, public sender<T> {
         return true;
     }
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
     typedef typename sender<T>::built_successors_type built_successors_type;
 
     built_successors_type &built_successors() __TBB_override { return my_successors.built_successors(); }
@@ -1707,7 +1983,7 @@ class broadcast_node : public graph_node, public receiver<T>, public sender<T> {
 
     typedef typename receiver<T>::built_predecessors_type built_predecessors_type;
 
-    built_predecessors_type &built_predecessors() __TBB_override { return my_built_predecessors; } 
+    built_predecessors_type &built_predecessors() __TBB_override { return my_built_predecessors; }
 
     void internal_add_built_predecessor( predecessor_type &p) __TBB_override {
         spin_mutex::scoped_lock l(pred_mutex);
@@ -1733,7 +2009,7 @@ class broadcast_node : public graph_node, public receiver<T>, public sender<T> {
         my_built_predecessors.receiver_extract(*this);
         my_successors.built_successors().sender_extract(*this);
     }
-#endif  /* TBB_PREVIEW_FLOW_GRAPH_FEATURES */
+#endif  /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
 
 protected:
     template< typename R, typename B > friend class run_and_put_task;
@@ -1746,7 +2022,7 @@ class broadcast_node : public graph_node, public receiver<T>, public sender<T> {
         return new_task;
     }
 
-    graph& graph_reference() __TBB_override {
+    graph& graph_reference() const __TBB_override {
         return my_graph;
     }
 
@@ -1755,7 +2031,7 @@ class broadcast_node : public graph_node, public receiver<T>, public sender<T> {
     void reset_node(reset_flags f) __TBB_override {
         if (f&rf_clear_edges) {
            my_successors.clear();
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
            my_built_predecessors.clear();
 #endif
         }
@@ -1764,30 +2040,50 @@ class broadcast_node : public graph_node, public receiver<T>, public sender<T> {
 };  // broadcast_node
 
 //! Forwards messages in arbitrary order
-template <typename T, typename A=cache_aligned_allocator<T> >
-class buffer_node : public graph_node, public internal::reservable_item_buffer<T, A>, public receiver<T>, public sender<T> {
+template <typename T, typename Allocator=__TBB_DEFAULT_NODE_ALLOCATOR(T) >
+class buffer_node
+    : public graph_node
+#if TBB_DEPRECATED_FLOW_NODE_ALLOCATOR
+    , public internal::reservable_item_buffer< T, Allocator >
+#else
+    , public internal::reservable_item_buffer< T, cache_aligned_allocator<T> >
+#endif
+    , public receiver<T>, public sender<T> {
+#if TBB_DEPRECATED_FLOW_NODE_ALLOCATOR
+    typedef Allocator internals_allocator;
+#else
+    typedef cache_aligned_allocator<T> internals_allocator;
+#endif
 public:
     typedef T input_type;
     typedef T output_type;
     typedef typename receiver<input_type>::predecessor_type predecessor_type;
     typedef typename sender<output_type>::successor_type successor_type;
-    typedef buffer_node<T, A> class_type;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+    typedef buffer_node<T, Allocator> class_type;
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
     typedef typename receiver<input_type>::predecessor_list_type predecessor_list_type;
     typedef typename sender<output_type>::successor_list_type successor_list_type;
 #endif
+#if !TBB_DEPRECATED_FLOW_NODE_ALLOCATOR
+    __TBB_STATIC_ASSERT(
+        (tbb::internal::is_same_type<Allocator, null_type>::value),
+        "Allocator template parameter for flow graph nodes is deprecated and will be removed. "
+        "Specify TBB_DEPRECATED_FLOW_NODE_ALLOCATOR to temporary enable the deprecated interface."
+    );
+#endif
+
 protected:
     typedef size_t size_type;
     internal::round_robin_cache< T, null_rw_mutex > my_successors;
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
     internal::edge_container<predecessor_type> my_built_predecessors;
 #endif
 
-    friend class internal::forward_task_bypass< buffer_node< T, A > >;
+    friend class internal::forward_task_bypass< class_type >;
 
     enum op_type {reg_succ, rem_succ, req_item, res_item, rel_res, con_res, put_item, try_fwd_task
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
         , add_blt_succ, del_blt_succ,
         add_blt_pred, del_blt_pred,
         blt_succ_cnt, blt_pred_cnt,
@@ -1799,7 +2095,7 @@ class buffer_node : public graph_node, public internal::reservable_item_buffer<T
     class buffer_operation : public internal::aggregated_operation< buffer_operation > {
     public:
         char type;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
         task * ltask;
         union {
             input_type *elem;
@@ -1816,7 +2112,7 @@ class buffer_node : public graph_node, public internal::reservable_item_buffer<T
 #endif
         buffer_operation(const T& e, op_type t) : type(char(t))
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
                                                   , ltask(NULL), elem(const_cast<T*>(&e))
 #else
                                                   , elem(const_cast<T*>(&e)) , ltask(NULL)
@@ -1852,7 +2148,7 @@ class buffer_node : public graph_node, public internal::reservable_item_buffer<T
             case con_res:  internal_consume(tmp); try_forwarding = true; break;
             case put_item: try_forwarding = internal_push(tmp); break;
             case try_fwd_task: internal_forward_task(tmp); break;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
             // edge recording
             case add_blt_succ: internal_add_built_succ(tmp); break;
             case del_blt_succ: internal_del_built_succ(tmp); break;
@@ -1872,8 +2168,7 @@ class buffer_node : public graph_node, public internal::reservable_item_buffer<T
             if(internal::is_graph_active(this->my_graph)) {
                 forwarder_busy = true;
                 task *new_task = new(task::allocate_additional_child_of(*(this->my_graph.root_task()))) internal::
-                        forward_task_bypass
-                        < buffer_node<input_type, A> >(*this);
+                    forward_task_bypass<class_type>(*this);
                 // tmp should point to the last item handled by the aggregator.  This is the operation
                 // the handling thread enqueued.  So modifying that record will be okay.
                 // workaround for icc bug
@@ -1926,7 +2221,7 @@ class buffer_node : public graph_node, public internal::reservable_item_buffer<T
         __TBB_store_with_release(op->status, internal::SUCCEEDED);
     }
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
     typedef typename sender<T>::built_successors_type built_successors_type;
 
     built_successors_type &built_successors() __TBB_override { return my_successors.built_successors(); }
@@ -1943,7 +2238,7 @@ class buffer_node : public graph_node, public internal::reservable_item_buffer<T
 
     typedef typename receiver<T>::built_predecessors_type built_predecessors_type;
 
-    built_predecessors_type &built_predecessors() __TBB_override { return my_built_predecessors; } 
+    built_predecessors_type &built_predecessors() __TBB_override { return my_built_predecessors; }
 
     virtual void internal_add_built_pred(buffer_operation *op) {
         my_built_predecessors.add_edge(*(op->p));
@@ -1975,7 +2270,7 @@ class buffer_node : public graph_node, public internal::reservable_item_buffer<T
         __TBB_store_with_release(op->status, internal::SUCCEEDED);
     }
 
-#endif  /* TBB_PREVIEW_FLOW_GRAPH_FEATURES */
+#endif  /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
 
 private:
     void order() {}
@@ -2061,21 +2356,31 @@ class buffer_node : public graph_node, public internal::reservable_item_buffer<T
 
 public:
     //! Constructor
-    explicit buffer_node( graph &g ) : graph_node(g), internal::reservable_item_buffer<T>(),
-        forwarder_busy(false) {
+    __TBB_NOINLINE_SYM explicit buffer_node( graph &g )
+        : graph_node(g), internal::reservable_item_buffer<T, internals_allocator>(), receiver<T>(),
+          sender<T>(), forwarder_busy(false)
+    {
         my_successors.set_owner(this);
         my_aggregator.initialize_handler(handler_type(this));
-        tbb::internal::fgt_node( tbb::internal::FLOW_BUFFER_NODE, &this->my_graph,
+        tbb::internal::fgt_node( CODEPTR(), tbb::internal::FLOW_BUFFER_NODE, &this->my_graph,
                                  static_cast<receiver<input_type> *>(this), static_cast<sender<output_type> *>(this) );
     }
 
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+    template <typename... Args>
+    buffer_node(const node_set<Args...>& nodes) : buffer_node(nodes.graph_reference()) {
+        make_edges_in_order(nodes, *this);
+    }
+#endif
+
     //! Copy constructor
-    buffer_node( const buffer_node& src ) : graph_node(src.my_graph),
-        internal::reservable_item_buffer<T>(), receiver<T>(), sender<T>() {
-        forwarder_busy = false;
+    __TBB_NOINLINE_SYM buffer_node( const buffer_node& src )
+        : graph_node(src.my_graph), internal::reservable_item_buffer<T, internals_allocator>(),
+          receiver<T>(), sender<T>(), forwarder_busy(false)
+    {
         my_successors.set_owner(this);
         my_aggregator.initialize_handler(handler_type(this));
-        tbb::internal::fgt_node( tbb::internal::FLOW_BUFFER_NODE, &this->my_graph,
+        tbb::internal::fgt_node( CODEPTR(), tbb::internal::FLOW_BUFFER_NODE, &this->my_graph,
                                  static_cast<receiver<input_type> *>(this), static_cast<sender<output_type> *>(this) );
     }
 
@@ -2099,7 +2404,7 @@ class buffer_node : public graph_node, public internal::reservable_item_buffer<T
         return true;
     }
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
     void internal_add_built_successor( successor_type &r) __TBB_override {
         buffer_operation op_data(add_blt_succ);
         op_data.r = &r;
@@ -2148,7 +2453,7 @@ class buffer_node : public graph_node, public internal::reservable_item_buffer<T
         my_aggregator.execute(&op_data);
     }
 
-#endif
+#endif /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
 
     //! Removes a successor.
     /** Removes successor r from the list of successors.
@@ -2230,13 +2535,13 @@ class buffer_node : public graph_node, public internal::reservable_item_buffer<T
         return ft;
     }
 
-    graph& graph_reference() __TBB_override {
+    graph& graph_reference() const __TBB_override {
         return my_graph;
     }
 
     void reset_receiver(reset_flags /*f*/) __TBB_override { }
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
 public:
     void extract() __TBB_override {
         my_built_predecessors.receiver_extract(*this);
@@ -2246,11 +2551,11 @@ class buffer_node : public graph_node, public internal::reservable_item_buffer<T
 
 protected:
     void reset_node( reset_flags f) __TBB_override {
-        internal::reservable_item_buffer<T, A>::reset();
+        internal::reservable_item_buffer<T, internals_allocator>::reset();
         // TODO: just clear structures
         if (f&rf_clear_edges) {
             my_successors.clear();
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
             my_built_predecessors.clear();
 #endif
         }
@@ -2259,10 +2564,17 @@ class buffer_node : public graph_node, public internal::reservable_item_buffer<T
 };  // buffer_node
 
 //! Forwards messages in FIFO order
-template <typename T, typename A=cache_aligned_allocator<T> >
-class queue_node : public buffer_node<T, A> {
+template <typename T, typename Allocator=__TBB_DEFAULT_NODE_ALLOCATOR(T) >
+class queue_node : public buffer_node<T, Allocator> {
+#if !TBB_DEPRECATED_FLOW_NODE_ALLOCATOR
+    __TBB_STATIC_ASSERT(
+        (tbb::internal::is_same_type<Allocator, null_type>::value),
+        "Allocator template parameter for flow graph nodes is deprecated and will be removed. "
+        "Specify TBB_DEPRECATED_FLOW_NODE_ALLOCATOR to temporary enable the deprecated interface."
+    );
+#endif
 protected:
-    typedef buffer_node<T, A> base_type;
+    typedef buffer_node<T, Allocator> base_type;
     typedef typename base_type::size_type size_type;
     typedef typename base_type::buffer_operation queue_operation;
     typedef queue_node class_type;
@@ -2319,15 +2631,22 @@ class queue_node : public buffer_node<T, A> {
     typedef typename sender<output_type>::successor_type successor_type;
 
     //! Constructor
-    explicit queue_node( graph &g ) : base_type(g) {
-        tbb::internal::fgt_node( tbb::internal::FLOW_QUEUE_NODE, &(this->my_graph),
+    __TBB_NOINLINE_SYM explicit queue_node( graph &g ) : base_type(g) {
+        tbb::internal::fgt_node( CODEPTR(), tbb::internal::FLOW_QUEUE_NODE, &(this->my_graph),
                                  static_cast<receiver<input_type> *>(this),
                                  static_cast<sender<output_type> *>(this) );
     }
 
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+    template <typename... Args>
+    queue_node( const node_set<Args...>& nodes) : queue_node(nodes.graph_reference()) {
+        make_edges_in_order(nodes, *this);
+    }
+#endif
+
     //! Copy constructor
-    queue_node( const queue_node& src) : base_type(src) {
-        tbb::internal::fgt_node( tbb::internal::FLOW_QUEUE_NODE, &(this->my_graph),
+    __TBB_NOINLINE_SYM queue_node( const queue_node& src) : base_type(src) {
+        tbb::internal::fgt_node( CODEPTR(), tbb::internal::FLOW_QUEUE_NODE, &(this->my_graph),
                                  static_cast<receiver<input_type> *>(this),
                                  static_cast<sender<output_type> *>(this) );
     }
@@ -2345,12 +2664,19 @@ class queue_node : public buffer_node<T, A> {
 };  // queue_node
 
 //! Forwards messages in sequence order
-template< typename T, typename A=cache_aligned_allocator<T> >
-class sequencer_node : public queue_node<T, A> {
+template< typename T, typename Allocator=__TBB_DEFAULT_NODE_ALLOCATOR(T) >
+class sequencer_node : public queue_node<T, Allocator> {
     internal::function_body< T, size_t > *my_sequencer;
     // my_sequencer should be a benign function and must be callable
     // from a parallel context.  Does this mean it needn't be reset?
 public:
+#if !TBB_DEPRECATED_FLOW_NODE_ALLOCATOR
+    __TBB_STATIC_ASSERT(
+        (tbb::internal::is_same_type<Allocator, null_type>::value),
+        "Allocator template parameter for flow graph nodes is deprecated and will be removed. "
+        "Specify TBB_DEPRECATED_FLOW_NODE_ALLOCATOR to temporary enable the deprecated interface."
+    );
+#endif
     typedef T input_type;
     typedef T output_type;
     typedef typename receiver<input_type>::predecessor_type predecessor_type;
@@ -2358,17 +2684,25 @@ class sequencer_node : public queue_node<T, A> {
 
     //! Constructor
     template< typename Sequencer >
-    sequencer_node( graph &g, const Sequencer& s ) : queue_node<T, A>(g),
+    __TBB_NOINLINE_SYM sequencer_node( graph &g, const Sequencer& s ) : queue_node<T, Allocator>(g),
         my_sequencer(new internal::function_body_leaf< T, size_t, Sequencer>(s) ) {
-        tbb::internal::fgt_node( tbb::internal::FLOW_SEQUENCER_NODE, &(this->my_graph),
+        tbb::internal::fgt_node( CODEPTR(), tbb::internal::FLOW_SEQUENCER_NODE, &(this->my_graph),
                                  static_cast<receiver<input_type> *>(this),
                                  static_cast<sender<output_type> *>(this) );
     }
 
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+    template <typename Sequencer, typename... Args>
+    sequencer_node( const node_set<Args...>& nodes, const Sequencer& s)
+        : sequencer_node(nodes.graph_reference(), s) {
+        make_edges_in_order(nodes, *this);
+    }
+#endif
+
     //! Copy constructor
-    sequencer_node( const sequencer_node& src ) : queue_node<T, A>(src),
+    __TBB_NOINLINE_SYM sequencer_node( const sequencer_node& src ) : queue_node<T, Allocator>(src),
         my_sequencer( src.my_sequencer->clone() ) {
-        tbb::internal::fgt_node( tbb::internal::FLOW_SEQUENCER_NODE, &(this->my_graph),
+        tbb::internal::fgt_node( CODEPTR(), tbb::internal::FLOW_SEQUENCER_NODE, &(this->my_graph),
                                  static_cast<receiver<input_type> *>(this),
                                  static_cast<sender<output_type> *>(this) );
     }
@@ -2383,8 +2717,8 @@ class sequencer_node : public queue_node<T, A> {
 #endif
 
 protected:
-    typedef typename buffer_node<T, A>::size_type size_type;
-    typedef typename buffer_node<T, A>::buffer_operation sequencer_operation;
+    typedef typename buffer_node<T, Allocator>::size_type size_type;
+    typedef typename buffer_node<T, Allocator>::buffer_operation sequencer_operation;
 
 private:
     bool internal_push(sequencer_operation *op) __TBB_override {
@@ -2411,26 +2745,44 @@ class sequencer_node : public queue_node<T, A> {
 };  // sequencer_node
 
 //! Forwards messages in priority order
-template< typename T, typename Compare = std::less<T>, typename A=cache_aligned_allocator<T> >
-class priority_queue_node : public buffer_node<T, A> {
+template<typename T, typename Compare = std::less<T>, typename Allocator=__TBB_DEFAULT_NODE_ALLOCATOR(T)>
+class priority_queue_node : public buffer_node<T, Allocator> {
 public:
+#if !TBB_DEPRECATED_FLOW_NODE_ALLOCATOR
+    __TBB_STATIC_ASSERT(
+        (tbb::internal::is_same_type<Allocator, null_type>::value),
+        "Allocator template parameter for flow graph nodes is deprecated and will removed in the future. "
+        "To temporary enable the deprecated interface specify TBB_ENABLE_DEPRECATED_NODE_ALLOCATOR."
+    );
+#endif
     typedef T input_type;
     typedef T output_type;
-    typedef buffer_node<T,A> base_type;
+    typedef buffer_node<T,Allocator> base_type;
     typedef priority_queue_node class_type;
     typedef typename receiver<input_type>::predecessor_type predecessor_type;
     typedef typename sender<output_type>::successor_type successor_type;
 
     //! Constructor
-    explicit priority_queue_node( graph &g ) : buffer_node<T, A>(g), mark(0) {
-        tbb::internal::fgt_node( tbb::internal::FLOW_PRIORITY_QUEUE_NODE, &(this->my_graph),
+    __TBB_NOINLINE_SYM explicit priority_queue_node( graph &g, const Compare& comp = Compare() )
+        : buffer_node<T, Allocator>(g), compare(comp), mark(0) {
+        tbb::internal::fgt_node( CODEPTR(), tbb::internal::FLOW_PRIORITY_QUEUE_NODE, &(this->my_graph),
                                  static_cast<receiver<input_type> *>(this),
                                  static_cast<sender<output_type> *>(this) );
     }
 
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+    template <typename... Args>
+    priority_queue_node(const node_set<Args...>& nodes, const Compare& comp = Compare())
+        : priority_queue_node(nodes.graph_reference(), comp) {
+        make_edges_in_order(nodes, *this);
+    }
+#endif
+
     //! Copy constructor
-    priority_queue_node( const priority_queue_node &src ) : buffer_node<T, A>(src), mark(0) {
-        tbb::internal::fgt_node( tbb::internal::FLOW_PRIORITY_QUEUE_NODE, &(this->my_graph),
+    __TBB_NOINLINE_SYM priority_queue_node( const priority_queue_node &src )
+        : buffer_node<T, Allocator>(src), mark(0)
+    {
+        tbb::internal::fgt_node( CODEPTR(), tbb::internal::FLOW_PRIORITY_QUEUE_NODE, &(this->my_graph),
                                  static_cast<receiver<input_type> *>(this),
                                  static_cast<sender<output_type> *>(this) );
     }
@@ -2448,9 +2800,9 @@ class priority_queue_node : public buffer_node<T, A> {
         base_type::reset_node(f);
     }
 
-    typedef typename buffer_node<T, A>::size_type size_type;
-    typedef typename buffer_node<T, A>::item_type item_type;
-    typedef typename buffer_node<T, A>::buffer_operation prio_operation;
+    typedef typename buffer_node<T, Allocator>::size_type size_type;
+    typedef typename buffer_node<T, Allocator>::item_type item_type;
+    typedef typename buffer_node<T, Allocator>::buffer_operation prio_operation;
 
     //! Tries to forward valid items to successors
     void internal_forward_task(prio_operation *op) __TBB_override {
@@ -2621,18 +2973,22 @@ class priority_queue_node : public buffer_node<T, A> {
     }
 };  // priority_queue_node
 
+} // interfaceX
+
+namespace interface11 {
+
 //! Forwards messages only if the threshold has not been reached
 /** This node forwards items until its threshold is reached.
     It contains no buffering.  If the downstream node rejects, the
     message is dropped. */
-template< typename T >
+template< typename T, typename DecrementType=continue_msg >
 class limiter_node : public graph_node, public receiver< T >, public sender< T > {
 public:
     typedef T input_type;
     typedef T output_type;
     typedef typename receiver<input_type>::predecessor_type predecessor_type;
     typedef typename sender<output_type>::successor_type successor_type;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
     typedef typename receiver<input_type>::built_predecessors_type built_predecessors_type;
     typedef typename sender<output_type>::built_successors_type built_successors_type;
     typedef typename receiver<input_type>::predecessor_list_type predecessor_list_type;
@@ -2647,12 +3003,12 @@ class limiter_node : public graph_node, public receiver< T >, public sender< T >
     internal::reservable_predecessor_cache< T, spin_mutex > my_predecessors;
     spin_mutex my_mutex;
     internal::broadcast_cache< T > my_successors;
-    int init_decrement_predecessors;
+    __TBB_DEPRECATED_LIMITER_EXPR( int init_decrement_predecessors; )
 
-    friend class internal::forward_task_bypass< limiter_node<T> >;
+    friend class internal::forward_task_bypass< limiter_node<T,DecrementType> >;
 
     // Let decrementer call decrement_counter()
-    friend class internal::decrementer< limiter_node<T> >;
+    friend class internal::decrementer< limiter_node<T,DecrementType>, DecrementType >;
 
     bool check_conditions() {  // always called under lock
         return ( my_count + my_tries < my_threshold && !my_predecessors.empty() && !my_successors.empty() );
@@ -2685,7 +3041,7 @@ class limiter_node : public graph_node, public receiver< T >, public sender< T >
                     if ( check_conditions() ) {
                         if ( internal::is_graph_active(this->my_graph) ) {
                             task *rtask = new ( task::allocate_additional_child_of( *(this->my_graph.root_task()) ) )
-                                internal::forward_task_bypass< limiter_node<T> >( *this );
+                                internal::forward_task_bypass< limiter_node<T, DecrementType> >( *this );
                             internal::spawn_in_graph_arena(graph_reference(), *rtask);
                         }
                     }
@@ -2703,7 +3059,7 @@ class limiter_node : public graph_node, public receiver< T >, public sender< T >
             if ( check_conditions() ) {
                 if ( internal::is_graph_active(this->my_graph) ) {
                     task *rtask = new ( task::allocate_additional_child_of( *(this->my_graph.root_task()) ) )
-                        internal::forward_task_bypass< limiter_node<T> >( *this );
+                        internal::forward_task_bypass< limiter_node<T, DecrementType> >( *this );
                     __TBB_ASSERT(!rval, "Have two tasks to handle");
                     return rtask;
                 }
@@ -2717,45 +3073,67 @@ class limiter_node : public graph_node, public receiver< T >, public sender< T >
         return;
     }
 
-    task * decrement_counter() {
+    task* decrement_counter( long long delta ) {
         {
             spin_mutex::scoped_lock lock(my_mutex);
-            if(my_count) --my_count;
+            if( delta > 0 && size_t(delta) > my_count )
+                my_count = 0;
+            else if( delta < 0 && size_t(delta) > my_threshold - my_count )
+                my_count = my_threshold;
+            else
+                my_count -= size_t(delta); // absolute value of delta is sufficiently small
         }
         return forward_task();
     }
 
-public:
-    //! The internal receiver< continue_msg > that decrements the count
-    internal::decrementer< limiter_node<T> > decrement;
-
-    //! Constructor
-    limiter_node(graph &g, size_t threshold, int num_decrement_predecessors=0) :
-        graph_node(g), my_threshold(threshold), my_count(0), my_tries(0),
-        init_decrement_predecessors(num_decrement_predecessors),
-        decrement(num_decrement_predecessors)
-    {
+    void initialize() {
         my_predecessors.set_owner(this);
         my_successors.set_owner(this);
         decrement.set_owner(this);
-        tbb::internal::fgt_node( tbb::internal::FLOW_LIMITER_NODE, &this->my_graph,
-                                 static_cast<receiver<input_type> *>(this), static_cast<receiver<continue_msg> *>(&decrement),
-                                 static_cast<sender<output_type> *>(this) );
+        tbb::internal::fgt_node(
+            CODEPTR(), tbb::internal::FLOW_LIMITER_NODE, &this->my_graph,
+            static_cast<receiver<input_type> *>(this), static_cast<receiver<DecrementType> *>(&decrement),
+            static_cast<sender<output_type> *>(this)
+        );
     }
+public:
+    //! The internal receiver< DecrementType > that decrements the count
+    internal::decrementer< limiter_node<T, DecrementType>, DecrementType > decrement;
+
+#if TBB_DEPRECATED_LIMITER_NODE_CONSTRUCTOR
+    __TBB_STATIC_ASSERT( (tbb::internal::is_same_type<DecrementType, continue_msg>::value),
+                         "Deprecated interface of the limiter node can be used only in conjunction "
+                         "with continue_msg as the type of DecrementType template parameter." );
+#endif // Check for incompatible interface
+
+    //! Constructor
+    limiter_node(graph &g,
+                 __TBB_DEPRECATED_LIMITER_ARG2(size_t threshold, int num_decrement_predecessors=0))
+        : graph_node(g), my_threshold(threshold), my_count(0),
+          __TBB_DEPRECATED_LIMITER_ARG4(
+              my_tries(0), decrement(),
+              init_decrement_predecessors(num_decrement_predecessors),
+              decrement(num_decrement_predecessors)) {
+        initialize();
+    }
+
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+    template <typename... Args>
+    limiter_node(const node_set<Args...>& nodes, size_t threshold)
+        : limiter_node(nodes.graph_reference(), threshold) {
+        make_edges_in_order(nodes, *this);
+    }
+#endif
 
     //! Copy constructor
     limiter_node( const limiter_node& src ) :
         graph_node(src.my_graph), receiver<T>(), sender<T>(),
-        my_threshold(src.my_threshold), my_count(0), my_tries(0),
-        init_decrement_predecessors(src.init_decrement_predecessors),
-        decrement(src.init_decrement_predecessors)
-    {
-        my_predecessors.set_owner(this);
-        my_successors.set_owner(this);
-        decrement.set_owner(this);
-        tbb::internal::fgt_node( tbb::internal::FLOW_LIMITER_NODE, &this->my_graph,
-                                 static_cast<receiver<input_type> *>(this), static_cast<receiver<continue_msg> *>(&decrement),
-                                 static_cast<sender<output_type> *>(this) );
+        my_threshold(src.my_threshold), my_count(0),
+        __TBB_DEPRECATED_LIMITER_ARG4(
+            my_tries(0), decrement(),
+            init_decrement_predecessors(src.init_decrement_predecessors),
+            decrement(src.init_decrement_predecessors)) {
+        initialize();
     }
 
 #if TBB_PREVIEW_FLOW_GRAPH_TRACE
@@ -2773,7 +3151,7 @@ class limiter_node : public graph_node, public receiver< T >, public sender< T >
         if ( was_empty && !my_predecessors.empty() && my_count + my_tries < my_threshold ) {
             if ( internal::is_graph_active(this->my_graph) ) {
                 task* task = new ( task::allocate_additional_child_of( *(this->my_graph.root_task()) ) )
-                            internal::forward_task_bypass < limiter_node<T> >( *this );
+                    internal::forward_task_bypass < limiter_node<T, DecrementType> >( *this );
                 internal::spawn_in_graph_arena(graph_reference(), *task);
             }
         }
@@ -2788,7 +3166,7 @@ class limiter_node : public graph_node, public receiver< T >, public sender< T >
         return true;
     }
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
     built_successors_type &built_successors() __TBB_override { return my_successors.built_successors(); }
     built_predecessors_type &built_predecessors() __TBB_override { return my_predecessors.built_predecessors(); }
 
@@ -2826,7 +3204,7 @@ class limiter_node : public graph_node, public receiver< T >, public sender< T >
         my_predecessors.built_predecessors().receiver_extract(*this);
         decrement.built_predecessors().receiver_extract(decrement);
     }
-#endif  /* TBB_PREVIEW_FLOW_GRAPH_FEATURES */
+#endif  /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
 
     //! Adds src to the list of cached predecessors.
     bool register_predecessor( predecessor_type &src ) __TBB_override {
@@ -2834,7 +3212,7 @@ class limiter_node : public graph_node, public receiver< T >, public sender< T >
         my_predecessors.add( src );
         if ( my_count + my_tries < my_threshold && !my_successors.empty() && internal::is_graph_active(this->my_graph) ) {
             task* task = new ( task::allocate_additional_child_of( *(this->my_graph.root_task()) ) )
-                        internal::forward_task_bypass < limiter_node<T> >( *this );
+                internal::forward_task_bypass < limiter_node<T, DecrementType> >( *this );
             internal::spawn_in_graph_arena(graph_reference(), *task);
         }
         return true;
@@ -2868,7 +3246,7 @@ class limiter_node : public graph_node, public receiver< T >, public sender< T >
             --my_tries;
             if (check_conditions() && internal::is_graph_active(this->my_graph)) {
                 rtask = new ( task::allocate_additional_child_of( *(this->my_graph.root_task()) ) )
-                    internal::forward_task_bypass< limiter_node<T> >( *this );
+                    internal::forward_task_bypass< limiter_node<T, DecrementType> >( *this );
             }
         }
         else {
@@ -2879,9 +3257,7 @@ class limiter_node : public graph_node, public receiver< T >, public sender< T >
         return rtask;
     }
 
-    graph& graph_reference() __TBB_override {
-        return my_graph;
-    }
+    graph& graph_reference() const __TBB_override { return my_graph; }
 
     void reset_receiver(reset_flags /*f*/) __TBB_override {
         __TBB_ASSERT(false,NULL);  // should never be called
@@ -2919,12 +3295,20 @@ class join_node<OutputTuple,reserving>: public internal::unfolded_join_node<tbb:
 public:
     typedef OutputTuple output_type;
     typedef typename unfolded_type::input_ports_type input_ports_type;
-    explicit join_node(graph &g) : unfolded_type(g) {
-        tbb::internal::fgt_multiinput_node<N>( tbb::internal::FLOW_JOIN_NODE_RESERVING, &this->my_graph,
+     __TBB_NOINLINE_SYM explicit join_node(graph &g) : unfolded_type(g) {
+        tbb::internal::fgt_multiinput_node<N>( CODEPTR(), tbb::internal::FLOW_JOIN_NODE_RESERVING, &this->my_graph,
                                             this->input_ports(), static_cast< sender< output_type > *>(this) );
     }
-    join_node(const join_node &other) : unfolded_type(other) {
-        tbb::internal::fgt_multiinput_node<N>( tbb::internal::FLOW_JOIN_NODE_RESERVING, &this->my_graph,
+
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+    template <typename... Args>
+    __TBB_NOINLINE_SYM join_node(const node_set<Args...>& nodes, reserving = reserving()) : join_node(nodes.graph_reference()) {
+        make_edges_in_order(nodes, *this);
+    }
+#endif
+
+    __TBB_NOINLINE_SYM join_node(const join_node &other) : unfolded_type(other) {
+        tbb::internal::fgt_multiinput_node<N>( CODEPTR(), tbb::internal::FLOW_JOIN_NODE_RESERVING, &this->my_graph,
                                             this->input_ports(), static_cast< sender< output_type > *>(this) );
     }
 
@@ -2944,12 +3328,20 @@ class join_node<OutputTuple,queueing>: public internal::unfolded_join_node<tbb::
 public:
     typedef OutputTuple output_type;
     typedef typename unfolded_type::input_ports_type input_ports_type;
-    explicit join_node(graph &g) : unfolded_type(g) {
-        tbb::internal::fgt_multiinput_node<N>( tbb::internal::FLOW_JOIN_NODE_QUEUEING, &this->my_graph,
+     __TBB_NOINLINE_SYM explicit join_node(graph &g) : unfolded_type(g) {
+        tbb::internal::fgt_multiinput_node<N>( CODEPTR(), tbb::internal::FLOW_JOIN_NODE_QUEUEING, &this->my_graph,
                                             this->input_ports(), static_cast< sender< output_type > *>(this) );
     }
-    join_node(const join_node &other) : unfolded_type(other) {
-        tbb::internal::fgt_multiinput_node<N>( tbb::internal::FLOW_JOIN_NODE_QUEUEING, &this->my_graph,
+
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+    template <typename... Args>
+    __TBB_NOINLINE_SYM join_node(const node_set<Args...>& nodes, queueing = queueing()) : join_node(nodes.graph_reference()) {
+        make_edges_in_order(nodes, *this);
+    }
+#endif
+
+    __TBB_NOINLINE_SYM join_node(const join_node &other) : unfolded_type(other) {
+        tbb::internal::fgt_multiinput_node<N>( CODEPTR(), tbb::internal::FLOW_JOIN_NODE_QUEUEING, &this->my_graph,
                                             this->input_ports(), static_cast< sender< output_type > *>(this) );
     }
 
@@ -2975,76 +3367,94 @@ class join_node<OutputTuple, key_matching<K, KHash> > : public internal::unfolde
 
 #if __TBB_PREVIEW_MESSAGE_BASED_KEY_MATCHING
     join_node(graph &g) : unfolded_type(g) {}
+
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+    template <typename... Args>
+    join_node(const node_set<Args...>& nodes, key_matching<K, KHash> = key_matching<K, KHash>())
+        : join_node(nodes.graph_reference()) {
+        make_edges_in_order(nodes, *this);
+    }
+#endif
+
 #endif  /* __TBB_PREVIEW_MESSAGE_BASED_KEY_MATCHING */
 
     template<typename __TBB_B0, typename __TBB_B1>
-    join_node(graph &g, __TBB_B0 b0, __TBB_B1 b1) : unfolded_type(g, b0, b1) {
-        tbb::internal::fgt_multiinput_node<N>( tbb::internal::FLOW_JOIN_NODE_TAG_MATCHING, &this->my_graph,
+     __TBB_NOINLINE_SYM join_node(graph &g, __TBB_B0 b0, __TBB_B1 b1) : unfolded_type(g, b0, b1) {
+        tbb::internal::fgt_multiinput_node<N>( CODEPTR(), tbb::internal::FLOW_JOIN_NODE_TAG_MATCHING, &this->my_graph,
                                                            this->input_ports(), static_cast< sender< output_type > *>(this) );
     }
     template<typename __TBB_B0, typename __TBB_B1, typename __TBB_B2>
-    join_node(graph &g, __TBB_B0 b0, __TBB_B1 b1, __TBB_B2 b2) : unfolded_type(g, b0, b1, b2) {
-        tbb::internal::fgt_multiinput_node<N>( tbb::internal::FLOW_JOIN_NODE_TAG_MATCHING, &this->my_graph,
+     __TBB_NOINLINE_SYM join_node(graph &g, __TBB_B0 b0, __TBB_B1 b1, __TBB_B2 b2) : unfolded_type(g, b0, b1, b2) {
+        tbb::internal::fgt_multiinput_node<N>( CODEPTR(), tbb::internal::FLOW_JOIN_NODE_TAG_MATCHING, &this->my_graph,
                                                            this->input_ports(), static_cast< sender< output_type > *>(this) );
     }
     template<typename __TBB_B0, typename __TBB_B1, typename __TBB_B2, typename __TBB_B3>
-    join_node(graph &g, __TBB_B0 b0, __TBB_B1 b1, __TBB_B2 b2, __TBB_B3 b3) : unfolded_type(g, b0, b1, b2, b3) {
-        tbb::internal::fgt_multiinput_node<N>( tbb::internal::FLOW_JOIN_NODE_TAG_MATCHING, &this->my_graph,
+     __TBB_NOINLINE_SYM join_node(graph &g, __TBB_B0 b0, __TBB_B1 b1, __TBB_B2 b2, __TBB_B3 b3) : unfolded_type(g, b0, b1, b2, b3) {
+        tbb::internal::fgt_multiinput_node<N>( CODEPTR(), tbb::internal::FLOW_JOIN_NODE_TAG_MATCHING, &this->my_graph,
                                                            this->input_ports(), static_cast< sender< output_type > *>(this) );
     }
     template<typename __TBB_B0, typename __TBB_B1, typename __TBB_B2, typename __TBB_B3, typename __TBB_B4>
-    join_node(graph &g, __TBB_B0 b0, __TBB_B1 b1, __TBB_B2 b2, __TBB_B3 b3, __TBB_B4 b4) :
+     __TBB_NOINLINE_SYM join_node(graph &g, __TBB_B0 b0, __TBB_B1 b1, __TBB_B2 b2, __TBB_B3 b3, __TBB_B4 b4) :
             unfolded_type(g, b0, b1, b2, b3, b4) {
-        tbb::internal::fgt_multiinput_node<N>( tbb::internal::FLOW_JOIN_NODE_TAG_MATCHING, &this->my_graph,
+        tbb::internal::fgt_multiinput_node<N>( CODEPTR(), tbb::internal::FLOW_JOIN_NODE_TAG_MATCHING, &this->my_graph,
                                                            this->input_ports(), static_cast< sender< output_type > *>(this) );
     }
 #if __TBB_VARIADIC_MAX >= 6
     template<typename __TBB_B0, typename __TBB_B1, typename __TBB_B2, typename __TBB_B3, typename __TBB_B4,
         typename __TBB_B5>
-    join_node(graph &g, __TBB_B0 b0, __TBB_B1 b1, __TBB_B2 b2, __TBB_B3 b3, __TBB_B4 b4, __TBB_B5 b5) :
+     __TBB_NOINLINE_SYM join_node(graph &g, __TBB_B0 b0, __TBB_B1 b1, __TBB_B2 b2, __TBB_B3 b3, __TBB_B4 b4, __TBB_B5 b5) :
             unfolded_type(g, b0, b1, b2, b3, b4, b5) {
-        tbb::internal::fgt_multiinput_node<N>( tbb::internal::FLOW_JOIN_NODE_TAG_MATCHING, &this->my_graph,
+        tbb::internal::fgt_multiinput_node<N>( CODEPTR(), tbb::internal::FLOW_JOIN_NODE_TAG_MATCHING, &this->my_graph,
                                                            this->input_ports(), static_cast< sender< output_type > *>(this) );
     }
 #endif
 #if __TBB_VARIADIC_MAX >= 7
     template<typename __TBB_B0, typename __TBB_B1, typename __TBB_B2, typename __TBB_B3, typename __TBB_B4,
         typename __TBB_B5, typename __TBB_B6>
-    join_node(graph &g, __TBB_B0 b0, __TBB_B1 b1, __TBB_B2 b2, __TBB_B3 b3, __TBB_B4 b4, __TBB_B5 b5, __TBB_B6 b6) :
+     __TBB_NOINLINE_SYM join_node(graph &g, __TBB_B0 b0, __TBB_B1 b1, __TBB_B2 b2, __TBB_B3 b3, __TBB_B4 b4, __TBB_B5 b5, __TBB_B6 b6) :
             unfolded_type(g, b0, b1, b2, b3, b4, b5, b6) {
-        tbb::internal::fgt_multiinput_node<N>( tbb::internal::FLOW_JOIN_NODE_TAG_MATCHING, &this->my_graph,
+        tbb::internal::fgt_multiinput_node<N>( CODEPTR(), tbb::internal::FLOW_JOIN_NODE_TAG_MATCHING, &this->my_graph,
                                                            this->input_ports(), static_cast< sender< output_type > *>(this) );
     }
 #endif
 #if __TBB_VARIADIC_MAX >= 8
     template<typename __TBB_B0, typename __TBB_B1, typename __TBB_B2, typename __TBB_B3, typename __TBB_B4,
         typename __TBB_B5, typename __TBB_B6, typename __TBB_B7>
-    join_node(graph &g, __TBB_B0 b0, __TBB_B1 b1, __TBB_B2 b2, __TBB_B3 b3, __TBB_B4 b4, __TBB_B5 b5, __TBB_B6 b6,
+     __TBB_NOINLINE_SYM join_node(graph &g, __TBB_B0 b0, __TBB_B1 b1, __TBB_B2 b2, __TBB_B3 b3, __TBB_B4 b4, __TBB_B5 b5, __TBB_B6 b6,
             __TBB_B7 b7) : unfolded_type(g, b0, b1, b2, b3, b4, b5, b6, b7) {
-        tbb::internal::fgt_multiinput_node<N>( tbb::internal::FLOW_JOIN_NODE_TAG_MATCHING, &this->my_graph,
+        tbb::internal::fgt_multiinput_node<N>( CODEPTR(), tbb::internal::FLOW_JOIN_NODE_TAG_MATCHING, &this->my_graph,
                                                            this->input_ports(), static_cast< sender< output_type > *>(this) );
     }
 #endif
 #if __TBB_VARIADIC_MAX >= 9
     template<typename __TBB_B0, typename __TBB_B1, typename __TBB_B2, typename __TBB_B3, typename __TBB_B4,
         typename __TBB_B5, typename __TBB_B6, typename __TBB_B7, typename __TBB_B8>
-    join_node(graph &g, __TBB_B0 b0, __TBB_B1 b1, __TBB_B2 b2, __TBB_B3 b3, __TBB_B4 b4, __TBB_B5 b5, __TBB_B6 b6,
+     __TBB_NOINLINE_SYM join_node(graph &g, __TBB_B0 b0, __TBB_B1 b1, __TBB_B2 b2, __TBB_B3 b3, __TBB_B4 b4, __TBB_B5 b5, __TBB_B6 b6,
             __TBB_B7 b7, __TBB_B8 b8) : unfolded_type(g, b0, b1, b2, b3, b4, b5, b6, b7, b8) {
-        tbb::internal::fgt_multiinput_node<N>( tbb::internal::FLOW_JOIN_NODE_TAG_MATCHING, &this->my_graph,
+        tbb::internal::fgt_multiinput_node<N>( CODEPTR(), tbb::internal::FLOW_JOIN_NODE_TAG_MATCHING, &this->my_graph,
                                                            this->input_ports(), static_cast< sender< output_type > *>(this) );
     }
 #endif
 #if __TBB_VARIADIC_MAX >= 10
     template<typename __TBB_B0, typename __TBB_B1, typename __TBB_B2, typename __TBB_B3, typename __TBB_B4,
         typename __TBB_B5, typename __TBB_B6, typename __TBB_B7, typename __TBB_B8, typename __TBB_B9>
-    join_node(graph &g, __TBB_B0 b0, __TBB_B1 b1, __TBB_B2 b2, __TBB_B3 b3, __TBB_B4 b4, __TBB_B5 b5, __TBB_B6 b6,
+     __TBB_NOINLINE_SYM join_node(graph &g, __TBB_B0 b0, __TBB_B1 b1, __TBB_B2 b2, __TBB_B3 b3, __TBB_B4 b4, __TBB_B5 b5, __TBB_B6 b6,
             __TBB_B7 b7, __TBB_B8 b8, __TBB_B9 b9) : unfolded_type(g, b0, b1, b2, b3, b4, b5, b6, b7, b8, b9) {
-        tbb::internal::fgt_multiinput_node<N>( tbb::internal::FLOW_JOIN_NODE_TAG_MATCHING, &this->my_graph,
+        tbb::internal::fgt_multiinput_node<N>( CODEPTR(), tbb::internal::FLOW_JOIN_NODE_TAG_MATCHING, &this->my_graph,
                                                            this->input_ports(), static_cast< sender< output_type > *>(this) );
     }
 #endif
-    join_node(const join_node &other) : unfolded_type(other) {
-        tbb::internal::fgt_multiinput_node<N>( tbb::internal::FLOW_JOIN_NODE_TAG_MATCHING, &this->my_graph,
+
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+    template <typename... Args, typename... Bodies>
+    __TBB_NOINLINE_SYM join_node(const node_set<Args...>& nodes, Bodies... bodies)
+        : join_node(nodes.graph_reference(), bodies...) {
+        make_edges_in_order(nodes, *this);
+    }
+#endif
+
+    __TBB_NOINLINE_SYM join_node(const join_node &other) : unfolded_type(other) {
+        tbb::internal::fgt_multiinput_node<N>( CODEPTR(), tbb::internal::FLOW_JOIN_NODE_TAG_MATCHING, &this->my_graph,
                                                            this->input_ports(), static_cast< sender< output_type > *>(this) );
     }
 
@@ -3073,18 +3483,26 @@ class indexer_node<T0> : public internal::unfolded_indexer_node<tuple<T0> > {
     typedef tuple<T0> InputTuple;
     typedef typename internal::tagged_msg<size_t, T0> output_type;
     typedef typename internal::unfolded_indexer_node<InputTuple> unfolded_type;
-    indexer_node(graph& g) : unfolded_type(g) {
-        tbb::internal::fgt_multiinput_node<N>( tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
+    __TBB_NOINLINE_SYM indexer_node(graph& g) : unfolded_type(g) {
+        tbb::internal::fgt_multiinput_node<N>( CODEPTR(), tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
                                            this->input_ports(), static_cast< sender< output_type > *>(this) );
     }
+
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+    template <typename... Args>
+    indexer_node(const node_set<Args...>& nodes) : indexer_node(nodes.graph_reference()) {
+        make_edges_in_order(nodes, *this);
+    }
+#endif
+
     // Copy constructor
-    indexer_node( const indexer_node& other ) : unfolded_type(other) {
-        tbb::internal::fgt_multiinput_node<N>( tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
+    __TBB_NOINLINE_SYM indexer_node( const indexer_node& other ) : unfolded_type(other) {
+        tbb::internal::fgt_multiinput_node<N>( CODEPTR(), tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
                                            this->input_ports(), static_cast< sender< output_type > *>(this) );
     }
 
 #if TBB_PREVIEW_FLOW_GRAPH_TRACE
-     void set_name( const char *name ) {
+     void set_name( const char *name ) __TBB_override {
         tbb::internal::fgt_node_desc( this, name );
     }
 #endif
@@ -3098,18 +3516,26 @@ class indexer_node<T0, T1> : public internal::unfolded_indexer_node<tuple<T0, T1
     typedef tuple<T0, T1> InputTuple;
     typedef typename internal::tagged_msg<size_t, T0, T1> output_type;
     typedef typename internal::unfolded_indexer_node<InputTuple> unfolded_type;
-    indexer_node(graph& g) : unfolded_type(g) {
-        tbb::internal::fgt_multiinput_node<N>( tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
+    __TBB_NOINLINE_SYM indexer_node(graph& g) : unfolded_type(g) {
+        tbb::internal::fgt_multiinput_node<N>( CODEPTR(), tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
                                            this->input_ports(), static_cast< sender< output_type > *>(this) );
     }
+
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+    template <typename... Args>
+    indexer_node(const node_set<Args...>& nodes) : indexer_node(nodes.graph_reference()) {
+        make_edges_in_order(nodes, *this);
+    }
+#endif
+
     // Copy constructor
-    indexer_node( const indexer_node& other ) : unfolded_type(other) {
-        tbb::internal::fgt_multiinput_node<N>( tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
+    __TBB_NOINLINE_SYM indexer_node( const indexer_node& other ) : unfolded_type(other) {
+        tbb::internal::fgt_multiinput_node<N>( CODEPTR(), tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
                                            this->input_ports(), static_cast< sender< output_type > *>(this) );
     }
 
 #if TBB_PREVIEW_FLOW_GRAPH_TRACE
-     void set_name( const char *name ) {
+     void set_name( const char *name ) __TBB_override {
         tbb::internal::fgt_node_desc( this, name );
     }
 #endif
@@ -3123,18 +3549,26 @@ class indexer_node<T0, T1, T2> : public internal::unfolded_indexer_node<tuple<T0
     typedef tuple<T0, T1, T2> InputTuple;
     typedef typename internal::tagged_msg<size_t, T0, T1, T2> output_type;
     typedef typename internal::unfolded_indexer_node<InputTuple> unfolded_type;
-    indexer_node(graph& g) : unfolded_type(g) {
-        tbb::internal::fgt_multiinput_node<N>( tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
+    __TBB_NOINLINE_SYM indexer_node(graph& g) : unfolded_type(g) {
+        tbb::internal::fgt_multiinput_node<N>( CODEPTR(), tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
                                            this->input_ports(), static_cast< sender< output_type > *>(this) );
     }
+
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+    template <typename... Args>
+    indexer_node(const node_set<Args...>& nodes) : indexer_node(nodes.graph_reference()) {
+        make_edges_in_order(nodes, *this);
+    }
+#endif
+
     // Copy constructor
-    indexer_node( const indexer_node& other ) : unfolded_type(other) {
-        tbb::internal::fgt_multiinput_node<N>( tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
+    __TBB_NOINLINE_SYM indexer_node( const indexer_node& other ) : unfolded_type(other) {
+        tbb::internal::fgt_multiinput_node<N>( CODEPTR(), tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
                                            this->input_ports(), static_cast< sender< output_type > *>(this) );
     }
 
 #if TBB_PREVIEW_FLOW_GRAPH_TRACE
-        void set_name( const char *name ) {
+    void set_name( const char *name ) __TBB_override {
         tbb::internal::fgt_node_desc( this, name );
     }
 #endif
@@ -3148,13 +3582,21 @@ class indexer_node<T0, T1, T2, T3> : public internal::unfolded_indexer_node<tupl
     typedef tuple<T0, T1, T2, T3> InputTuple;
     typedef typename internal::tagged_msg<size_t, T0, T1, T2, T3> output_type;
     typedef typename internal::unfolded_indexer_node<InputTuple> unfolded_type;
-    indexer_node(graph& g) : unfolded_type(g) {
-        tbb::internal::fgt_multiinput_node<N>( tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
+    __TBB_NOINLINE_SYM indexer_node(graph& g) : unfolded_type(g) {
+        tbb::internal::fgt_multiinput_node<N>( CODEPTR(), tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
                                            this->input_ports(), static_cast< sender< output_type > *>(this) );
     }
+
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+    template <typename... Args>
+    indexer_node(const node_set<Args...>& nodes) : indexer_node(nodes.graph_reference()) {
+        make_edges_in_order(nodes, *this);
+    }
+#endif
+
     // Copy constructor
-    indexer_node( const indexer_node& other ) : unfolded_type(other) {
-        tbb::internal::fgt_multiinput_node<N>( tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
+    __TBB_NOINLINE_SYM indexer_node( const indexer_node& other ) : unfolded_type(other) {
+        tbb::internal::fgt_multiinput_node<N>( CODEPTR(), tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
                                            this->input_ports(), static_cast< sender< output_type > *>(this) );
     }
 
@@ -3173,13 +3615,21 @@ class indexer_node<T0, T1, T2, T3, T4> : public internal::unfolded_indexer_node<
     typedef tuple<T0, T1, T2, T3, T4> InputTuple;
     typedef typename internal::tagged_msg<size_t, T0, T1, T2, T3, T4> output_type;
     typedef typename internal::unfolded_indexer_node<InputTuple> unfolded_type;
-    indexer_node(graph& g) : unfolded_type(g) {
-        tbb::internal::fgt_multiinput_node<N>( tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
+    __TBB_NOINLINE_SYM indexer_node(graph& g) : unfolded_type(g) {
+        tbb::internal::fgt_multiinput_node<N>( CODEPTR(), tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
                                            this->input_ports(), static_cast< sender< output_type > *>(this) );
     }
+
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+    template <typename... Args>
+    indexer_node(const node_set<Args...>& nodes) : indexer_node(nodes.graph_reference()) {
+        make_edges_in_order(nodes, *this);
+    }
+#endif
+
     // Copy constructor
-    indexer_node( const indexer_node& other ) : unfolded_type(other) {
-        tbb::internal::fgt_multiinput_node<N>( tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
+    __TBB_NOINLINE_SYM indexer_node( const indexer_node& other ) : unfolded_type(other) {
+        tbb::internal::fgt_multiinput_node<N>( CODEPTR(), tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
                                            this->input_ports(), static_cast< sender< output_type > *>(this) );
     }
 
@@ -3199,13 +3649,21 @@ class indexer_node<T0, T1, T2, T3, T4, T5> : public internal::unfolded_indexer_n
     typedef tuple<T0, T1, T2, T3, T4, T5> InputTuple;
     typedef typename internal::tagged_msg<size_t, T0, T1, T2, T3, T4, T5> output_type;
     typedef typename internal::unfolded_indexer_node<InputTuple> unfolded_type;
-    indexer_node(graph& g) : unfolded_type(g) {
-        tbb::internal::fgt_multiinput_node<N>( tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
+    __TBB_NOINLINE_SYM indexer_node(graph& g) : unfolded_type(g) {
+        tbb::internal::fgt_multiinput_node<N>( CODEPTR(), tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
                                            this->input_ports(), static_cast< sender< output_type > *>(this) );
     }
+
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+    template <typename... Args>
+    indexer_node(const node_set<Args...>& nodes) : indexer_node(nodes.graph_reference()) {
+        make_edges_in_order(nodes, *this);
+    }
+#endif
+
     // Copy constructor
-    indexer_node( const indexer_node& other ) : unfolded_type(other) {
-        tbb::internal::fgt_multiinput_node<N>( tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
+    __TBB_NOINLINE_SYM indexer_node( const indexer_node& other ) : unfolded_type(other) {
+        tbb::internal::fgt_multiinput_node<N>( CODEPTR(), tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
                                            this->input_ports(), static_cast< sender< output_type > *>(this) );
     }
 
@@ -3227,13 +3685,21 @@ class indexer_node<T0, T1, T2, T3, T4, T5, T6> : public internal::unfolded_index
     typedef tuple<T0, T1, T2, T3, T4, T5, T6> InputTuple;
     typedef typename internal::tagged_msg<size_t, T0, T1, T2, T3, T4, T5, T6> output_type;
     typedef typename internal::unfolded_indexer_node<InputTuple> unfolded_type;
-    indexer_node(graph& g) : unfolded_type(g) {
-        tbb::internal::fgt_multiinput_node<N>( tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
+    __TBB_NOINLINE_SYM indexer_node(graph& g) : unfolded_type(g) {
+        tbb::internal::fgt_multiinput_node<N>( CODEPTR(), tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
                                            this->input_ports(), static_cast< sender< output_type > *>(this) );
     }
+
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+    template <typename... Args>
+    indexer_node(const node_set<Args...>& nodes) : indexer_node(nodes.graph_reference()) {
+        make_edges_in_order(nodes, *this);
+    }
+#endif
+
     // Copy constructor
-    indexer_node( const indexer_node& other ) : unfolded_type(other) {
-        tbb::internal::fgt_multiinput_node<N>( tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
+    __TBB_NOINLINE_SYM indexer_node( const indexer_node& other ) : unfolded_type(other) {
+        tbb::internal::fgt_multiinput_node<N>( CODEPTR(), tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
                                            this->input_ports(), static_cast< sender< output_type > *>(this) );
     }
 
@@ -3256,12 +3722,20 @@ class indexer_node<T0, T1, T2, T3, T4, T5, T6, T7> : public internal::unfolded_i
     typedef typename internal::tagged_msg<size_t, T0, T1, T2, T3, T4, T5, T6, T7> output_type;
     typedef typename internal::unfolded_indexer_node<InputTuple> unfolded_type;
     indexer_node(graph& g) : unfolded_type(g) {
-        tbb::internal::fgt_multiinput_node<N>( tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
+        tbb::internal::fgt_multiinput_node<N>( CODEPTR(), tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
                                            this->input_ports(), static_cast< sender< output_type > *>(this) );
     }
+
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+    template <typename... Args>
+    indexer_node(const node_set<Args...>& nodes) : indexer_node(nodes.graph_reference()) {
+        make_edges_in_order(nodes, *this);
+    }
+#endif
+
     // Copy constructor
     indexer_node( const indexer_node& other ) : unfolded_type(other) {
-        tbb::internal::fgt_multiinput_node<N>( tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
+        tbb::internal::fgt_multiinput_node<N>( CODEPTR(), tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
                                            this->input_ports(), static_cast< sender< output_type > *>(this) );
     }
 
@@ -3283,13 +3757,21 @@ class indexer_node<T0, T1, T2, T3, T4, T5, T6, T7, T8> : public internal::unfold
     typedef tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8> InputTuple;
     typedef typename internal::tagged_msg<size_t, T0, T1, T2, T3, T4, T5, T6, T7, T8> output_type;
     typedef typename internal::unfolded_indexer_node<InputTuple> unfolded_type;
-    indexer_node(graph& g) : unfolded_type(g) {
-        tbb::internal::fgt_multiinput_node<N>( tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
+    __TBB_NOINLINE_SYM indexer_node(graph& g) : unfolded_type(g) {
+        tbb::internal::fgt_multiinput_node<N>( CODEPTR(), tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
                                            this->input_ports(), static_cast< sender< output_type > *>(this) );
     }
+
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+    template <typename... Args>
+    indexer_node(const node_set<Args...>& nodes) : indexer_node(nodes.graph_reference()) {
+        make_edges_in_order(nodes, *this);
+    }
+#endif
+
     // Copy constructor
-    indexer_node( const indexer_node& other ) : unfolded_type(other) {
-        tbb::internal::fgt_multiinput_node<N>( tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
+    __TBB_NOINLINE_SYM indexer_node( const indexer_node& other ) : unfolded_type(other) {
+        tbb::internal::fgt_multiinput_node<N>( CODEPTR(), tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
                                            this->input_ports(), static_cast< sender< output_type > *>(this) );
     }
 
@@ -3311,13 +3793,21 @@ class indexer_node/*default*/ : public internal::unfolded_indexer_node<tuple<T0,
     typedef tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> InputTuple;
     typedef typename internal::tagged_msg<size_t, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> output_type;
     typedef typename internal::unfolded_indexer_node<InputTuple> unfolded_type;
-    indexer_node(graph& g) : unfolded_type(g) {
-        tbb::internal::fgt_multiinput_node<N>( tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
+    __TBB_NOINLINE_SYM indexer_node(graph& g) : unfolded_type(g) {
+        tbb::internal::fgt_multiinput_node<N>( CODEPTR(), tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
                                            this->input_ports(), static_cast< sender< output_type > *>(this) );
     }
+
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+    template <typename... Args>
+    indexer_node(const node_set<Args...>& nodes) : indexer_node(nodes.graph_reference()) {
+        make_edges_in_order(nodes, *this);
+    }
+#endif
+
     // Copy constructor
-    indexer_node( const indexer_node& other ) : unfolded_type(other) {
-        tbb::internal::fgt_multiinput_node<N>( tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
+    __TBB_NOINLINE_SYM indexer_node( const indexer_node& other ) : unfolded_type(other) {
+        tbb::internal::fgt_multiinput_node<N>( CODEPTR(), tbb::internal::FLOW_INDEXER_NODE, &this->my_graph,
                                            this->input_ports(), static_cast< sender< output_type > *>(this) );
     }
 
@@ -3335,7 +3825,7 @@ inline void internal_make_edge( internal::untyped_sender &p, internal::untyped_r
 template< typename T >
 inline void internal_make_edge( sender<T> &p, receiver<T> &s ) {
 #endif
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
     s.internal_add_built_predecessor(p);
     p.internal_add_built_successor(s);
 #endif
@@ -3399,7 +3889,7 @@ template< typename T >
 inline void internal_remove_edge( sender<T> &p, receiver<T> &s ) {
 #endif
     p.remove_successor( s );
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
     // TODO: should we try to remove p from the predecessor list of s, in case the edge is reversed?
     p.internal_delete_built_successor(s);
     s.internal_delete_built_predecessor(p);
@@ -3454,7 +3944,7 @@ inline void remove_edge( sender<S>& output, V& input) {
 }
 #endif
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
 template<typename C >
 template< typename S >
 void internal::edge_container<C>::sender_extract( S &s ) {
@@ -3472,7 +3962,7 @@ void internal::edge_container<C>::receiver_extract( R &r ) {
         remove_edge(**i, r);
     }
 }
-#endif  /* TBB_PREVIEW_FLOW_GRAPH_FEATURES */
+#endif  /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
 
 //! Returns a copy of the body from a function or continue node
 template< typename Body, typename Node >
@@ -3493,9 +3983,6 @@ class composite_node <tbb::flow::tuple<InputTypes...>, tbb::flow::tuple<OutputTy
     typedef tbb::flow::tuple< sender<OutputTypes>&... > output_ports_type;
 
 private:
-#if TBB_PREVIEW_FLOW_GRAPH_TRACE
-    const char *my_type_name;
-#endif
     std::unique_ptr<input_ports_type> my_input_ports;
     std::unique_ptr<output_ports_type> my_output_ports;
 
@@ -3507,38 +3994,32 @@ class composite_node <tbb::flow::tuple<InputTypes...>, tbb::flow::tuple<OutputTy
 
 public:
 #if TBB_PREVIEW_FLOW_GRAPH_TRACE
-    composite_node( graph &g, const char *type_name ) : graph_node(g), my_type_name(type_name) {
-        tbb::internal::fgt_multiinput_multioutput_node( tbb::internal::FLOW_COMPOSITE_NODE, this, &this->my_graph );
-        tbb::internal::fgt_multiinput_multioutput_node_desc( this, my_type_name );
+    composite_node( graph &g, const char *type_name = "composite_node" ) : graph_node(g) {
+        tbb::internal::fgt_multiinput_multioutput_node( CODEPTR(), tbb::internal::FLOW_COMPOSITE_NODE, this, &this->my_graph );
+        tbb::internal::fgt_multiinput_multioutput_node_desc( this, type_name );
     }
-#endif
+#else
     composite_node( graph &g ) : graph_node(g) {
-        tbb::internal::fgt_multiinput_multioutput_node( tbb::internal::FLOW_COMPOSITE_NODE, this, &this->my_graph );
+        tbb::internal::fgt_multiinput_multioutput_node( CODEPTR(), tbb::internal::FLOW_COMPOSITE_NODE, this, &this->my_graph );
     }
+#endif
 
-   template<typename T1, typename T2>
-   void set_external_ports(T1&& input_ports_tuple, T2&& output_ports_tuple) {
-       __TBB_STATIC_ASSERT(NUM_INPUTS == tbb::flow::tuple_size<input_ports_type>::value, "number of arguments does not match number of input ports");
-       __TBB_STATIC_ASSERT(NUM_OUTPUTS == tbb::flow::tuple_size<output_ports_type>::value, "number of arguments does not match number of output ports");
-       my_input_ports = tbb::internal::make_unique<input_ports_type>(std::forward<T1>(input_ports_tuple));
-       my_output_ports = tbb::internal::make_unique<output_ports_type>(std::forward<T2>(output_ports_tuple));
+    template<typename T1, typename T2>
+    void set_external_ports(T1&& input_ports_tuple, T2&& output_ports_tuple) {
+        __TBB_STATIC_ASSERT(NUM_INPUTS == tbb::flow::tuple_size<input_ports_type>::value, "number of arguments does not match number of input ports");
+        __TBB_STATIC_ASSERT(NUM_OUTPUTS == tbb::flow::tuple_size<output_ports_type>::value, "number of arguments does not match number of output ports");
+        my_input_ports = tbb::internal::make_unique<input_ports_type>(std::forward<T1>(input_ports_tuple));
+        my_output_ports = tbb::internal::make_unique<output_ports_type>(std::forward<T2>(output_ports_tuple));
 
-#if TBB_PREVIEW_FLOW_GRAPH_TRACE
-      tbb::internal::fgt_internal_input_alias_helper<T1, NUM_INPUTS>::alias_port( this, input_ports_tuple);
-      tbb::internal::fgt_internal_output_alias_helper<T2, NUM_OUTPUTS>::alias_port( this, output_ports_tuple);
-#endif
-   }
+        tbb::internal::fgt_internal_input_alias_helper<T1, NUM_INPUTS>::alias_port( this, input_ports_tuple);
+        tbb::internal::fgt_internal_output_alias_helper<T2, NUM_OUTPUTS>::alias_port( this, output_ports_tuple);
+    }
 
-#if TBB_PREVIEW_FLOW_GRAPH_TRACE
     template< typename... NodeTypes >
     void add_visible_nodes(const NodeTypes&... n) { internal::add_nodes_impl(this, true, n...); }
 
     template< typename... NodeTypes >
     void add_nodes(const NodeTypes&... n) { internal::add_nodes_impl(this, false, n...); }
-#else
-    template<typename... Nodes> void add_nodes(Nodes&...) { }
-    template<typename... Nodes> void add_visible_nodes(Nodes&...) { }
-#endif
 
 #if TBB_PREVIEW_FLOW_GRAPH_TRACE
     void set_name( const char *name ) __TBB_override {
@@ -3556,7 +4037,7 @@ class composite_node <tbb::flow::tuple<InputTypes...>, tbb::flow::tuple<OutputTy
          return *my_output_ports;
     }
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
     void extract() __TBB_override {
         __TBB_ASSERT(false, "Current composite_node implementation does not support extract");
     }
@@ -3570,9 +4051,6 @@ class composite_node <tbb::flow::tuple<InputTypes...>, tbb::flow::tuple<> > : pu
     typedef tbb::flow::tuple< receiver<InputTypes>&... > input_ports_type;
 
 private:
-#if TBB_PREVIEW_FLOW_GRAPH_TRACE
-    const char *my_type_name;
-#endif
     std::unique_ptr<input_ports_type> my_input_ports;
     static const size_t NUM_INPUTS = sizeof...(InputTypes);
 
@@ -3581,12 +4059,14 @@ class composite_node <tbb::flow::tuple<InputTypes...>, tbb::flow::tuple<> > : pu
 
 public:
 #if TBB_PREVIEW_FLOW_GRAPH_TRACE
-    composite_node( graph &g, const char *type_name = "composite_node") : graph_node(g), my_type_name(type_name) {
-        tbb::internal::itt_make_task_group( tbb::internal::ITT_DOMAIN_FLOW, this, tbb::internal::FLOW_NODE, &g, tbb::internal::FLOW_GRAPH, tbb::internal::FLOW_COMPOSITE_NODE );
-        tbb::internal::fgt_multiinput_multioutput_node_desc( this, my_type_name );
+    composite_node( graph &g, const char *type_name = "composite_node") : graph_node(g) {
+        tbb::internal::fgt_composite( CODEPTR(), this, &g );
+        tbb::internal::fgt_multiinput_multioutput_node_desc( this, type_name );
     }
 #else
-    composite_node( graph &g) : graph_node(g) {}
+    composite_node( graph &g ) : graph_node(g) {
+        tbb::internal::fgt_composite( CODEPTR(), this, &g );
+    }
 #endif
 
    template<typename T>
@@ -3595,21 +4075,14 @@ class composite_node <tbb::flow::tuple<InputTypes...>, tbb::flow::tuple<> > : pu
 
        my_input_ports = tbb::internal::make_unique<input_ports_type>(std::forward<T>(input_ports_tuple));
 
-#if TBB_PREVIEW_FLOW_GRAPH_TRACE
-      tbb::internal::fgt_internal_input_alias_helper<T, NUM_INPUTS>::alias_port( this, std::forward<T>(input_ports_tuple));
-#endif
+       tbb::internal::fgt_internal_input_alias_helper<T, NUM_INPUTS>::alias_port( this, std::forward<T>(input_ports_tuple));
    }
 
-#if TBB_PREVIEW_FLOW_GRAPH_TRACE
     template< typename... NodeTypes >
     void add_visible_nodes(const NodeTypes&... n) { internal::add_nodes_impl(this, true, n...); }
 
     template< typename... NodeTypes >
     void add_nodes( const NodeTypes&... n) { internal::add_nodes_impl(this, false, n...); }
-#else
-    template<typename... Nodes> void add_nodes(Nodes&...) {}
-    template<typename... Nodes> void add_visible_nodes(Nodes&...) {}
-#endif
 
 #if TBB_PREVIEW_FLOW_GRAPH_TRACE
     void set_name( const char *name ) __TBB_override {
@@ -3622,7 +4095,7 @@ class composite_node <tbb::flow::tuple<InputTypes...>, tbb::flow::tuple<> > : pu
          return *my_input_ports;
     }
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
     void extract() __TBB_override {
         __TBB_ASSERT(false, "Current composite_node implementation does not support extract");
     }
@@ -3637,9 +4110,6 @@ class composite_node <tbb::flow::tuple<>, tbb::flow::tuple<OutputTypes...> > : p
     typedef tbb::flow::tuple< sender<OutputTypes>&... > output_ports_type;
 
 private:
-#if TBB_PREVIEW_FLOW_GRAPH_TRACE
-    const char *my_type_name;
-#endif
     std::unique_ptr<output_ports_type> my_output_ports;
     static const size_t NUM_OUTPUTS = sizeof...(OutputTypes);
 
@@ -3648,12 +4118,14 @@ class composite_node <tbb::flow::tuple<>, tbb::flow::tuple<OutputTypes...> > : p
 
 public:
 #if TBB_PREVIEW_FLOW_GRAPH_TRACE
-    composite_node( graph &g, const char *type_name = "composite_node") : graph_node(g), my_type_name(type_name) {
-        tbb::internal::itt_make_task_group( tbb::internal::ITT_DOMAIN_FLOW, this, tbb::internal::FLOW_NODE, &g, tbb::internal::FLOW_GRAPH, tbb::internal::FLOW_COMPOSITE_NODE );
-        tbb::internal::fgt_multiinput_multioutput_node_desc( this, my_type_name );
+    __TBB_NOINLINE_SYM composite_node( graph &g, const char *type_name = "composite_node") : graph_node(g) {
+        tbb::internal::fgt_composite( CODEPTR(), this, &g );
+        tbb::internal::fgt_multiinput_multioutput_node_desc( this, type_name );
     }
 #else
-    composite_node( graph &g) : graph_node(g) {}
+    __TBB_NOINLINE_SYM composite_node( graph &g ) : graph_node(g) {
+        tbb::internal::fgt_composite( CODEPTR(), this, &g );
+    }
 #endif
 
    template<typename T>
@@ -3662,21 +4134,14 @@ class composite_node <tbb::flow::tuple<>, tbb::flow::tuple<OutputTypes...> > : p
 
        my_output_ports = tbb::internal::make_unique<output_ports_type>(std::forward<T>(output_ports_tuple));
 
-#if TBB_PREVIEW_FLOW_GRAPH_TRACE
-      tbb::internal::fgt_internal_output_alias_helper<T, NUM_OUTPUTS>::alias_port( this, std::forward<T>(output_ports_tuple));
-#endif
+       tbb::internal::fgt_internal_output_alias_helper<T, NUM_OUTPUTS>::alias_port( this, std::forward<T>(output_ports_tuple));
    }
 
-#if TBB_PREVIEW_FLOW_GRAPH_TRACE
     template<typename... NodeTypes >
     void add_visible_nodes(const NodeTypes&... n) { internal::add_nodes_impl(this, true, n...); }
 
     template<typename... NodeTypes >
-    void add_nodes(const NodeTypes&... n) { internal::add_nodes_impl(this, false, n...); }
-#else
-    template<typename... Nodes> void add_nodes(Nodes&...) {}
-    template<typename... Nodes> void add_visible_nodes(Nodes&...) {}
-#endif
+    void add_nodes(const NodeTypes&... n) { internal::add_nodes_impl(this, false, n...); }
 
 #if TBB_PREVIEW_FLOW_GRAPH_TRACE
     void set_name( const char *name ) __TBB_override {
@@ -3689,7 +4154,7 @@ class composite_node <tbb::flow::tuple<>, tbb::flow::tuple<OutputTypes...> > : p
          return *my_output_ports;
     }
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
     void extract() __TBB_override {
         __TBB_ASSERT(false, "Current composite_node implementation does not support extract");
     }
@@ -3721,7 +4186,7 @@ class async_body: public async_body_base<Gateway> {
     typedef async_body_base<Gateway> base_type;
     typedef Gateway gateway_type;
 
-    async_body(const Body &body, gateway_type *gateway) 
+    async_body(const Body &body, gateway_type *gateway)
         : base_type(gateway), my_body(body) { }
 
     void operator()( const Input &v, Ports & ) {
@@ -3734,13 +4199,27 @@ class async_body: public async_body_base<Gateway> {
     Body my_body;
 };
 
-}
+} // namespace internal
+
+} // namespace interfaceX
+namespace interface11 {
 
 //! Implements async node
-template < typename Input, typename Output, typename Policy = queueing, typename Allocator=cache_aligned_allocator<Input> >
-class async_node : public multifunction_node< Input, tuple< Output >, Policy, Allocator >, public sender< Output > {
+template < typename Input, typename Output,
+           typename Policy = queueing_lightweight,
+           typename Allocator=__TBB_DEFAULT_NODE_ALLOCATOR(Input) >
+class async_node
+    : public multifunction_node< Input, tuple< Output >, Policy, Allocator >, public sender< Output >
+{
+#if !TBB_DEPRECATED_FLOW_NODE_ALLOCATOR
+    __TBB_STATIC_ASSERT(
+        (tbb::internal::is_same_type<Allocator, null_type>::value),
+        "Allocator template parameter for flow graph nodes is deprecated and will removed in the future. "
+        "To temporary enable the deprecated interface specify TBB_ENABLE_DEPRECATED_NODE_ALLOCATOR."
+    );
+#endif
     typedef multifunction_node< Input, tuple< Output >, Policy, Allocator > base_type;
-    typedef typename internal::multifunction_input<Input, typename base_type::output_ports_type, Allocator> mfn_input_type;
+    typedef typename internal::multifunction_input<Input, typename base_type::output_ports_type, Policy, Allocator> mfn_input_type;
 
 public:
     typedef Input input_type;
@@ -3756,6 +4235,7 @@ class async_node : public multifunction_node< Input, tuple< Output >, Policy, Al
     struct try_put_functor {
         typedef internal::multifunction_output<Output> output_port_type;
         output_port_type *port;
+        // TODO: pass value by copy since we do not want to block asynchronous thread.
         const Output *value;
         bool result;
         try_put_functor(output_port_type &p, const Output &v) : port(&p), value(&v), result(false) { }
@@ -3792,27 +4272,67 @@ class async_node : public multifunction_node< Input, tuple< Output >, Policy, Al
     //! Implements gateway_type::try_put for an external activity to submit a message to FG
     bool try_put_impl(const Output &i) {
         internal::multifunction_output<Output> &port_0 = internal::output_port<0>(*this);
+        internal::broadcast_cache<output_type>& port_successors = port_0.successors();
         tbb::internal::fgt_async_try_put_begin(this, &port_0);
-        try_put_functor tpf(port_0, i);
-        internal::execute_in_graph_arena(this->my_graph, tpf);
+        task_list tasks;
+        bool is_at_least_one_put_successful = port_successors.gather_successful_try_puts(i, tasks);
+        __TBB_ASSERT( is_at_least_one_put_successful || tasks.empty(),
+                      "Return status is inconsistent with the method operation." );
+
+        while( !tasks.empty() ) {
+            internal::enqueue_in_graph_arena(this->my_graph, tasks.pop_front());
+        }
         tbb::internal::fgt_async_try_put_end(this, &port_0);
-        return tpf.result;
+        return is_at_least_one_put_successful;
     }
 
 public:
     template<typename Body>
-    async_node( graph &g, size_t concurrency, Body body ) :
-        base_type( g, concurrency, internal::async_body<Input, typename base_type::output_ports_type, gateway_type, Body>(body, &my_gateway) ), my_gateway(self()) {
-        tbb::internal::fgt_multioutput_node_with_body<1>( tbb::internal::FLOW_ASYNC_NODE,
-                &this->my_graph, static_cast<receiver<input_type> *>(this),
-                this->output_ports(), this->my_body );
-    }
-
-    async_node( const async_node &other ) : base_type(other), sender<Output>(), my_gateway(self()) {
+    __TBB_NOINLINE_SYM async_node(
+        graph &g, size_t concurrency,
+#if __TBB_CPP11_PRESENT
+        Body body, __TBB_FLOW_GRAPH_PRIORITY_ARG1(Policy = Policy(), node_priority_t priority = tbb::flow::internal::no_priority)
+#else
+        __TBB_FLOW_GRAPH_PRIORITY_ARG1(Body body, node_priority_t priority = tbb::flow::internal::no_priority)
+#endif
+    ) : base_type(
+        g, concurrency,
+        internal::async_body<Input, typename base_type::output_ports_type, gateway_type, Body>
+        (body, &my_gateway) __TBB_FLOW_GRAPH_PRIORITY_ARG0(priority) ), my_gateway(self()) {
+        tbb::internal::fgt_multioutput_node_with_body<1>(
+            CODEPTR(), tbb::internal::FLOW_ASYNC_NODE,
+            &this->my_graph, static_cast<receiver<input_type> *>(this),
+            this->output_ports(), this->my_body
+        );
+    }
+
+#if __TBB_PREVIEW_FLOW_GRAPH_PRIORITIES && __TBB_CPP11_PRESENT
+    template <typename Body, typename... Args>
+    __TBB_NOINLINE_SYM async_node(graph& g, size_t concurrency, Body body, node_priority_t priority)
+        : async_node(g, concurrency, body, Policy(), priority) {}
+#endif // __TBB_PREVIEW_FLOW_GRAPH_PRIORITIES
+
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+    template <typename Body, typename... Args>
+    __TBB_NOINLINE_SYM async_node(
+        const node_set<Args...>& nodes, size_t concurrency, Body body,
+        __TBB_FLOW_GRAPH_PRIORITY_ARG1(Policy = Policy(), node_priority_t priority = tbb::flow::internal::no_priority)
+    ) : async_node(nodes.graph_reference(), concurrency, __TBB_FLOW_GRAPH_PRIORITY_ARG1(body, priority)) {
+        make_edges_in_order(nodes, *this);
+    }
+
+#if __TBB_PREVIEW_FLOW_GRAPH_PRIORITIES
+    template <typename Body, typename... Args>
+    __TBB_NOINLINE_SYM async_node(const node_set<Args...>& nodes, size_t concurrency, Body body, node_priority_t priority)
+        : async_node(nodes, concurrency, body, Policy(), priority) {}
+#endif // __TBB_PREVIEW_FLOW_GRAPH_PRIORITIES
+#endif // __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+
+    __TBB_NOINLINE_SYM async_node( const async_node &other ) : base_type(other), sender<Output>(), my_gateway(self()) {
         static_cast<async_body_base_type*>(this->my_body->get_body_ptr())->set_gateway(&my_gateway);
         static_cast<async_body_base_type*>(this->my_init_body->get_body_ptr())->set_gateway(&my_gateway);
 
-        tbb::internal::fgt_multioutput_node_with_body<1>( tbb::internal::FLOW_ASYNC_NODE,
+        tbb::internal::fgt_multioutput_node_with_body<1>( CODEPTR(), tbb::internal::FLOW_ASYNC_NODE,
                 &this->my_graph, static_cast<receiver<input_type> *>(this),
                 this->output_ports(), this->my_body );
     }
@@ -3823,7 +4343,7 @@ class async_node : public multifunction_node< Input, tuple< Output >, Policy, Al
 
 #if TBB_PREVIEW_FLOW_GRAPH_TRACE
     void set_name( const char *name ) __TBB_override {
-            tbb::internal::fgt_multioutput_node_desc( this, name );
+        tbb::internal::fgt_multioutput_node_desc( this, name );
     }
 #endif
 
@@ -3848,7 +4368,7 @@ class async_node : public multifunction_node< Input, tuple< Output >, Policy, Al
         return ab.get_body();
     }
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
     //! interface to record edges for traversal & deletion
     typedef typename  internal::edge_container<successor_type> built_successors_type;
     typedef typename  built_successors_type::edge_list_type successor_list_type;
@@ -3871,7 +4391,7 @@ class async_node : public multifunction_node< Input, tuple< Output >, Policy, Al
     size_t  successor_count() __TBB_override {
         return internal::output_port<0>(*this).successor_count();
     }
-#endif
+#endif /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
 
 protected:
 
@@ -3884,58 +4404,340 @@ class async_node : public multifunction_node< Input, tuple< Output >, Policy, Al
 #include "internal/_flow_graph_streaming_node.h"
 #endif // __TBB_PREVIEW_STREAMING_NODE
 
+#include "internal/_flow_graph_node_set_impl.h"
+
+template< typename T >
+class overwrite_node : public graph_node, public receiver<T>, public sender<T> {
+public:
+    typedef T input_type;
+    typedef T output_type;
+    typedef typename receiver<input_type>::predecessor_type predecessor_type;
+    typedef typename sender<output_type>::successor_type successor_type;
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
+    typedef typename receiver<input_type>::built_predecessors_type built_predecessors_type;
+    typedef typename sender<output_type>::built_successors_type built_successors_type;
+    typedef typename receiver<input_type>::predecessor_list_type predecessor_list_type;
+    typedef typename sender<output_type>::successor_list_type successor_list_type;
+#endif
+
+    __TBB_NOINLINE_SYM explicit overwrite_node(graph &g) : graph_node(g), my_buffer_is_valid(false) {
+        my_successors.set_owner( this );
+        tbb::internal::fgt_node( CODEPTR(), tbb::internal::FLOW_OVERWRITE_NODE, &this->my_graph,
+                                 static_cast<receiver<input_type> *>(this), static_cast<sender<output_type> *>(this) );
+    }
+
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+    template <typename... Args>
+    overwrite_node(const node_set<Args...>& nodes) : overwrite_node(nodes.graph_reference()) {
+        make_edges_in_order(nodes, *this);
+    }
+#endif
+
+    //! Copy constructor; doesn't take anything from src; default won't work
+    __TBB_NOINLINE_SYM overwrite_node( const overwrite_node& src ) :
+        graph_node(src.my_graph), receiver<T>(), sender<T>(), my_buffer_is_valid(false)
+    {
+        my_successors.set_owner( this );
+        tbb::internal::fgt_node( CODEPTR(), tbb::internal::FLOW_OVERWRITE_NODE, &this->my_graph,
+                                 static_cast<receiver<input_type> *>(this), static_cast<sender<output_type> *>(this) );
+    }
+
+    ~overwrite_node() {}
+
+#if TBB_PREVIEW_FLOW_GRAPH_TRACE
+    void set_name( const char *name ) __TBB_override {
+        tbb::internal::fgt_node_desc( this, name );
+    }
+#endif
+
+   bool register_successor( successor_type &s ) __TBB_override {
+        spin_mutex::scoped_lock l( my_mutex );
+        if (my_buffer_is_valid && internal::is_graph_active( my_graph )) {
+            // We have a valid value that must be forwarded immediately.
+            bool ret = s.try_put( my_buffer );
+            if ( ret ) {
+                // We add the successor that accepted our put
+                my_successors.register_successor( s );
+            } else {
+                // In case of reservation a race between the moment of reservation and register_successor can appear,
+                // because failed reserve does not mean that register_successor is not ready to put a message immediately.
+                // We have some sort of infinite loop: reserving node tries to set pull state for the edge,
+                // but overwrite_node tries to return push state back. That is why we have to break this loop with task creation.
+                task *rtask = new ( task::allocate_additional_child_of( *( my_graph.root_task() ) ) )
+                    register_predecessor_task( *this, s );
+                internal::spawn_in_graph_arena( my_graph, *rtask );
+            }
+        } else {
+            // No valid value yet, just add as successor
+            my_successors.register_successor( s );
+        }
+        return true;
+    }
+
+    bool remove_successor( successor_type &s ) __TBB_override {
+        spin_mutex::scoped_lock l( my_mutex );
+        my_successors.remove_successor(s);
+        return true;
+    }
+
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
+    built_predecessors_type &built_predecessors() __TBB_override { return my_built_predecessors; }
+    built_successors_type   &built_successors()   __TBB_override { return my_successors.built_successors(); }
+
+    void internal_add_built_successor( successor_type &s) __TBB_override {
+        spin_mutex::scoped_lock l( my_mutex );
+        my_successors.internal_add_built_successor(s);
+    }
+
+    void internal_delete_built_successor( successor_type &s) __TBB_override {
+        spin_mutex::scoped_lock l( my_mutex );
+        my_successors.internal_delete_built_successor(s);
+    }
+
+    size_t successor_count() __TBB_override {
+        spin_mutex::scoped_lock l( my_mutex );
+        return my_successors.successor_count();
+    }
+
+    void copy_successors(successor_list_type &v) __TBB_override {
+        spin_mutex::scoped_lock l( my_mutex );
+        my_successors.copy_successors(v);
+    }
+
+    void internal_add_built_predecessor( predecessor_type &p) __TBB_override {
+        spin_mutex::scoped_lock l( my_mutex );
+        my_built_predecessors.add_edge(p);
+    }
+
+    void internal_delete_built_predecessor( predecessor_type &p) __TBB_override {
+        spin_mutex::scoped_lock l( my_mutex );
+        my_built_predecessors.delete_edge(p);
+    }
+
+    size_t predecessor_count() __TBB_override {
+        spin_mutex::scoped_lock l( my_mutex );
+        return my_built_predecessors.edge_count();
+    }
+
+    void copy_predecessors( predecessor_list_type &v ) __TBB_override {
+        spin_mutex::scoped_lock l( my_mutex );
+        my_built_predecessors.copy_edges(v);
+    }
+
+    void extract() __TBB_override {
+        my_buffer_is_valid = false;
+        built_successors().sender_extract(*this);
+        built_predecessors().receiver_extract(*this);
+    }
+
+#endif  /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
+
+    bool try_get( input_type &v ) __TBB_override {
+        spin_mutex::scoped_lock l( my_mutex );
+        if ( my_buffer_is_valid ) {
+            v = my_buffer;
+            return true;
+        }
+        return false;
+    }
+
+    //! Reserves an item
+    bool try_reserve( T &v ) __TBB_override {
+        return try_get(v);
+    }
+
+    //! Releases the reserved item
+    bool try_release() __TBB_override { return true; }
+
+    //! Consumes the reserved item
+    bool try_consume() __TBB_override { return true; }
+
+    bool is_valid() {
+       spin_mutex::scoped_lock l( my_mutex );
+       return my_buffer_is_valid;
+    }
+
+    void clear() {
+       spin_mutex::scoped_lock l( my_mutex );
+       my_buffer_is_valid = false;
+    }
+
+protected:
+
+    template< typename R, typename B > friend class run_and_put_task;
+    template<typename X, typename Y> friend class internal::broadcast_cache;
+    template<typename X, typename Y> friend class internal::round_robin_cache;
+    task * try_put_task( const input_type &v ) __TBB_override {
+        spin_mutex::scoped_lock l( my_mutex );
+        return try_put_task_impl(v);
+    }
+
+    task * try_put_task_impl(const input_type &v) {
+        my_buffer = v;
+        my_buffer_is_valid = true;
+        task * rtask = my_successors.try_put_task(v);
+        if (!rtask) rtask = SUCCESSFULLY_ENQUEUED;
+        return rtask;
+    }
+
+    graph& graph_reference() const __TBB_override {
+        return my_graph;
+    }
+
+    //! Breaks an infinite loop between the node reservation and register_successor call
+    struct register_predecessor_task : public graph_task {
+
+        register_predecessor_task(predecessor_type& owner, successor_type& succ) :
+            o(owner), s(succ) {};
+
+        tbb::task* execute() __TBB_override {
+            if (!s.register_predecessor(o)) {
+                o.register_successor(s);
+            }
+            return NULL;
+        }
+
+        predecessor_type& o;
+        successor_type& s;
+    };
+
+    spin_mutex my_mutex;
+    internal::broadcast_cache< input_type, null_rw_mutex > my_successors;
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
+    internal::edge_container<predecessor_type> my_built_predecessors;
+#endif
+    input_type my_buffer;
+    bool my_buffer_is_valid;
+    void reset_receiver(reset_flags /*f*/) __TBB_override {}
+
+    void reset_node( reset_flags f) __TBB_override {
+        my_buffer_is_valid = false;
+       if (f&rf_clear_edges) {
+           my_successors.clear();
+       }
+    }
+};  // overwrite_node
+
+template< typename T >
+class write_once_node : public overwrite_node<T> {
+public:
+    typedef T input_type;
+    typedef T output_type;
+    typedef overwrite_node<T> base_type;
+    typedef typename receiver<input_type>::predecessor_type predecessor_type;
+    typedef typename sender<output_type>::successor_type successor_type;
+
+    //! Constructor
+    __TBB_NOINLINE_SYM explicit write_once_node(graph& g) : base_type(g) {
+        tbb::internal::fgt_node( CODEPTR(), tbb::internal::FLOW_WRITE_ONCE_NODE, &(this->my_graph),
+                                 static_cast<receiver<input_type> *>(this),
+                                 static_cast<sender<output_type> *>(this) );
+    }
+
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+    template <typename... Args>
+    write_once_node(const node_set<Args...>& nodes) : write_once_node(nodes.graph_reference()) {
+        make_edges_in_order(nodes, *this);
+    }
+#endif
+
+    //! Copy constructor: call base class copy constructor
+    __TBB_NOINLINE_SYM write_once_node( const write_once_node& src ) : base_type(src) {
+        tbb::internal::fgt_node( CODEPTR(), tbb::internal::FLOW_WRITE_ONCE_NODE, &(this->my_graph),
+                                 static_cast<receiver<input_type> *>(this),
+                                 static_cast<sender<output_type> *>(this) );
+    }
+
+#if TBB_PREVIEW_FLOW_GRAPH_TRACE
+    void set_name( const char *name ) __TBB_override {
+        tbb::internal::fgt_node_desc( this, name );
+    }
+#endif
+
+protected:
+    template< typename R, typename B > friend class run_and_put_task;
+    template<typename X, typename Y> friend class internal::broadcast_cache;
+    template<typename X, typename Y> friend class internal::round_robin_cache;
+    task *try_put_task( const T &v ) __TBB_override {
+        spin_mutex::scoped_lock l( this->my_mutex );
+        return this->my_buffer_is_valid ? NULL : this->try_put_task_impl(v);
+    }
+};
+
 } // interfaceX
 
-    using interface10::reset_flags;
-    using interface10::rf_reset_protocol;
-    using interface10::rf_reset_bodies;
-    using interface10::rf_clear_edges;
-
-    using interface10::graph;
-    using interface10::graph_node;
-    using interface10::continue_msg;
-
-    using interface10::source_node;
-    using interface10::function_node;
-    using interface10::multifunction_node;
-    using interface10::split_node;
-    using interface10::internal::output_port;
-    using interface10::indexer_node;
-    using interface10::internal::tagged_msg;
-    using interface10::internal::cast_to;
-    using interface10::internal::is_a;
-    using interface10::continue_node;
-    using interface10::overwrite_node;
-    using interface10::write_once_node;
-    using interface10::broadcast_node;
-    using interface10::buffer_node;
-    using interface10::queue_node;
-    using interface10::sequencer_node;
-    using interface10::priority_queue_node;
-    using interface10::limiter_node;
-    using namespace interface10::internal::graph_policy_namespace;
-    using interface10::join_node;
-    using interface10::input_port;
-    using interface10::copy_body;
-    using interface10::make_edge;
-    using interface10::remove_edge;
-    using interface10::internal::tag_value;
+    using interface11::reset_flags;
+    using interface11::rf_reset_protocol;
+    using interface11::rf_reset_bodies;
+    using interface11::rf_clear_edges;
+
+    using interface11::graph;
+    using interface11::graph_node;
+    using interface11::continue_msg;
+    using interface11::source_node;
+    using interface11::input_node;
+    using interface11::function_node;
+    using interface11::multifunction_node;
+    using interface11::split_node;
+    using interface11::internal::output_port;
+    using interface11::indexer_node;
+    using interface11::internal::tagged_msg;
+    using interface11::internal::cast_to;
+    using interface11::internal::is_a;
+    using interface11::continue_node;
+    using interface11::overwrite_node;
+    using interface11::write_once_node;
+    using interface11::broadcast_node;
+    using interface11::buffer_node;
+    using interface11::queue_node;
+    using interface11::sequencer_node;
+    using interface11::priority_queue_node;
+    using interface11::limiter_node;
+    using namespace interface11::internal::graph_policy_namespace;
+    using interface11::join_node;
+    using interface11::input_port;
+    using interface11::copy_body;
+    using interface11::make_edge;
+    using interface11::remove_edge;
+    using interface11::internal::tag_value;
 #if __TBB_FLOW_GRAPH_CPP11_FEATURES
-    using interface10::composite_node;
+    using interface11::composite_node;
 #endif
-    using interface10::async_node;
+    using interface11::async_node;
 #if __TBB_PREVIEW_ASYNC_MSG
-    using interface10::async_msg;
+    using interface11::async_msg;
 #endif
 #if __TBB_PREVIEW_STREAMING_NODE
-    using interface10::port_ref;
-    using interface10::streaming_node;
+    using interface11::port_ref;
+    using interface11::streaming_node;
 #endif // __TBB_PREVIEW_STREAMING_NODE
+#if __TBB_PREVIEW_FLOW_GRAPH_PRIORITIES
+    using internal::node_priority_t;
+    using internal::no_priority;
+#endif
+
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+    using interface11::internal::follows;
+    using interface11::internal::precedes;
+    using interface11::internal::make_node_set;
+    using interface11::internal::make_edges;
+#endif
 
 } // flow
 } // tbb
 
+// Include deduction guides for node classes
+#include "internal/_flow_graph_nodes_deduction.h"
+
 #undef __TBB_PFG_RESET_ARG
 #undef __TBB_COMMA
+#undef __TBB_DEFAULT_NODE_ALLOCATOR
+
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_flow_graph_H_include_area
+
+#if TBB_USE_THREADING_TOOLS && TBB_PREVIEW_FLOW_GRAPH_TRACE && ( __linux__ || __APPLE__ )
+   #undef __TBB_NOINLINE_SYM
+#endif
 
 #endif // __TBB_flow_graph_H
diff --git a/src/tbb/include/tbb/flow_graph_abstractions.h b/src/tbb/include/tbb/flow_graph_abstractions.h
index 46971e03..f8ac239c 100644
--- a/src/tbb/include/tbb/flow_graph_abstractions.h
+++ b/src/tbb/include/tbb/flow_graph_abstractions.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_flow_graph_abstractions_H
@@ -23,7 +19,7 @@
 
 namespace tbb {
 namespace flow {
-namespace interface10 {
+namespace interface11 {
 
 //! Pure virtual template classes that define interfaces for async communication
 class graph_proxy {
@@ -49,8 +45,8 @@ class receiver_gateway : public graph_proxy {
 
 } //interfaceX
 
-using interface10::graph_proxy;
-using interface10::receiver_gateway;
+using interface11::graph_proxy;
+using interface11::receiver_gateway;
 
 } //flow
 } //tbb
diff --git a/src/tbb/include/tbb/flow_graph_opencl_node.h b/src/tbb/include/tbb/flow_graph_opencl_node.h
index e28abe78..e6670db6 100644
--- a/src/tbb/include/tbb/flow_graph_opencl_node.h
+++ b/src/tbb/include/tbb/flow_graph_opencl_node.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,15 +12,25 @@
     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 "internal/_deprecated_header_message_guard.h"
 
+#if !defined(__TBB_show_deprecation_message_flow_graph_opencl_node_H) && defined(__TBB_show_deprecated_header_message)
+#define  __TBB_show_deprecation_message_flow_graph_opencl_node_H
+#pragma message("TBB Warning: tbb/flow_graph_opencl_node.h is deprecated. For details, please see Deprecated Features appendix in the TBB reference manual.")
+#endif
 
-
-*/
+#if defined(__TBB_show_deprecated_header_message)
+#undef __TBB_show_deprecated_header_message
+#endif
 
 #ifndef __TBB_flow_graph_opencl_node_H
 #define __TBB_flow_graph_opencl_node_H
 
+#define __TBB_flow_graph_opencl_node_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #include "tbb/tbb_config.h"
 #if __TBB_PREVIEW_OPENCL_NODE
 
@@ -43,7 +53,7 @@
 namespace tbb {
 namespace flow {
 
-namespace interface10 {
+namespace interface11 {
 
 template <typename DeviceFilter>
 class opencl_factory;
@@ -106,7 +116,7 @@ inline std::string platform_info<std::string>(cl_platform_id p, cl_platform_info
 }
 
 
-class opencl_device {
+class __TBB_DEPRECATED_IN_VERBOSE_MODE opencl_device {
 public:
     typedef size_t device_id_type;
     enum : device_id_type {
@@ -121,19 +131,19 @@ class opencl_device {
     opencl_device( cl_device_id cl_d_id, device_id_type device_id ) : my_device_id( device_id ), my_cl_device_id( cl_d_id ), my_cl_command_queue( NULL ) {}
 
     std::string platform_profile() const {
-        return platform_info<std::string>( platform(), CL_PLATFORM_PROFILE );
+        return platform_info<std::string>( platform_id(), CL_PLATFORM_PROFILE );
     }
     std::string platform_version() const {
-        return platform_info<std::string>( platform(), CL_PLATFORM_VERSION );
+        return platform_info<std::string>( platform_id(), CL_PLATFORM_VERSION );
     }
     std::string platform_name() const {
-        return platform_info<std::string>( platform(), CL_PLATFORM_NAME );
+        return platform_info<std::string>( platform_id(), CL_PLATFORM_NAME );
     }
     std::string platform_vendor() const {
-        return platform_info<std::string>( platform(), CL_PLATFORM_VENDOR );
+        return platform_info<std::string>( platform_id(), CL_PLATFORM_VENDOR );
     }
     std::string platform_extensions() const {
-        return platform_info<std::string>( platform(), CL_PLATFORM_EXTENSIONS );
+        return platform_info<std::string>( platform_id(), CL_PLATFORM_EXTENSIONS );
     }
 
     template <typename T>
@@ -229,12 +239,12 @@ class opencl_device {
         my_cl_command_queue = cmd_queue;
     }
 
-private:
-
-    cl_platform_id platform() const {
+    cl_platform_id platform_id() const {
         return device_info<cl_platform_id>( my_cl_device_id, CL_DEVICE_PLATFORM );
     }
 
+private:
+
     device_id_type my_device_id;
     cl_device_id my_cl_device_id;
     cl_command_queue my_cl_command_queue;
@@ -254,7 +264,7 @@ class opencl_device {
 #endif
 };
 
-class opencl_device_list {
+class __TBB_DEPRECATED_IN_VERBOSE_MODE opencl_device_list {
     typedef std::vector<opencl_device> container_type;
 public:
     typedef container_type::iterator iterator;
@@ -352,7 +362,7 @@ class callback : public callback_base {
 };
 
 template <typename T, typename Factory = opencl_info::default_opencl_factory>
-class opencl_async_msg : public async_msg<T> {
+class __TBB_DEPRECATED_IN_VERBOSE_MODE opencl_async_msg : public async_msg<T> {
 public:
     typedef T value_type;
 
@@ -457,7 +467,7 @@ class opencl_async_msg : public async_msg<T> {
     operator const T&() const { return data(); }
 
 protected:
-    // Overridden in this derived class to inform that 
+    // Overridden in this derived class to inform that
     // async calculation chain is over
     void finalize() const __TBB_override {
         receive_if_memory_object(*this);
@@ -508,7 +518,7 @@ class opencl_memory {
         my_curr_device_id = my_factory->devices().begin()->my_device_id;
     }
 
-    ~opencl_memory() {
+    virtual ~opencl_memory() {
         if ( my_sending_event_present ) enforce_cl_retcode( clReleaseEvent( my_sending_event ), "Failed to release an event for the OpenCL buffer" );
         enforce_cl_retcode( clReleaseMemObject( my_cl_mem ), "Failed to release an memory object" );
     }
@@ -530,10 +540,10 @@ class opencl_memory {
 
     opencl_async_msg<void*, Factory> receive(const cl_event *e) {
         opencl_async_msg<void*, Factory> d;
-        if (e) { 
+        if (e) {
             d = opencl_async_msg<void*, Factory>(my_host_ptr, *e);
-        } else { 
-            d = opencl_async_msg<void*, Factory>(my_host_ptr); 
+        } else {
+            d = opencl_async_msg<void*, Factory>(my_host_ptr);
         }
 
         // Concurrent receives are prohibited so we do not worry about synchronization.
@@ -627,10 +637,12 @@ enum access_type {
 };
 
 template <typename T, typename Factory = opencl_info::default_opencl_factory>
-class opencl_subbuffer;
+class __TBB_DEPRECATED_IN_VERBOSE_MODE
+opencl_subbuffer;
 
 template <typename T, typename Factory = opencl_info::default_opencl_factory>
-class opencl_buffer {
+class __TBB_DEPRECATED_IN_VERBOSE_MODE
+opencl_buffer {
 public:
     typedef cl_mem native_object_type;
     typedef opencl_buffer memory_object_type;
@@ -704,7 +716,8 @@ class opencl_buffer {
 };
 
 template <typename T, typename Factory>
-class opencl_subbuffer : public opencl_buffer<T, Factory> {
+class __TBB_DEPRECATED_IN_VERBOSE_MODE
+opencl_subbuffer : public opencl_buffer<T, Factory> {
     opencl_buffer<T, Factory> my_owner;
 public:
     opencl_subbuffer() {}
@@ -780,7 +793,7 @@ typename std::enable_if<is_memory_object_type<T>::value>::type receive_if_memory
 template <typename T>
 typename std::enable_if<!is_memory_object_type<T>::value>::type  receive_if_memory_object( const T& ) {}
 
-class opencl_range {
+class __TBB_DEPRECATED_IN_VERBOSE_MODE opencl_range {
 public:
     typedef size_t range_index_type;
     typedef std::array<range_index_type, 3> nd_range_type;
@@ -790,7 +803,7 @@ class opencl_range {
     opencl_range(G&& global_work = std::initializer_list<int>({ 0 }), L&& local_work = std::initializer_list<int>({ 0, 0, 0 })) {
         auto g_it = global_work.begin();
         auto l_it = local_work.begin();
-        my_global_work_size = { size_t(-1), size_t(-1), size_t(-1) };
+        my_global_work_size = { {size_t(-1), size_t(-1), size_t(-1)} };
         // my_local_work_size is still uninitialized
         for (int s = 0; s < 3 && g_it != global_work.end(); ++g_it, ++l_it, ++s) {
             __TBB_ASSERT(l_it != local_work.end(), "global_work & local_work must have same size");
@@ -808,7 +821,7 @@ class opencl_range {
 };
 
 template <typename DeviceFilter>
-class opencl_factory {
+class __TBB_DEPRECATED_IN_VERBOSE_MODE opencl_factory {
 public:
     template<typename T> using async_msg_type = opencl_async_msg<T, opencl_factory<DeviceFilter>>;
     typedef opencl_device device_type;
@@ -1089,9 +1102,9 @@ class opencl_factory {
         }
 
         enforce_cl_retcode(my_devices.size() ? CL_SUCCESS : CL_INVALID_DEVICE, "No devices in the device list");
-        cl_platform_id platform_id = my_devices.begin()->platform();
+        cl_platform_id platform_id = my_devices.begin()->platform_id();
         for (opencl_device_list::iterator it = ++my_devices.begin(); it != my_devices.end(); ++it)
-            enforce_cl_retcode(it->platform() == platform_id ? CL_SUCCESS : CL_INVALID_PLATFORM, "All devices should be in the same platform");
+            enforce_cl_retcode(it->platform_id() == platform_id ? CL_SUCCESS : CL_INVALID_PLATFORM, "All devices should be in the same platform");
 
         std::vector<cl_device_id> cl_device_ids;
         for (auto d = my_devices.begin(); d != my_devices.end(); ++d) {
@@ -1128,7 +1141,7 @@ class opencl_factory {
                 // Suppress "declared deprecated" warning for the next line.
 #if __TBB_GCC_WARNING_SUPPRESSION_PRESENT
 #pragma GCC diagnostic push
-// #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
 #endif
 #if _MSC_VER || __INTEL_COMPILER
 #pragma warning( push )
@@ -1181,7 +1194,12 @@ struct default_device_selector {
 struct default_device_filter {
     opencl_device_list operator()(const opencl_device_list &devices) {
         opencl_device_list dl;
-        dl.add(*devices.begin());
+        cl_platform_id platform_id = devices.begin()->platform_id();
+        for (opencl_device_list::const_iterator it = devices.cbegin(); it != devices.cend(); ++it) {
+            if (it->platform_id() == platform_id) {
+                dl.add(*it);
+            }
+        }
         return dl;
     }
 };
@@ -1214,7 +1232,7 @@ enum class opencl_program_type {
 };
 
 template <typename Factory = opencl_info::default_opencl_factory>
-class opencl_program : tbb::internal::no_assign {
+class __TBB_DEPRECATED_IN_VERBOSE_MODE opencl_program : tbb::internal::no_assign {
 public:
     typedef typename Factory::kernel_type kernel_type;
 
@@ -1393,15 +1411,15 @@ class opencl_program : tbb::internal::no_assign {
     template <typename DeviceFilter>
     friend class opencl_factory;
 
-    template <typename DeviceFilter>
-    friend class opencl_factory<DeviceFilter>::kernel;
+    friend class Factory::kernel;
 };
 
 template<typename... Args>
-class opencl_node;
+class __TBB_DEPRECATED_IN_VERBOSE_MODE opencl_node;
 
 template<typename JP, typename Factory, typename... Ports>
-class opencl_node< tuple<Ports...>, JP, Factory > : public streaming_node< tuple<Ports...>, JP, Factory > {
+class __TBB_DEPRECATED_IN_VERBOSE_MODE
+opencl_node< tuple<Ports...>, JP, Factory > : public streaming_node< tuple<Ports...>, JP, Factory > {
     typedef streaming_node < tuple<Ports...>, JP, Factory > base_type;
 public:
     typedef typename base_type::kernel_type kernel_type;
@@ -1409,25 +1427,26 @@ class opencl_node< tuple<Ports...>, JP, Factory > : public streaming_node< tuple
     opencl_node( graph &g, const kernel_type& kernel )
         : base_type( g, kernel, opencl_info::default_device_selector< opencl_info::default_opencl_factory >(), opencl_info::default_factory() )
     {
-        tbb::internal::fgt_multiinput_multioutput_node( tbb::internal::FLOW_OPENCL_NODE, this, &this->my_graph );
+        tbb::internal::fgt_multiinput_multioutput_node( CODEPTR(), tbb::internal::FLOW_OPENCL_NODE, this, &this->my_graph );
     }
 
     opencl_node( graph &g, const kernel_type& kernel, Factory &f )
         : base_type( g, kernel, opencl_info::default_device_selector <Factory >(), f )
     {
-        tbb::internal::fgt_multiinput_multioutput_node( tbb::internal::FLOW_OPENCL_NODE, this, &this->my_graph );
+        tbb::internal::fgt_multiinput_multioutput_node( CODEPTR(), tbb::internal::FLOW_OPENCL_NODE, this, &this->my_graph );
     }
 
     template <typename DeviceSelector>
     opencl_node( graph &g, const kernel_type& kernel, DeviceSelector d, Factory &f)
         : base_type( g, kernel, d, f)
     {
-        tbb::internal::fgt_multiinput_multioutput_node( tbb::internal::FLOW_OPENCL_NODE, this, &this->my_graph );
+        tbb::internal::fgt_multiinput_multioutput_node( CODEPTR(), tbb::internal::FLOW_OPENCL_NODE, this, &this->my_graph );
     }
 };
 
 template<typename JP, typename... Ports>
-class opencl_node< tuple<Ports...>, JP > : public opencl_node < tuple<Ports...>, JP, opencl_info::default_opencl_factory > {
+class __TBB_DEPRECATED_IN_VERBOSE_MODE
+opencl_node< tuple<Ports...>, JP > : public opencl_node < tuple<Ports...>, JP, opencl_info::default_opencl_factory > {
     typedef opencl_node < tuple<Ports...>, JP, opencl_info::default_opencl_factory > base_type;
 public:
     typedef typename base_type::kernel_type kernel_type;
@@ -1443,7 +1462,8 @@ class opencl_node< tuple<Ports...>, JP > : public opencl_node < tuple<Ports...>,
 };
 
 template<typename... Ports>
-class opencl_node< tuple<Ports...> > : public opencl_node < tuple<Ports...>, queueing, opencl_info::default_opencl_factory > {
+class __TBB_DEPRECATED_IN_VERBOSE_MODE
+opencl_node< tuple<Ports...> > : public opencl_node < tuple<Ports...>, queueing, opencl_info::default_opencl_factory > {
     typedef opencl_node < tuple<Ports...>, queueing, opencl_info::default_opencl_factory > base_type;
 public:
     typedef typename base_type::kernel_type kernel_type;
@@ -1458,24 +1478,27 @@ class opencl_node< tuple<Ports...> > : public opencl_node < tuple<Ports...>, que
     {}
 };
 
-} // namespace interface10
-
-using interface10::opencl_node;
-using interface10::read_only;
-using interface10::read_write;
-using interface10::write_only;
-using interface10::opencl_buffer;
-using interface10::opencl_subbuffer;
-using interface10::opencl_device;
-using interface10::opencl_device_list;
-using interface10::opencl_program;
-using interface10::opencl_program_type;
-using interface10::opencl_async_msg;
-using interface10::opencl_factory;
-using interface10::opencl_range;
+} // namespace interfaceX
+
+using interface11::opencl_node;
+using interface11::read_only;
+using interface11::read_write;
+using interface11::write_only;
+using interface11::opencl_buffer;
+using interface11::opencl_subbuffer;
+using interface11::opencl_device;
+using interface11::opencl_device_list;
+using interface11::opencl_program;
+using interface11::opencl_program_type;
+using interface11::opencl_async_msg;
+using interface11::opencl_factory;
+using interface11::opencl_range;
 
 } // namespace flow
 } // namespace tbb
 #endif /* __TBB_PREVIEW_OPENCL_NODE */
 
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_flow_graph_opencl_node_H_include_area
+
 #endif // __TBB_flow_graph_opencl_node_H
diff --git a/src/tbb/include/tbb/gfx_factory.h b/src/tbb/include/tbb/gfx_factory.h
deleted file mode 100644
index 76ca3559..00000000
--- a/src/tbb/include/tbb/gfx_factory.h
+++ /dev/null
@@ -1,359 +0,0 @@
-/*
-    Copyright (c) 2005-2017 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.
-
-
-
-
-*/
-
-#ifndef __TBB_flow_graph_gfx_factory_H
-#define __TBB_flow_graph_gfx_factory_H
-
-#include "tbb/tbb_config.h"
-
-#if __TBB_PREVIEW_GFX_FACTORY
-
-#include <vector>
-#include <future>
-#include <mutex>
-#include <iostream>
-
-#include <gfx/gfx_rt.h>
-#include <gfx/gfx_intrin.h>
-#include <gfx/gfx_types.h>
-
-namespace tbb {
-
-namespace flow {
-
-namespace interface9 {
-
-template <typename T>
-class gfx_buffer;
-
-namespace gfx_offload {
-
-    typedef GfxTaskId task_id_type;
-
-    //-----------------------------------------------------------------------
-    // GFX errors checkers.
-    // For more debug output, set GFX_LOG_OFFLOAD=2 macro
-    //-----------------------------------------------------------------------
-
-    // TODO: reconsider error handling approach. If exception is the right way
-    // then need to define and document a specific exception type.
-    inline void throw_gfx_exception() {
-        std::string msg = "GFX error occurred: " + std::to_string(_GFX_get_last_error());
-        std::cerr << msg << std::endl;
-        throw msg;
-    }
-
-    inline void check_enqueue_retcode(task_id_type err) {
-        if (err == 0) {
-            throw_gfx_exception();
-        }
-    }
-
-    inline void check_gfx_retcode(task_id_type err) {
-        if (err != GFX_SUCCESS) {
-            throw_gfx_exception();
-        }
-    }
-
-    //---------------------------------------------------------------------
-    // GFX asynchronous offload and share API
-    //---------------------------------------------------------------------
-
-    // Sharing and unsharing data API
-    template<typename DataType, typename SizeType>
-    void share(DataType* p, SizeType n) { check_gfx_retcode(_GFX_share(p, sizeof(*p)*n)); }
-    template<typename DataType>
-    void unshare(DataType* p) { check_gfx_retcode(_GFX_unshare(p)); }
-
-    // Retrieving array pointer from shared gfx_buffer
-    // Other types remain the same
-    template <typename T>
-    T* raw_data(gfx_buffer<T>& buffer) { return buffer.data(); }
-    template <typename T>
-    const T* raw_data(const gfx_buffer<T>& buffer) { return buffer.data(); }
-    template <typename T>
-    T& raw_data(T& data) { return data; }
-    template <typename T>
-    const T& raw_data(const T& data) { return data; }
-
-    // Kernel enqueuing on device with arguments
-    template <typename F, typename ...ArgType>
-    task_id_type run_kernel(F ptr, ArgType&... args) {
-        task_id_type id = _GFX_offload(ptr, raw_data(args)...);
-
-        // Check if something during offload went wrong (ex: driver initialization failure)
-        gfx_offload::check_enqueue_retcode(id);
-
-        return id;
-    }
-
-    // Waiting for tasks completion
-    void wait_for_task(task_id_type id) { check_gfx_retcode(_GFX_wait(id)); }
-
-} // namespace gfx_offload
-
-template <typename T>
-class gfx_buffer {
-public:
-
-    typedef typename std::vector<T>::iterator iterator;
-    typedef typename std::vector<T>::const_iterator const_iterator;
-
-    typedef std::size_t size_type;
-
-    gfx_buffer() : my_vector_ptr(std::make_shared< std::vector<T> >()) {}
-    gfx_buffer(size_type size) : my_vector_ptr(std::make_shared< std::vector<T> >(size)) {}
-
-    T* data() { return &(my_vector_ptr->front()); }
-    const T* data() const { return &(my_vector_ptr->front()); }
-
-    size_type size() const { return my_vector_ptr->size(); }
-
-    const_iterator cbegin() const { return my_vector_ptr->cbegin(); }
-    const_iterator cend() const { return my_vector_ptr->cend(); }
-    iterator begin() { return my_vector_ptr->begin(); }
-    iterator end() { return my_vector_ptr->end(); }
-
-    T& operator[](size_type pos) { return (*my_vector_ptr)[pos]; }
-    const T& operator[](size_type pos) const { return (*my_vector_ptr)[pos]; }
-
-private:
-    std::shared_ptr< std::vector<T> > my_vector_ptr;
-};
-
-template<typename T>
-class gfx_async_msg : public tbb::flow::async_msg<T> {
-public:
-    typedef gfx_offload::task_id_type kernel_id_type;
-
-    gfx_async_msg() : my_task_id(0) {}
-    gfx_async_msg(const T& input_data) : my_data(input_data), my_task_id(0) {}
-
-    T& data() { return my_data; }
-    const T& data() const { return my_data; }
-
-    void set_task_id(kernel_id_type id) { my_task_id = id; }
-    kernel_id_type task_id() const { return my_task_id; }
-
-private:
-    T my_data;
-    kernel_id_type my_task_id;
-};
-
-class gfx_factory {
-private:
-
-    // Wrapper for GFX kernel which is just a function
-    class func_wrapper {
-    public:
-
-        template <typename F>
-        func_wrapper(F ptr) { my_ptr = reinterpret_cast<void*>(ptr); }
-
-        template<typename ...Args>
-        void operator()(Args&&... args) {}
-
-        operator void*() { return my_ptr; }
-
-    private:
-        void* my_ptr;
-    };
-
-public:
-
-    // Device specific types
-    template<typename T> using async_msg_type = gfx_async_msg<T>;
-
-    typedef func_wrapper kernel_type;
-
-    // Empty device type that is needed for Factory Concept
-    // but is not used in gfx_factory
-    typedef struct {} device_type;
-
-    typedef gfx_offload::task_id_type kernel_id_type;
-
-    gfx_factory(tbb::flow::graph& g) : m_graph(g), current_task_id(0) {}
-
-    // Upload data to the device
-    template <typename ...Args>
-    void send_data(device_type /*device*/, Args&... args) {
-        send_data_impl(args...);
-    }
-
-    // Run kernel on the device
-    template <typename ...Args>
-    void send_kernel(device_type /*device*/, const kernel_type& kernel, Args&... args) {
-        // Get packed T data from async_msg<T> and pass it to kernel
-        kernel_id_type id = gfx_offload::run_kernel(kernel, args.data()...);
-
-        // Set id to async_msg
-        set_kernel_id(id, args...);
-
-        // Extend the graph lifetime until the callback completion.
-        m_graph.reserve_wait();
-
-        // Mutex for future assignment
-        std::lock_guard<std::mutex> lock(future_assignment_mutex);
-
-        // Set callback that waits for kernel execution
-        callback_future = std::async(std::launch::async, &gfx_factory::callback<Args...>, this, id, args...);
-    }
-
-    // Finalization action after the kernel run
-    template <typename FinalizeFn, typename ...Args>
-    void finalize(device_type /*device*/, FinalizeFn fn, Args&... /*args*/) {
-        fn();
-    }
-
-    // Empty device selector.
-    // No way to choose a device with GFX API.
-    class dummy_device_selector {
-    public:
-        device_type operator()(gfx_factory& /*factory*/) {
-            return device_type();
-        }
-    };
-
-private:
-
-    //---------------------------------------------------------------------
-    // Callback for kernel result
-    //---------------------------------------------------------------------
-
-    template <typename ...Args>
-    void callback(kernel_id_type id, Args... args) {
-        // Waiting for specific tasks id to complete
-        {
-            std::lock_guard<std::mutex> lock(task_wait_mutex);
-            if (current_task_id < id) {
-                gfx_offload::wait_for_task(id);
-                current_task_id = id;
-            }
-        }
-
-        // Get result from device and set to async_msg (args)
-        receive_data(args...);
-
-        // Data was sent to the graph, release the reference
-        m_graph.release_wait();
-    }
-
-    //---------------------------------------------------------------------
-    // send_data() arguments processing
-    //---------------------------------------------------------------------
-
-    // GFX buffer shared data with device that will be executed on
-    template <typename T>
-    void share_data(T) {}
-
-    template <typename T>
-    void share_data(gfx_buffer<T>& buffer) {
-        gfx_offload::share(buffer.data(), buffer.size());
-    }
-
-    template <typename T>
-    void send_arg(T) {}
-
-    template <typename T>
-    void send_arg(async_msg_type<T>& msg) {
-        share_data(msg.data());
-    }
-
-    void send_data_impl() {}
-
-    template <typename T, typename ...Rest>
-    void send_data_impl(T& arg, Rest&... args) {
-        send_arg(arg);
-        send_data_impl(args...);
-    }
-
-    //----------------------------------------------------------------------
-    // send_kernel() arguments processing
-    //----------------------------------------------------------------------
-
-    template <typename T>
-    void set_kernel_id_arg(kernel_id_type, T) {}
-
-    template <typename T>
-    void set_kernel_id_arg(kernel_id_type id, async_msg_type<T>& msg) {
-        msg.set_task_id(id);
-    }
-
-    void set_kernel_id(kernel_id_type) {}
-
-    template <typename T, typename ...Rest>
-    void set_kernel_id(kernel_id_type id, T& arg, Rest&... args) {
-        set_kernel_id_arg(id, arg);
-        set_kernel_id(id, args...);
-    }
-
-    //-----------------------------------------------------------------------
-    // Arguments processing after kernel execution.
-    // Unsharing buffers and forwarding results to the graph
-    //-----------------------------------------------------------------------
-
-    // After kernel execution the data should be unshared
-    template <typename T>
-    void unshare_data(T) {}
-
-    template <typename T>
-    void unshare_data(gfx_buffer<T>& buffer) {
-        gfx_offload::unshare(buffer.data());
-    }
-
-    template <typename T>
-    void receive_arg(T) {}
-
-    template <typename T>
-    void receive_arg(async_msg_type<T>& msg) {
-        unshare_data(msg.data());
-        msg.set(msg.data());
-    }
-
-    void receive_data() {}
-
-    template <typename T, typename ...Rest>
-    void receive_data(T& arg, Rest&... args) {
-        receive_arg(arg);
-        receive_data(args...);
-    }
-
-    //-----------------------------------------------------------------------
-    int current_task_id;
-
-    std::future<void> callback_future;
-    tbb::flow::graph& m_graph;
-
-    std::mutex future_assignment_mutex;
-    std::mutex task_wait_mutex;
-};
-
-} // namespace interface9
-
-using interface9::gfx_factory;
-using interface9::gfx_buffer;
-
-} // namespace flow
-
-} // namespace tbb
-
-#endif // __TBB_PREVIEW_GFX_FACTORY
-
-#endif // __TBB_flow_graph_gfx_factory_H
diff --git a/src/tbb/include/tbb/global_control.h b/src/tbb/include/tbb/global_control.h
index fe742020..bdcd59a5 100644
--- a/src/tbb/include/tbb/global_control.h
+++ b/src/tbb/include/tbb/global_control.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,19 +12,11 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_global_control_H
 #define __TBB_global_control_H
 
-#if !TBB_PREVIEW_GLOBAL_CONTROL && !__TBB_BUILD
-#error Set TBB_PREVIEW_GLOBAL_CONTROL before including global_control.h
-#endif
-
 #include "tbb_stddef.h"
 
 namespace tbb {
@@ -41,8 +33,8 @@ class global_control {
     global_control(parameter p, size_t value) :
         my_value(value), my_next(NULL), my_param(p) {
         __TBB_ASSERT(my_param < parameter_max, "Invalid parameter");
-#if __TBB_WIN8UI_SUPPORT
-        // For Windows Store* apps it's impossible to set stack size
+#if __TBB_WIN8UI_SUPPORT && (_WIN32_WINNT < 0x0A00)
+        // For Windows 8 Store* apps it's impossible to set stack size
         if (p==thread_stack_size)
             return;
 #elif __TBB_x86_64 && (_WIN32 || _WIN64)
@@ -56,8 +48,8 @@ class global_control {
 
     ~global_control() {
         __TBB_ASSERT(my_param < parameter_max, "Invalid parameter. Probably the object was corrupted.");
-#if __TBB_WIN8UI_SUPPORT
-        // For Windows Store* apps it's impossible to set stack size
+#if __TBB_WIN8UI_SUPPORT && (_WIN32_WINNT < 0x0A00)
+        // For Windows 8 Store* apps it's impossible to set stack size
         if (my_param==thread_stack_size)
             return;
 #endif
diff --git a/src/tbb/include/tbb/index.html b/src/tbb/include/tbb/index.html
index 2eddd450..9ead0e24 100644
--- a/src/tbb/include/tbb/index.html
+++ b/src/tbb/include/tbb/index.html
@@ -19,7 +19,7 @@ <H2>Directories</H2>
 <HR>
 <A HREF="../index.html">Up to parent directory</A>
 <p></p>
-Copyright &copy; 2005-2017 Intel Corporation.  All Rights Reserved.
+Copyright &copy; 2005-2020 Intel Corporation.  All Rights Reserved.
 <P></P>
 Intel is a registered trademark or trademark of Intel Corporation
 or its subsidiaries in the United States and other countries.
diff --git a/src/tbb/include/tbb/info.h b/src/tbb/include/tbb/info.h
new file mode 100644
index 00000000..84b32092
--- /dev/null
+++ b/src/tbb/include/tbb/info.h
@@ -0,0 +1,52 @@
+/*
+    Copyright (c) 2019-2020 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.
+*/
+
+#ifndef __TBB_info_H
+#define __TBB_info_H
+
+#include "tbb_config.h"
+
+#if __TBB_NUMA_SUPPORT
+
+#include <vector>
+
+namespace tbb {
+    namespace internal {
+        namespace numa_topology {
+            unsigned nodes_count();
+            void fill(int* indexes_array);
+            int default_concurrency(int node_id);
+        } //namespace numa_topology
+    } // namespace internal
+
+    typedef int numa_node_id;
+
+    namespace info {
+        inline std::vector<numa_node_id> numa_nodes() {
+            std::vector<numa_node_id> nodes_indexes(tbb::internal::numa_topology::nodes_count());
+            internal::numa_topology::fill(&nodes_indexes.front());
+            return nodes_indexes;
+        }
+
+        inline int default_concurrency(numa_node_id id = -1) {
+            return internal::numa_topology::default_concurrency(id);
+        }
+    } // namespace info
+} // namespace tbb
+
+#endif /*__TBB_NUMA_SUPPORT*/
+
+#endif /*__TBB_info_H*/
diff --git a/src/tbb/include/tbb/internal/_aggregator_impl.h b/src/tbb/include/tbb/internal/_aggregator_impl.h
index 40bbd491..6d89c055 100644
--- a/src/tbb/include/tbb/internal/_aggregator_impl.h
+++ b/src/tbb/include/tbb/internal/_aggregator_impl.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB__aggregator_impl_H
@@ -164,7 +160,7 @@ template<typename aggregating_class, typename operation_list>
 class aggregating_functor {
     aggregating_class *fi;
 public:
-    aggregating_functor() {}
+    aggregating_functor() : fi() {}
     aggregating_functor(aggregating_class *fi_) : fi(fi_) {}
     void operator()(operation_list* op_list) { fi->handle_operations(op_list); }
 };
diff --git a/src/tbb/include/tbb/internal/_allocator_traits.h b/src/tbb/include/tbb/internal/_allocator_traits.h
new file mode 100644
index 00000000..eba986b7
--- /dev/null
+++ b/src/tbb/include/tbb/internal/_allocator_traits.h
@@ -0,0 +1,156 @@
+/*
+    Copyright (c) 2019-2020 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.
+*/
+
+#ifndef __TBB_allocator_traits_H
+#define __TBB_allocator_traits_H
+
+#include "../tbb_stddef.h" // true/false_type
+
+#if __TBB_ALLOCATOR_TRAITS_PRESENT
+#include <memory> // for allocator_traits
+#endif
+
+#if __TBB_CPP11_RVALUE_REF_PRESENT
+#include <utility> // for std::move
+#endif
+
+// For allocator_swap helper
+#include __TBB_STD_SWAP_HEADER
+
+namespace tbb {
+namespace internal {
+
+//! Internal implementation of allocator traits, propagate_on_* use internal boolean_constant.
+//! In order to avoid code duplication, check what implementation of boolean constant will likely be passed.
+#if __TBB_ALLOCATOR_TRAITS_PRESENT
+typedef std::true_type traits_true_type;
+typedef std::false_type traits_false_type;
+#else
+typedef tbb::internal::true_type traits_true_type;
+typedef tbb::internal::false_type traits_false_type;
+#endif
+
+//! Copy assignment implementation for allocator if propagate_on_container_copy_assignment == true_type
+//! Noop if pocca == false_type
+template <typename MyAlloc, typename OtherAlloc>
+inline void allocator_copy_assignment(MyAlloc& my_allocator, OtherAlloc& other_allocator, traits_true_type) {
+    my_allocator = other_allocator;
+}
+template <typename MyAlloc, typename OtherAlloc>
+inline void allocator_copy_assignment(MyAlloc&, OtherAlloc&, traits_false_type) { /* NO COPY */}
+
+#if __TBB_CPP11_RVALUE_REF_PRESENT
+//! Move assignment implementation for allocator if propagate_on_container_move_assignment == true_type.
+//! Noop if pocma == false_type.
+template <typename MyAlloc, typename OtherAlloc>
+inline void allocator_move_assignment(MyAlloc& my_allocator, OtherAlloc& other_allocator, traits_true_type) {
+    my_allocator = std::move(other_allocator);
+}
+template <typename MyAlloc, typename OtherAlloc>
+inline void allocator_move_assignment(MyAlloc&, OtherAlloc&, traits_false_type) { /* NO MOVE */ }
+#endif
+
+//! Swap implementation for allocators if propagate_on_container_swap == true_type.
+//! Noop if pocs == false_type.
+template <typename MyAlloc, typename OtherAlloc>
+inline void allocator_swap(MyAlloc& my_allocator, OtherAlloc& other_allocator, traits_true_type) {
+    using std::swap;
+    swap(my_allocator, other_allocator);
+}
+template <typename MyAlloc, typename OtherAlloc>
+inline void allocator_swap(MyAlloc&, OtherAlloc&, traits_false_type) { /* NO SWAP */ }
+
+#if __TBB_ALLOCATOR_TRAITS_PRESENT
+using std::allocator_traits;
+#else
+//! Internal allocator_traits implementation, which relies on C++03 standard
+//! [20.1.5] allocator requirements
+template<typename Alloc>
+struct allocator_traits {
+    // C++03 allocator doesn't have to be assignable or swappable, therefore
+    // define these traits as false_type to do not require additional operations
+    // that are not supposed to be in.
+    typedef tbb::internal::false_type propagate_on_container_move_assignment;
+    typedef tbb::internal::false_type propagate_on_container_copy_assignment;
+    typedef tbb::internal::false_type propagate_on_container_swap;
+
+    typedef Alloc allocator_type;
+    typedef typename allocator_type::value_type value_type;
+
+    typedef typename allocator_type::pointer pointer;
+    typedef typename allocator_type::const_pointer const_pointer;
+    typedef typename allocator_type::difference_type difference_type;
+    typedef typename allocator_type::size_type size_type;
+
+    template <typename U> struct rebind_alloc {
+        typedef typename Alloc::template rebind<U>::other other;
+    };
+
+    static pointer allocate(Alloc& a, size_type n) {
+        return a.allocate(n);
+    }
+
+    static void deallocate(Alloc& a, pointer p, size_type n) {
+        a.deallocate(p, n);
+    }
+
+    template<typename PT>
+    static void construct(Alloc&, PT* p) {
+        ::new (static_cast<void*>(p)) PT();
+    }
+
+    template<typename PT, typename T1>
+    static void construct(Alloc&, PT* p, __TBB_FORWARDING_REF(T1) t1) {
+        ::new (static_cast<void*>(p)) PT(tbb::internal::forward<T1>(t1));
+    }
+
+    template<typename PT, typename T1, typename T2>
+    static void construct(Alloc&, PT* p, __TBB_FORWARDING_REF(T1) t1, __TBB_FORWARDING_REF(T2) t2) {
+        ::new (static_cast<void*>(p)) PT(tbb::internal::forward<T1>(t1), tbb::internal::forward<T2>(t2));
+    }
+
+    template<typename PT, typename T1, typename T2, typename T3>
+    static void construct(Alloc&, PT* p, __TBB_FORWARDING_REF(T1) t1,
+                          __TBB_FORWARDING_REF(T2) t2, __TBB_FORWARDING_REF(T3) t3) {
+        ::new (static_cast<void*>(p)) PT(tbb::internal::forward<T1>(t1), tbb::internal::forward<T2>(t2),
+                                         tbb::internal::forward<T3>(t3));
+    }
+
+    template<typename T>
+    static void destroy(Alloc&, T* p) {
+        p->~T();
+        tbb::internal::suppress_unused_warning(p);
+    }
+
+    static Alloc select_on_container_copy_construction(const Alloc& a) { return a; }
+};
+#endif // __TBB_ALLOCATOR_TRAITS_PRESENT
+
+//! C++03/C++11 compliant rebind helper, even if no std::allocator_traits available
+//! or rebind is not defined for allocator type
+template<typename Alloc, typename T>
+struct allocator_rebind {
+#if __TBB_ALLOCATOR_TRAITS_PRESENT
+    typedef typename allocator_traits<Alloc>::template rebind_alloc<T> type;
+#else
+    typedef typename allocator_traits<Alloc>::template rebind_alloc<T>::other type;
+#endif
+};
+
+}} // namespace tbb::internal
+
+#endif // __TBB_allocator_traits_H
+
diff --git a/src/tbb/include/tbb/internal/_concurrent_queue_impl.h b/src/tbb/include/tbb/internal/_concurrent_queue_impl.h
index 29e27426..e3bef772 100644
--- a/src/tbb/include/tbb/internal/_concurrent_queue_impl.h
+++ b/src/tbb/include/tbb/internal/_concurrent_queue_impl.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB__concurrent_queue_impl_H
@@ -514,7 +510,7 @@ concurrent_queue_base_v3<T>::concurrent_queue_base_v3() {
     __TBB_ASSERT( (size_t)&my_rep->head_counter % NFS_GetLineSize()==0, "alignment error" );
     __TBB_ASSERT( (size_t)&my_rep->tail_counter % NFS_GetLineSize()==0, "alignment error" );
     __TBB_ASSERT( (size_t)&my_rep->array % NFS_GetLineSize()==0, "alignment error" );
-    memset(my_rep,0,sizeof(concurrent_queue_rep<T>));
+    memset(static_cast<void*>(my_rep),0,sizeof(concurrent_queue_rep<T>));
     my_rep->item_size = item_size;
     my_rep->items_per_page = item_size<=  8 ? 32 :
                              item_size<= 16 ? 16 :
@@ -647,7 +643,7 @@ bool concurrent_queue_iterator_rep<T>::get_item( T*& item, size_t k ) {
 //! Constness-independent portion of concurrent_queue_iterator.
 /** @ingroup containers */
 template<typename Value>
-class concurrent_queue_iterator_base_v3 : no_assign {
+class concurrent_queue_iterator_base_v3 {
     //! Represents concurrent_queue over which we are iterating.
     /** NULL if one past last element in queue. */
     concurrent_queue_iterator_rep<Value>* my_rep;
@@ -670,10 +666,15 @@ class concurrent_queue_iterator_base_v3 : no_assign {
 
     //! Copy constructor
     concurrent_queue_iterator_base_v3( const concurrent_queue_iterator_base_v3& i )
-    : no_assign(), my_rep(NULL), my_item(NULL) {
+    : my_rep(NULL), my_item(NULL) {
         assign(i);
     }
 
+    concurrent_queue_iterator_base_v3& operator=( const concurrent_queue_iterator_base_v3& i ) {
+        assign(i);
+        return *this;
+    }
+
     //! Construct iterator pointing to head of queue.
     concurrent_queue_iterator_base_v3( const concurrent_queue_base_v3<Value>& queue ) ;
 
@@ -768,8 +769,8 @@ class concurrent_queue_iterator: public concurrent_queue_iterator_base_v3<typena
     {}
 
     //! Iterator assignment
-    concurrent_queue_iterator& operator=( const concurrent_queue_iterator& other ) {
-        this->assign(other);
+    concurrent_queue_iterator& operator=( const concurrent_queue_iterator<Container,typename Container::value_type>& other ) {
+        concurrent_queue_iterator_base_v3<typename tbb_remove_cv<Value>::type>::operator=(other);
         return *this;
     }
 
@@ -889,7 +890,7 @@ class concurrent_queue_base_v3: no_copy {
     //! Get size of queue
     ptrdiff_t __TBB_EXPORTED_METHOD internal_size() const;
 
-    //! Check if the queue is emtpy
+    //! Check if the queue is empty
     bool __TBB_EXPORTED_METHOD internal_empty() const;
 
     //! Set the queue capacity
@@ -980,6 +981,11 @@ class concurrent_queue_iterator_base_v3 {
         assign(i);
     }
 
+    concurrent_queue_iterator_base_v3& operator=( const concurrent_queue_iterator_base_v3& i ) {
+        assign(i);
+        return *this;
+    }
+
     //! Obsolete entry point for constructing iterator pointing to head of queue.
     /** Does not work correctly for SSE types. */
     __TBB_EXPORTED_METHOD concurrent_queue_iterator_base_v3( const concurrent_queue_base_v3& queue );
@@ -1029,8 +1035,8 @@ class concurrent_queue_iterator: public concurrent_queue_iterator_base,
     {}
 
     //! Iterator assignment
-    concurrent_queue_iterator& operator=( const concurrent_queue_iterator& other ) {
-        assign(other);
+    concurrent_queue_iterator& operator=( const concurrent_queue_iterator<Container,typename Container::value_type>& other ) {
+        concurrent_queue_iterator_base_v3::operator=(other);
         return *this;
     }
 
diff --git a/src/tbb/include/tbb/internal/_concurrent_skip_list_impl.h b/src/tbb/include/tbb/internal/_concurrent_skip_list_impl.h
new file mode 100644
index 00000000..8cc1a11d
--- /dev/null
+++ b/src/tbb/include/tbb/internal/_concurrent_skip_list_impl.h
@@ -0,0 +1,1085 @@
+/*
+    Copyright (c) 2019-2020 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.
+*/
+
+#ifndef __TBB_concurrent_skip_list_H
+#define __TBB_concurrent_skip_list_H
+
+#if !defined(__TBB_concurrent_map_H) && !defined(__TBB_concurrent_set_H)
+#error Do not #include this internal file directly; use public TBB headers instead.
+#endif
+
+#include "../tbb_config.h"
+#include "../tbb_stddef.h"
+#include "../tbb_allocator.h"
+#include "../spin_mutex.h"
+#include "../tbb_exception.h"
+#include "../enumerable_thread_specific.h"
+#include "_allocator_traits.h"
+#include "_template_helpers.h"
+#include "_node_handle_impl.h"
+#include <utility> // Need std::pair
+#include <functional>
+#include <initializer_list>
+#include <memory> // Need std::allocator_traits
+#include <atomic>
+#include <mutex>
+#include <vector>
+#include <array>
+#include <type_traits>
+#include <cstdlib>
+#include <random>
+#include <tuple>
+
+#if _MSC_VER
+#pragma warning(disable: 4189) // warning 4189 -- local variable is initialized but not referenced
+#pragma warning(disable: 4127) // warning 4127 -- while (true) has a constant expression in it
+#endif
+
+namespace tbb {
+namespace interface10 {
+namespace internal {
+
+template <typename Value, typename Mutex>
+class skip_list_node {
+
+public:
+    using value_type = Value;
+    using size_type = std::size_t;
+    using reference = value_type & ;
+    using const_reference = const value_type & ;
+    using pointer = value_type * ;
+    using const_pointer = const value_type *;
+    using node_pointer = skip_list_node * ;
+    using atomic_node_pointer = std::atomic<node_pointer>;
+
+    using mutex_type = Mutex;
+    using lock_type = std::unique_lock<mutex_type>;
+
+    skip_list_node(size_type levels) : my_height(levels), my_fullyLinked(false) {
+        for (size_type lev = 0; lev < my_height; ++lev)
+            new(&my_next(lev)) atomic_node_pointer(nullptr);
+        __TBB_ASSERT(height() == levels, "Wrong node height");
+    }
+
+    ~skip_list_node() {
+        for(size_type lev = 0; lev < my_height; ++lev)
+            my_next(lev).~atomic();
+    }
+
+    skip_list_node(const skip_list_node&) = delete;
+
+    skip_list_node(skip_list_node&&) = delete;
+
+    skip_list_node& operator=(const skip_list_node&) = delete;
+
+    pointer storage() {
+        return reinterpret_cast<pointer>(&my_val);
+    }
+
+    reference value() {
+        return *storage();
+    }
+
+    node_pointer next(size_type level) const {
+        __TBB_ASSERT(level < height(), "Cannot get next on the level greater than height");
+        return my_next(level).load(std::memory_order_acquire);
+    }
+
+    void set_next(size_type level, node_pointer next) {
+        __TBB_ASSERT(level < height(), "Cannot set next on the level greater than height");
+
+        my_next(level).store(next, std::memory_order_release);
+    }
+
+    /** @return number of layers */
+    size_type height() const {
+        return my_height;
+    }
+
+    bool fully_linked() const {
+        return my_fullyLinked.load(std::memory_order_acquire);
+    }
+
+    void mark_linked() {
+        my_fullyLinked.store(true, std::memory_order_release);
+    }
+
+    lock_type acquire() {
+        return lock_type(my_mutex);
+    }
+
+private:
+    using aligned_storage_type = typename std::aligned_storage<sizeof(value_type), alignof(value_type)>::type;
+
+    atomic_node_pointer& my_next(size_type level) {
+        atomic_node_pointer* arr = reinterpret_cast<atomic_node_pointer*>(this + 1);
+        return arr[level];
+    }
+
+    const atomic_node_pointer& my_next(size_type level) const {
+        const atomic_node_pointer* arr = reinterpret_cast<const atomic_node_pointer*>(this + 1);
+        return arr[level];
+    }
+
+    mutex_type my_mutex;
+    aligned_storage_type my_val;
+    size_type my_height;
+    std::atomic_bool my_fullyLinked;
+};
+
+template <typename NodeType, bool is_const>
+class skip_list_iterator {
+    using node_type = NodeType;
+    using node_ptr = node_type*;
+public:
+    using iterator_category = std::forward_iterator_tag;
+    using value_type = typename node_type::value_type;
+    using difference_type = std::ptrdiff_t;
+    using pointer = typename std::conditional<is_const, typename node_type::const_pointer,
+                                                        typename node_type::pointer>::type;
+    using reference = typename std::conditional<is_const, typename node_type::const_reference,
+                                                          typename node_type::reference>::type;
+
+    skip_list_iterator() : my_node_ptr(nullptr) {}
+
+    // TODO: the code above does not compile in VS2015 (seems like a bug) - consider enabling it for all other platforms
+    // template <typename T = void, typename = typename std::enable_if<is_const, T>::type>
+    // skip_list_iterator(const skip_list_iterator<node_type, false>& other) : my_node_ptr(other.my_node_ptr) {}
+
+    // skip_list_iterator(const skip_list_iterator& other) : my_node_ptr(other.my_node_ptr) {}
+
+    skip_list_iterator(const skip_list_iterator<node_type, false>& other) : my_node_ptr(other.my_node_ptr) {}
+
+    skip_list_iterator& operator=(const skip_list_iterator<node_type, false>& other) {
+         my_node_ptr = other.my_node_ptr;
+         return *this;
+    }
+
+    template <typename T = void, typename = typename std::enable_if<is_const, T>::type>
+    skip_list_iterator(const skip_list_iterator<node_type, true>& other) : my_node_ptr(other.my_node_ptr) {}
+
+    reference operator*() const { return *(my_node_ptr->storage()); }
+    pointer operator->() const { return &**this; }
+
+    skip_list_iterator& operator++() {
+        __TBB_ASSERT(my_node_ptr != nullptr, NULL);
+        my_node_ptr = my_node_ptr->next(0);
+        return *this;
+    }
+
+    skip_list_iterator operator++(int) {
+        skip_list_iterator tmp = *this;
+        ++*this;
+        return tmp;
+    }
+
+private:
+    skip_list_iterator(node_type* n) : my_node_ptr(n) {}
+
+    node_ptr my_node_ptr;
+
+    template <typename Traits>
+    friend class concurrent_skip_list;
+
+    friend class skip_list_iterator<NodeType, true>;
+
+    friend class const_range;
+    friend class range;
+
+    template <typename T, bool M, bool U>
+    friend bool operator==(const skip_list_iterator<T, M>&, const skip_list_iterator<T, U>&);
+
+    template <typename T, bool M, bool U>
+    friend bool operator!=(const skip_list_iterator<T, M>&, const skip_list_iterator<T, U>&);
+};
+
+template <typename NodeType, bool is_const1, bool is_const2>
+bool operator==(const skip_list_iterator<NodeType, is_const1>& lhs, const skip_list_iterator<NodeType, is_const2>& rhs) {
+    return lhs.my_node_ptr == rhs.my_node_ptr;
+}
+
+template <typename NodeType, bool is_const1, bool is_const2>
+bool operator!=(const skip_list_iterator<NodeType, is_const1>& lhs, const skip_list_iterator<NodeType, is_const2>& rhs) {
+    return lhs.my_node_ptr != rhs.my_node_ptr;
+}
+
+template <typename Traits>
+class concurrent_skip_list {
+protected:
+    using traits_type = Traits;
+    using allocator_type = typename traits_type::allocator_type;
+    using allocator_traits_type = std::allocator_traits<allocator_type>;
+    using key_compare = typename traits_type::compare_type;
+    using value_compare = typename traits_type::value_compare;
+    using key_type = typename traits_type::key_type;
+    using value_type = typename traits_type::value_type;
+    using node_type = typename traits_type::node_type;
+    using list_node_type = skip_list_node<value_type, typename traits_type::mutex_type>;
+
+    using iterator = skip_list_iterator<list_node_type, /*is_const=*/false>;
+    using const_iterator = skip_list_iterator<list_node_type, /*is_const=*/true>;
+    using reverse_iterator = std::reverse_iterator<iterator>;
+    using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+
+    using reference = value_type&;
+    using const_reference = const value_type&;
+    using pointer = typename allocator_traits_type::pointer;
+    using const_pointer = typename allocator_traits_type::const_pointer;
+    using size_type = std::size_t;
+    using difference_type = std::ptrdiff_t;
+
+    using random_level_generator_type = typename traits_type::random_level_generator_type;
+    using node_allocator_type = typename std::allocator_traits<allocator_type>::template rebind_alloc<uint8_t>;
+    using node_allocator_traits = typename std::allocator_traits<allocator_type>::template rebind_traits<uint8_t>;
+    using node_ptr = list_node_type*;
+
+    static constexpr size_type MAX_LEVEL = traits_type::MAX_LEVEL;
+
+    using array_type = std::array<node_ptr, MAX_LEVEL>;
+    using lock_array = std::array<typename list_node_type::lock_type, MAX_LEVEL>;
+
+public:
+    static bool const allow_multimapping = traits_type::allow_multimapping;
+
+    /**
+     * Default constructor. Construct empty skip list.
+     */
+    concurrent_skip_list() : my_size(0) {
+        create_dummy_head();
+    }
+
+    explicit concurrent_skip_list(const key_compare& comp, const allocator_type& alloc = allocator_type())
+        : my_node_allocator(alloc), my_compare(comp), my_size(0)
+    {
+        create_dummy_head();
+    }
+
+    template<class InputIt>
+    concurrent_skip_list(InputIt first, InputIt last, const key_compare& comp = key_compare(),
+                         const allocator_type& alloc = allocator_type())
+        : my_node_allocator(alloc), my_compare(comp), my_size(0)
+    {
+        create_dummy_head();
+        internal_copy(first, last);
+    }
+
+    /** Copy constructor */
+    concurrent_skip_list(const concurrent_skip_list& other)
+        : my_node_allocator(node_allocator_traits::select_on_container_copy_construction(other.get_allocator())),
+          my_compare(other.my_compare), my_rnd_generator(other.my_rnd_generator), my_size(0)
+    {
+        create_dummy_head();
+        internal_copy(other);
+        __TBB_ASSERT(my_size == other.my_size, "Wrong size of copy-constructed container");
+    }
+
+    concurrent_skip_list(const concurrent_skip_list& other, const allocator_type& alloc)
+        : my_node_allocator(alloc), my_compare(other.my_compare),
+          my_rnd_generator(other.my_rnd_generator), my_size(0)
+    {
+        create_dummy_head();
+        internal_copy(other);
+        __TBB_ASSERT(my_size == other.my_size, "Wrong size of copy-constructed container");
+    }
+
+    concurrent_skip_list(concurrent_skip_list&& other)
+        : my_node_allocator(std::move(other.my_node_allocator)), my_compare(other.my_compare),
+          my_rnd_generator(other.my_rnd_generator)
+    {
+        internal_move(std::move(other));
+    }
+
+    concurrent_skip_list(concurrent_skip_list&& other, const allocator_type& alloc)
+        : my_node_allocator(alloc), my_compare(other.my_compare),
+          my_rnd_generator(other.my_rnd_generator)
+    {
+        if (alloc == other.get_allocator()) {
+            internal_move(std::move(other));
+        } else {
+            my_size = 0;
+            create_dummy_head();
+            internal_copy(std::make_move_iterator(other.begin()), std::make_move_iterator(other.end()));
+        }
+    }
+
+    ~concurrent_skip_list() {
+        clear();
+        delete_dummy_head();
+    }
+
+    concurrent_skip_list& operator=(const concurrent_skip_list& other) {
+        if (this != &other) {
+            using pocca_type = typename node_allocator_traits::propagate_on_container_copy_assignment;
+            clear();
+            tbb::internal::allocator_copy_assignment(my_node_allocator, other.my_node_allocator, pocca_type());
+            my_compare = other.my_compare;
+            my_rnd_generator = other.my_rnd_generator;
+            internal_copy(other);
+        }
+        return *this;
+    }
+
+    concurrent_skip_list& operator=(concurrent_skip_list&& other) {
+        if (this != &other) {
+            using pocma_type = typename node_allocator_traits::propagate_on_container_move_assignment;
+            clear();
+            my_compare = other.my_compare;
+            my_rnd_generator = other.my_rnd_generator;
+            internal_move_assign(std::move(other), pocma_type());
+        }
+        return *this;
+    }
+
+    concurrent_skip_list& operator=(std::initializer_list<value_type> il)
+    {
+        clear();
+        insert(il.begin(),il.end());
+        return *this;
+    }
+
+    std::pair<iterator, bool> insert(const value_type& value) {
+        return internal_insert(value);
+    }
+
+    std::pair<iterator, bool> insert(value_type&& value) {
+        return internal_insert(std::move(value));
+    }
+
+    iterator insert(const_iterator, const_reference value) {
+        // Ignore hint
+        return insert(value).first;
+    }
+
+    iterator insert(const_iterator, value_type&& value) {
+        // Ignore hint
+        return insert(std::move(value)).first;
+    }
+
+    template<typename InputIterator>
+    void insert(InputIterator first, InputIterator last) {
+        for (InputIterator it = first; it != last; ++it)
+            insert(*it);
+    }
+
+    void insert(std::initializer_list<value_type> init) {
+        insert(init.begin(), init.end());
+    }
+
+    std::pair<iterator, bool> insert(node_type&& nh) {
+        if(!nh.empty()) {
+            std::pair<iterator, bool> insert_result = internal_insert_node(nh.my_node);
+            if(insert_result.second) {
+                nh.deactivate();
+            }
+            return insert_result;
+        }
+        return std::pair<iterator, bool>(end(), false);
+    }
+
+    iterator insert(const_iterator, node_type&& nh) {
+        // Ignore hint
+        return insert(std::move(nh)).first;
+    }
+
+    template<typename... Args >
+    std::pair<iterator, bool> emplace(Args&&... args) {
+        return internal_insert(std::forward<Args>(args)...);
+    }
+
+    template<typename... Args>
+    iterator emplace_hint(const_iterator, Args&&... args) {
+        // Ignore hint
+        return emplace(std::forward<Args>(args)...).first;
+    }
+
+    iterator unsafe_erase(iterator pos) {
+        std::pair<node_ptr, node_ptr> extract_result = internal_extract(pos);
+        if(extract_result.first) { // node was extracted
+            delete_node(extract_result.first);
+            return iterator(extract_result.second);
+        }
+        return end();
+    }
+
+    iterator unsafe_erase(const_iterator pos) {
+        return unsafe_erase(get_iterator(pos));
+    }
+
+    template <typename K, typename = tbb::internal::is_transparent<key_compare, K>,
+                          typename = typename std::enable_if<!std::is_convertible<K, iterator>::value &&
+                                                             !std::is_convertible<K, const_iterator>::value>::type>
+    size_type unsafe_erase(const K& key) {
+        std::pair<iterator, iterator> range = equal_range(key);
+        size_type sz = std::distance(range.first, range.second);
+        unsafe_erase(range.first, range.second);
+        return sz;
+    }
+
+    iterator unsafe_erase(const_iterator first, const_iterator last) {
+        while(first != last) {
+            first = unsafe_erase(get_iterator(first));
+        }
+        return get_iterator(first);
+    }
+
+    size_type unsafe_erase(const key_type& key) {
+        std::pair<iterator, iterator> range = equal_range(key);
+        size_type sz = std::distance(range.first, range.second);
+        unsafe_erase(range.first, range.second);
+        return sz;
+    }
+
+    node_type unsafe_extract(const_iterator pos) {
+        std::pair<node_ptr, node_ptr> extract_result = internal_extract(pos);
+        return extract_result.first ? node_type(extract_result.first) : node_type();
+    }
+
+    node_type unsafe_extract(const key_type& key) {
+        return unsafe_extract(find(key));
+    }
+
+    iterator lower_bound(const key_type& key) {
+        return internal_get_bound(key, my_compare);
+    }
+
+    const_iterator lower_bound(const key_type& key) const {
+        return internal_get_bound(key, my_compare);
+    }
+
+    template <typename K, typename = typename tbb::internal::is_transparent<key_compare, K> >
+    iterator lower_bound(const K& key) {
+        return internal_get_bound(key, my_compare);
+    }
+
+    template <typename K, typename = typename tbb::internal::is_transparent<key_compare, K> >
+    const_iterator lower_bound(const K& key) const {
+        return internal_get_bound(key, my_compare);
+    }
+
+    iterator upper_bound(const key_type& key) {
+        return internal_get_bound(key, not_greater_compare(my_compare));
+    }
+
+    const_iterator upper_bound(const key_type& key) const {
+        return internal_get_bound(key, not_greater_compare(my_compare));
+    }
+
+    template <typename K, typename = typename tbb::internal::is_transparent<key_compare, K> >
+    iterator upper_bound(const K& key) {
+        return internal_get_bound(key, not_greater_compare(my_compare));
+    }
+
+    template <typename K, typename = typename tbb::internal::is_transparent<key_compare, K> >
+    const_iterator upper_bound(const K& key) const {
+        return internal_get_bound(key, not_greater_compare(my_compare));
+    }
+
+    iterator find(const key_type& key) {
+        return internal_find(key);
+    }
+
+    const_iterator find(const key_type& key) const {
+        return internal_find(key);
+    }
+
+    template <typename K, typename = typename tbb::internal::is_transparent<key_compare, K> >
+    iterator find(const K& key) {
+        return internal_find(key);
+    }
+
+    template <typename K, typename = typename tbb::internal::is_transparent<key_compare, K> >
+    const_iterator find(const K& key) const {
+        return internal_find(key);
+    }
+
+    size_type count( const key_type& key ) const {
+        return internal_count(key);
+    }
+
+    template <typename K, typename = typename tbb::internal::is_transparent<key_compare, K> >
+    size_type count(const K& key) const {
+        return internal_count(key);
+    }
+
+    bool contains(const key_type& key) const {
+        return find(key) != end();
+    }
+
+    template <typename K, typename = typename tbb::internal::is_transparent<key_compare, K> >
+    bool contains(const K& key) const {
+        return find(key) != end();
+    }
+
+    void clear() noexcept {
+        __TBB_ASSERT(dummy_head->height() > 0, NULL);
+
+        node_ptr current = dummy_head->next(0);
+        while (current) {
+            __TBB_ASSERT(current->height() > 0, NULL);
+            node_ptr next = current->next(0);
+            delete_node(current);
+            current = next;
+        }
+
+        my_size = 0;
+        for (size_type i = 0; i < dummy_head->height(); ++i) {
+            dummy_head->set_next(i, nullptr);
+        }
+    }
+
+    iterator begin() {
+        return iterator(dummy_head->next(0));
+    }
+
+    const_iterator begin() const {
+        return const_iterator(dummy_head->next(0));
+    }
+
+    const_iterator cbegin() const {
+        return const_iterator(dummy_head->next(0));
+    }
+
+    iterator end() {
+        return iterator(nullptr);
+    }
+
+    const_iterator end() const {
+        return const_iterator(nullptr);
+    }
+
+    const_iterator cend() const {
+        return const_iterator(nullptr);
+    }
+
+    size_type size() const {
+        return my_size.load(std::memory_order_relaxed);
+    }
+
+    size_type max_size() const {
+        return my_node_allocator.max_size();
+    }
+
+    bool empty() const {
+        return 0 == size();
+    }
+
+    allocator_type get_allocator() const {
+        return my_node_allocator;
+    }
+
+    void swap(concurrent_skip_list& other) {
+        using std::swap;
+        using pocs_type = typename node_allocator_traits::propagate_on_container_swap;
+        tbb::internal::allocator_swap(my_node_allocator, other.my_node_allocator, pocs_type());
+        swap(my_compare, other.my_compare);
+        swap(my_rnd_generator, other.my_rnd_generator);
+        swap(dummy_head, other.dummy_head);
+
+        size_type tmp = my_size;
+        my_size.store(other.my_size);
+        other.my_size.store(tmp);
+    }
+
+    std::pair<iterator, iterator> equal_range(const key_type& key) {
+        return std::pair<iterator, iterator>(lower_bound(key), upper_bound(key));
+    }
+
+    std::pair<const_iterator, const_iterator> equal_range(const key_type& key) const {
+        return std::pair<const_iterator, const_iterator>(lower_bound(key), upper_bound(key));
+    }
+
+    template <typename K, typename = typename tbb::internal::is_transparent<key_compare, K> >
+    std::pair<iterator, iterator> equal_range(const K& key) {
+        return std::pair<iterator, iterator>(lower_bound(key), upper_bound(key));
+    }
+
+    template <typename K, typename = typename tbb::internal::is_transparent<key_compare, K> >
+    std::pair<const_iterator, const_iterator> equal_range(const K& key) const {
+        return std::pair<const_iterator, const_iterator>(lower_bound(key), upper_bound(key));
+    }
+
+    key_compare key_comp() const { return my_compare; }
+
+    value_compare value_comp() const { return traits_type::value_comp(my_compare); }
+
+    class const_range_type : tbb::internal::no_assign {
+    public:
+        using size_type = typename concurrent_skip_list::size_type;
+        using value_type = typename concurrent_skip_list::value_type;
+        using iterator = typename concurrent_skip_list::const_iterator;
+    private:
+        const_iterator my_end;
+        const_iterator my_begin;
+        size_type my_level;
+
+    public:
+
+        bool empty() const {
+            return my_begin.my_node_ptr->next(0) == my_end.my_node_ptr;
+        }
+
+        bool is_divisible() const {
+            return my_level != 0 ? my_begin.my_node_ptr->next(my_level - 1) != my_end.my_node_ptr : false;
+        }
+
+        size_type size() const { return std::distance(my_begin, my_end);}
+
+        const_range_type( const_range_type& r, split)
+            : my_end(r.my_end) {
+            my_begin = iterator(r.my_begin.my_node_ptr->next(r.my_level - 1));
+            my_level = my_begin.my_node_ptr->height();
+            r.my_end = my_begin;
+        }
+
+        const_range_type( const concurrent_skip_list& l)
+            : my_end(l.end()), my_begin(l.begin()), my_level(my_begin.my_node_ptr->height() ) {}
+
+        iterator begin() const { return my_begin; }
+        iterator end() const { return my_end; }
+        size_t grainsize() const { return 1; }
+
+    }; // class const_range_type
+
+    class range_type : public const_range_type {
+    public:
+        using iterator = typename concurrent_skip_list::iterator;
+
+        range_type(range_type& r, split) : const_range_type(r, split()) {}
+        range_type(const concurrent_skip_list& l) : const_range_type(l) {}
+
+        iterator begin() const {
+            node_ptr node = const_range_type::begin().my_node_ptr;
+            return iterator(node);
+        }
+
+        iterator end() const {
+            node_ptr node = const_range_type::end().my_node_ptr;
+            return iterator(node); }
+    }; // class range_type
+
+    range_type range() { return range_type(*this); }
+    const_range_type range() const { return const_range_type(*this); }
+
+private:
+    void internal_move(concurrent_skip_list&& other) {
+        dummy_head = other.dummy_head;
+        other.dummy_head = nullptr;
+        other.create_dummy_head();
+
+        my_size = other.my_size.load();
+        other.my_size = 0;
+    }
+
+    static const key_type& get_key(node_ptr n) {
+        __TBB_ASSERT(n, NULL);
+        return traits_type::get_key(n->value());
+    }
+
+    template <typename K>
+    iterator internal_find(const K& key) {
+        iterator it = lower_bound(key);
+        return (it == end() || my_compare(key, traits_type::get_key(*it))) ? end() : it;
+    }
+
+    template <typename K>
+    const_iterator internal_find(const K& key) const {
+        const_iterator it = lower_bound(key);
+        return (it == end() || my_compare(key, traits_type::get_key(*it))) ? end() : it;
+    }
+
+    template <typename K>
+    size_type internal_count( const K& key ) const {
+        if (allow_multimapping) {
+            std::pair<const_iterator, const_iterator> range = equal_range(key);
+            return std::distance(range.first, range.second);
+        }
+        return (find(key) == end()) ? size_type(0) : size_type(1);
+    }
+
+    /**
+     * Finds position on the @param level using @param cmp
+     * @param level - on which level search prev node
+     * @param prev - pointer to the start node to search
+     * @param key - key to search
+     * @param cmp - callable object to compare two objects
+     *  (my_compare member is default comparator)
+     * @returns pointer to the node which is not satisfy the comparison with @param key
+     */
+    template <typename K, typename pointer_type, typename comparator>
+    pointer_type internal_find_position( size_type level, pointer_type& prev, const K& key,
+                                         const comparator& cmp) const {
+        __TBB_ASSERT(level < prev->height(), "Wrong level to find position");
+        pointer_type curr = prev->next(level);
+
+        while (curr && cmp(get_key(curr), key)) {
+            prev = curr;
+            __TBB_ASSERT(level < prev->height(), NULL);
+            curr = prev->next(level);
+        }
+
+        return curr;
+    }
+
+    template <typename comparator>
+    void fill_prev_next_arrays(array_type& prev_nodes, array_type& next_nodes, node_ptr prev, const key_type& key,
+                               const comparator& cmp) {
+        prev_nodes.fill(dummy_head);
+        next_nodes.fill(nullptr);
+
+        for (size_type h = prev->height(); h > 0; --h) {
+            node_ptr next = internal_find_position(h - 1, prev, key, cmp);
+            prev_nodes[h - 1] = prev;
+            next_nodes[h - 1] = next;
+        }
+    }
+
+    template <typename comparator>
+    void fill_prev_next_by_ptr(array_type& prev_nodes, array_type& next_nodes, const_iterator it, const key_type& key,
+                               const comparator& cmp) {
+        node_ptr prev = dummy_head;
+        node_ptr erase_node = it.my_node_ptr;
+        size_type node_height = erase_node->height();
+
+        for (size_type h = prev->height(); h >= node_height; --h) {
+            internal_find_position(h - 1, prev, key, cmp);
+        }
+
+        for (size_type h = node_height; h > 0; --h) {
+            node_ptr curr = prev->next(h - 1);
+            while (const_iterator(curr) != it) {
+                prev = curr;
+                curr = prev->next(h - 1);
+            }
+            prev_nodes[h - 1] = prev;
+        }
+
+        std::fill(next_nodes.begin(), next_nodes.begin() + node_height, erase_node);
+    }
+
+    template<typename... Args>
+    std::pair<iterator, bool> internal_insert(Args&&... args) {
+        node_ptr new_node = create_node(std::forward<Args>(args)...);
+        std::pair<iterator, bool> insert_result = internal_insert_node(new_node);
+        if(!insert_result.second) {
+            delete_node(new_node);
+        }
+        return insert_result;
+    }
+
+    std::pair<iterator, bool> internal_insert_node(node_ptr new_node) {
+        array_type prev_nodes;
+        array_type next_nodes;
+        __TBB_ASSERT(dummy_head->height() >= new_node->height(), "Wrong height for new node");
+
+        do {
+            if (allow_multimapping) {
+                fill_prev_next_arrays(prev_nodes, next_nodes, dummy_head, get_key(new_node),
+                                      not_greater_compare(my_compare));
+            } else {
+                fill_prev_next_arrays(prev_nodes, next_nodes, dummy_head, get_key(new_node), my_compare);
+            }
+
+            node_ptr next = next_nodes[0];
+            if (next && !allow_multimapping && !my_compare(get_key(new_node), get_key(next))) {
+                // TODO: do we really need to wait?
+                while (!next->fully_linked()) {
+                    // TODO: atomic backoff
+                }
+
+                return std::pair<iterator, bool>(iterator(next), false);
+            }
+            __TBB_ASSERT(allow_multimapping || !next || my_compare(get_key(new_node), get_key(next)),
+                         "Wrong elements order");
+
+        } while (!try_insert_node(new_node, prev_nodes, next_nodes));
+
+        __TBB_ASSERT(new_node, NULL);
+        return std::pair<iterator, bool>(iterator(new_node), true);
+    }
+
+    bool try_insert_node(node_ptr new_node, array_type& prev_nodes, array_type& next_nodes) {
+        __TBB_ASSERT(dummy_head->height() >= new_node->height(), NULL);
+
+        lock_array locks;
+
+        if (!try_lock_nodes(new_node->height(), prev_nodes, next_nodes, locks)) {
+            return false;
+        }
+
+        __TBB_ASSERT(allow_multimapping ||
+                    ((prev_nodes[0] == dummy_head ||
+                      my_compare(get_key(prev_nodes[0]), get_key(new_node))) &&
+                      (next_nodes[0] == nullptr || my_compare(get_key(new_node), get_key(next_nodes[0])))),
+                    "Wrong elements order");
+
+        for (size_type level = 0; level < new_node->height(); ++level) {
+            __TBB_ASSERT(prev_nodes[level]->height() > level, NULL);
+            __TBB_ASSERT(prev_nodes[level]->next(level) == next_nodes[level], NULL);
+            new_node->set_next(level, next_nodes[level]);
+            prev_nodes[level]->set_next(level, new_node);
+        }
+        new_node->mark_linked();
+
+        ++my_size;
+
+        return true;
+    }
+
+    bool try_lock_nodes(size_type height, array_type& prevs, array_type& next_nodes, lock_array& locks) {
+        for (size_type l = 0; l < height; ++l) {
+            if (l == 0 || prevs[l] != prevs[l - 1])
+                locks[l] = prevs[l]->acquire();
+
+            node_ptr next = prevs[l]->next(l);
+            if ( next != next_nodes[l]) return false;
+        }
+
+        return true;
+    }
+
+    template <typename K, typename comparator>
+    const_iterator internal_get_bound(const K& key, const comparator& cmp) const {
+        node_ptr prev = dummy_head;
+        __TBB_ASSERT(dummy_head->height() > 0, NULL);
+        node_ptr next = nullptr;
+
+        for (size_type h = prev->height(); h > 0; --h) {
+            next = internal_find_position(h - 1, prev, key, cmp);
+        }
+
+        return const_iterator(next);
+    }
+
+    template <typename K, typename comparator>
+    iterator internal_get_bound(const K& key, const comparator& cmp){
+        node_ptr prev = dummy_head;
+        __TBB_ASSERT(dummy_head->height() > 0, NULL);
+        node_ptr next = nullptr;
+
+        for (size_type h = prev->height(); h > 0; --h) {
+            next = internal_find_position(h - 1, prev, key, cmp);
+        }
+
+        return iterator(next);
+    }
+
+    // Returns node_ptr to the extracted node and node_ptr to the next node after the extracted
+    std::pair<node_ptr, node_ptr> internal_extract(const_iterator it) {
+        if ( it != end() ) {
+            key_type key = traits_type::get_key(*it);
+            __TBB_ASSERT(dummy_head->height() > 0, NULL);
+
+            array_type prev_nodes;
+            array_type next_nodes;
+
+            fill_prev_next_by_ptr(prev_nodes, next_nodes, it, key, my_compare);
+
+            node_ptr erase_node = next_nodes[0];
+            __TBB_ASSERT(erase_node != nullptr, NULL);
+            node_ptr next_node = erase_node->next(0);
+
+            if (!my_compare(key, get_key(erase_node))) {
+                for(size_type level = 0; level < erase_node->height(); ++level) {
+                    __TBB_ASSERT(prev_nodes[level]->height() > level, NULL);
+                    __TBB_ASSERT(next_nodes[level] == erase_node, NULL);
+                    prev_nodes[level]->set_next(level, erase_node->next(level));
+                }
+                --my_size;
+                return std::pair<node_ptr, node_ptr>(erase_node, next_node);
+            }
+        }
+        return std::pair<node_ptr, node_ptr>(nullptr, nullptr);
+    }
+
+protected:
+    template<typename SourceType>
+    void internal_merge(SourceType&& source) {
+        using source_type = typename std::decay<SourceType>::type;
+        using source_iterator = typename source_type::iterator;
+        __TBB_STATIC_ASSERT((std::is_same<node_type, typename source_type::node_type>::value), "Incompatible containers cannot be merged");
+
+        for(source_iterator it = source.begin(); it != source.end();) {
+            source_iterator where = it++;
+            if (allow_multimapping || !contains(traits_type::get_key(*where))) {
+                std::pair<node_ptr, node_ptr> extract_result = source.internal_extract(where);
+
+                //If the insertion fails - return the node into source
+                node_type handle(extract_result.first);
+                __TBB_ASSERT(!handle.empty(), "Extracted handle in merge is empty");
+
+                if (!insert(std::move(handle)).second) {
+                    source.insert(std::move(handle));
+                }
+                handle.deactivate();
+            }
+        }
+    }
+
+private:
+    void internal_copy(const concurrent_skip_list& other) {
+        internal_copy(other.begin(), other.end());
+    }
+
+    template<typename Iterator>
+    void internal_copy(Iterator first, Iterator last) {
+        clear();
+        try {
+            for (auto it = first; it != last; ++it)
+                insert(*it);
+        }
+        catch (...) {
+            clear();
+            delete_dummy_head();
+            throw;
+        }
+    }
+
+    /** Generate random level */
+    size_type random_level() {
+        return my_rnd_generator();
+    }
+
+    static size_type calc_node_size(size_type height) {
+        return sizeof(list_node_type) + height*sizeof(typename list_node_type::atomic_node_pointer);
+    }
+
+    /** Creates new node */
+    template <typename... Args>
+    node_ptr create_node(Args&&... args) {
+        size_type levels = random_level();
+
+        size_type sz = calc_node_size(levels);
+
+        node_ptr node = reinterpret_cast<node_ptr>(node_allocator_traits::allocate(my_node_allocator, sz));
+
+        try {
+            node_allocator_traits::construct(my_node_allocator, node, levels);
+
+        }
+        catch(...) {
+            deallocate_node(node, sz);
+            throw;
+        }
+
+        try {
+            node_allocator_traits::construct(my_node_allocator, node->storage(), std::forward<Args>(args)...);
+        }
+        catch (...) {
+            node_allocator_traits::destroy(my_node_allocator, node);
+            deallocate_node(node, sz);
+            throw;
+        }
+
+        return node;
+    }
+
+    void create_dummy_head() {
+        size_type sz = calc_node_size(MAX_LEVEL);
+
+        dummy_head = reinterpret_cast<node_ptr>(node_allocator_traits::allocate(my_node_allocator, sz));
+        // TODO: investigate linkage fail in debug without this workaround
+        auto max_level = MAX_LEVEL;
+
+        try {
+            node_allocator_traits::construct(my_node_allocator, dummy_head, max_level);
+        }
+        catch(...) {
+            deallocate_node(dummy_head, sz);
+            throw;
+        }
+    }
+
+    template <bool is_dummy = false>
+    void delete_node(node_ptr node) {
+        size_type sz = calc_node_size(node->height());
+        // Destroy value
+        if (!is_dummy) node_allocator_traits::destroy(my_node_allocator, node->storage());
+        // Destroy node
+        node_allocator_traits::destroy(my_node_allocator, node);
+        // Deallocate memory
+        deallocate_node(node, sz);
+    }
+
+    void deallocate_node(node_ptr node, size_type sz) {
+        node_allocator_traits::deallocate(my_node_allocator, reinterpret_cast<uint8_t*>(node), sz);
+    }
+
+    void delete_dummy_head() {
+        delete_node<true>(dummy_head);
+    }
+
+    static iterator get_iterator(const_iterator it) {
+        return iterator(it.my_node_ptr);
+    }
+
+    void internal_move_assign(concurrent_skip_list&& other, /*POCMA=*/std::true_type) {
+        delete_dummy_head();
+        tbb::internal::allocator_move_assignment(my_node_allocator, other.my_node_allocator, std::true_type());
+        internal_move(std::move(other));
+    }
+
+    void internal_move_assign(concurrent_skip_list&& other, /*POCMA=*/std::false_type) {
+        if (my_node_allocator == other.my_node_allocator) {
+            delete_dummy_head();
+            internal_move(std::move(other));
+        } else {
+            internal_copy(std::make_move_iterator(other.begin()), std::make_move_iterator(other.end()));
+        }
+    }
+
+    struct not_greater_compare {
+        const key_compare& my_less_compare;
+
+        not_greater_compare(const key_compare& less_compare) : my_less_compare(less_compare) {}
+
+        template <typename K1, typename K2>
+        bool operator()(const K1& first, const K2& second) const {
+            return !my_less_compare(second, first);
+        }
+    };
+
+    node_allocator_type my_node_allocator;
+    key_compare my_compare;
+    random_level_generator_type my_rnd_generator;
+    node_ptr dummy_head;
+
+    template<typename OtherTraits>
+    friend class concurrent_skip_list;
+
+    std::atomic<size_type> my_size;
+}; // class concurrent_skip_list
+
+template <size_t MAX_LEVEL>
+class concurrent_geometric_level_generator {
+public:
+    static constexpr size_t max_level = MAX_LEVEL;
+
+    concurrent_geometric_level_generator() : engines(time(NULL)) {}
+
+    size_t operator()() {
+        return (distribution(engines.local()) % MAX_LEVEL) + 1;
+    }
+
+private:
+    tbb::enumerable_thread_specific<std::mt19937_64> engines;
+    std::geometric_distribution<size_t> distribution;
+};
+
+} // namespace internal
+} // namespace interface10
+} // namespace tbb
+
+#endif // __TBB_concurrent_skip_list_H
diff --git a/src/tbb/include/tbb/internal/_concurrent_unordered_impl.h b/src/tbb/include/tbb/internal/_concurrent_unordered_impl.h
index 2395aa08..b4bbefa5 100644
--- a/src/tbb/include/tbb/internal/_concurrent_unordered_impl.h
+++ b/src/tbb/include/tbb/internal/_concurrent_unordered_impl.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 /* Container implementations in this header are based on PPL implementations
@@ -44,7 +40,17 @@
     #include <initializer_list>
 #endif
 
+#if __TBB_CPP11_RVALUE_REF_PRESENT && !__TBB_IMPLICIT_COPY_DELETION_BROKEN
+    #define __TBB_UNORDERED_NODE_HANDLE_PRESENT 1
+#endif
+
+#include "_allocator_traits.h"
 #include "_tbb_hash_compare_impl.h"
+#include "_template_helpers.h"
+
+#if __TBB_UNORDERED_NODE_HANDLE_PRESENT
+#include "_node_handle_impl.h"
+#endif // __TBB_UNORDERED_NODE_HANDLE_PRESENT
 
 namespace tbb {
 namespace interface5 {
@@ -78,6 +84,11 @@ class flist_iterator : public std::iterator<std::forward_iterator_tag, Value>
     flist_iterator( const flist_iterator<Solist, typename Solist::value_type> &other )
         : my_node_ptr(other.my_node_ptr) {}
 
+    flist_iterator& operator=( const flist_iterator<Solist, typename Solist::value_type> &other ) {
+        my_node_ptr = other.my_node_ptr;
+        return *this;
+    }
+
     reference operator*() const { return my_node_ptr->my_element; }
     pointer operator->() const { return &**this; }
 
@@ -124,6 +135,8 @@ class solist_iterator : public flist_iterator<Solist, Value>
     friend class split_ordered_list;
     template<class M, typename V>
     friend class solist_iterator;
+    template <typename Traits>
+    friend class concurrent_unordered_base;
     template<typename M, typename T, typename U>
     friend bool operator==( const solist_iterator<M,T> &i, const solist_iterator<M,U> &j );
     template<typename M, typename T, typename U>
@@ -139,9 +152,15 @@ class solist_iterator : public flist_iterator<Solist, Value>
     typedef typename Solist::reference reference;
 
     solist_iterator() {}
-    solist_iterator(const solist_iterator<Solist, typename Solist::value_type> &other )
+    solist_iterator( const solist_iterator<Solist, typename Solist::value_type> &other )
         : base_type(other), my_list_ptr(other.my_list_ptr) {}
 
+    solist_iterator& operator=( const solist_iterator<Solist, typename Solist::value_type> &other ) {
+        base_type::my_node_ptr = other.get_node_ptr();
+        my_list_ptr = other.my_list_ptr;
+        return *this;
+    }
+
     reference operator*() const {
         return this->base_type::operator*();
     }
@@ -185,17 +204,20 @@ class split_ordered_list
 {
 public:
     typedef split_ordered_list<T, Allocator> self_type;
-    typedef typename Allocator::template rebind<T>::other allocator_type;
+
+    typedef typename tbb::internal::allocator_rebind<Allocator, T>::type allocator_type;
+
     struct node;
     typedef node *nodeptr_t;
 
-    typedef typename allocator_type::size_type size_type;
-    typedef typename allocator_type::difference_type difference_type;
-    typedef typename allocator_type::pointer pointer;
-    typedef typename allocator_type::const_pointer const_pointer;
-    typedef typename allocator_type::reference reference;
-    typedef typename allocator_type::const_reference const_reference;
-    typedef typename allocator_type::value_type value_type;
+    typedef typename tbb::internal::allocator_traits<allocator_type>::value_type value_type;
+    typedef typename tbb::internal::allocator_traits<allocator_type>::size_type size_type;
+    typedef typename tbb::internal::allocator_traits<allocator_type>::difference_type difference_type;
+    typedef typename tbb::internal::allocator_traits<allocator_type>::pointer pointer;
+    typedef typename tbb::internal::allocator_traits<allocator_type>::const_pointer const_pointer;
+    // No support for reference/const_reference in allocator traits
+    typedef value_type& reference;
+    typedef const value_type& const_reference;
 
     typedef solist_iterator<self_type, const value_type> const_iterator;
     typedef solist_iterator<self_type, value_type> iterator;
@@ -220,6 +242,15 @@ class split_ordered_list
             return my_order_key;
         }
 
+        // get() and value() is a common interface for getting access to node`s element (required by node_handle)
+        value_type* storage() {
+            return reinterpret_cast<value_type*>(&my_element);
+        }
+
+        value_type& value() {
+        return *storage();
+        }
+
         // Inserts the new element in the list in an atomic fashion
         nodeptr_t atomic_set_next(nodeptr_t new_node, nodeptr_t current_node)
         {
@@ -564,27 +595,49 @@ class split_ordered_list
 
     }
 
-    // This erase function can handle both real and dummy nodes
-    void erase_node(raw_iterator previous, raw_const_iterator& where)
-    {
+    nodeptr_t  erase_node_impl(raw_iterator previous, raw_const_iterator& where) {
         nodeptr_t pnode = (where++).get_node_ptr();
         nodeptr_t prevnode = previous.get_node_ptr();
         __TBB_ASSERT(prevnode->my_next == pnode, "Erase must take consecutive iterators");
         prevnode->my_next = pnode->my_next;
+        return pnode;
+    }
 
+    // This erase function can handle both real and dummy nodes
+    void erase_node(raw_iterator previous, raw_const_iterator& where,
+                    /*allow_destroy*/tbb::internal::true_type)
+    {
+        nodeptr_t pnode = erase_node_impl(previous, where);
         destroy_node(pnode);
     }
 
+    void erase_node(raw_iterator previous, raw_const_iterator& where,
+                    /*allow_destroy*/tbb::internal::false_type)
+    {
+        erase_node_impl(previous, where);
+    }
+
+    void erase_node(raw_iterator previous, raw_const_iterator& where) {
+        erase_node(previous, where, /*allow_destroy*/tbb::internal::true_type());
+    }
+
     // Erase the element (previous node needs to be passed because this is a forward only list)
-    iterator erase_node(raw_iterator previous, const_iterator where)
+    template<typename AllowDestroy>
+    iterator erase_node(raw_iterator previous, const_iterator where, AllowDestroy)
     {
         raw_const_iterator it = where;
-        erase_node(previous, it);
+        erase_node(previous, it, AllowDestroy());
         my_element_count--;
 
         return get_iterator(first_real_iterator(it));
     }
 
+    iterator erase_node(raw_iterator previous, const_iterator& where) {
+        return erase_node(previous, where, /*allow_destroy*/tbb::internal::true_type());
+    }
+
+
+
     // Move all elements from the passed in split-ordered list to this one
     void move_all(self_type& source)
     {
@@ -639,7 +692,7 @@ class split_ordered_list
 #endif
     }
 
-    typename allocator_type::template rebind<node>::other my_node_allocator;  // allocator object for nodes
+    typename tbb::internal::allocator_rebind<allocator_type, node>::type my_node_allocator; // allocator object for nodes
     size_type                                             my_element_count;   // Total item count, not counting dummy nodes
     nodeptr_t                                             my_head;            // pointer to head node
 };
@@ -661,12 +714,15 @@ class concurrent_unordered_base : public Traits
     typedef typename Traits::allocator_type allocator_type;
     typedef typename hash_compare::hasher hasher;
     typedef typename hash_compare::key_equal key_equal;
-    typedef typename allocator_type::pointer pointer;
-    typedef typename allocator_type::const_pointer const_pointer;
-    typedef typename allocator_type::reference reference;
-    typedef typename allocator_type::const_reference const_reference;
-    typedef typename allocator_type::size_type size_type;
-    typedef typename allocator_type::difference_type difference_type;
+
+    typedef typename tbb::internal::allocator_traits<allocator_type>::size_type size_type;
+    typedef typename tbb::internal::allocator_traits<allocator_type>::difference_type difference_type;
+    typedef typename tbb::internal::allocator_traits<allocator_type>::pointer pointer;
+    typedef typename tbb::internal::allocator_traits<allocator_type>::const_pointer const_pointer;
+    // No support for reference/const_reference in allocator
+    typedef typename allocator_type::value_type& reference;
+    typedef const typename allocator_type::value_type& const_reference;
+
     typedef split_ordered_list<value_type, typename Traits::allocator_type> solist_t;
     typedef typename solist_t::nodeptr_t nodeptr_t;
     // Iterators that walk the entire split-order list, including dummy nodes
@@ -676,12 +732,19 @@ class concurrent_unordered_base : public Traits
     typedef typename solist_t::const_iterator const_iterator;
     typedef iterator local_iterator;
     typedef const_iterator const_local_iterator;
+#if __TBB_UNORDERED_NODE_HANDLE_PRESENT
+    typedef typename Traits::node_type node_type;
+#endif // __TBB_UNORDERED_NODE_HANDLE_PRESENT
     using Traits::my_hash_compare;
     using Traits::get_key;
     using Traits::allow_multimapping;
 
     static const size_type initial_bucket_number = 8;                               // Initial number of buckets
+
 private:
+    template<typename OtherTraits>
+    friend class concurrent_unordered_base;
+
     typedef std::pair<iterator, iterator> pairii_t;
     typedef std::pair<const_iterator, const_iterator> paircc_t;
 
@@ -727,8 +790,10 @@ class concurrent_unordered_base : public Traits
 
 #if __TBB_CPP11_RVALUE_REF_PRESENT
     concurrent_unordered_base(concurrent_unordered_base&& right)
-        : Traits(right.my_hash_compare), my_solist(right.get_allocator()), my_allocator(right.get_allocator())
+        : Traits(right.my_hash_compare), my_solist(right.get_allocator()), my_allocator(right.get_allocator()),
+          my_maximum_bucket_size(float(initial_bucket_load))
     {
+        my_number_of_buckets = initial_bucket_number;
         internal_init();
         swap(right);
     }
@@ -740,6 +805,8 @@ class concurrent_unordered_base : public Traits
 
         internal_init();
         if (a == right.get_allocator()){
+            my_number_of_buckets = initial_bucket_number;
+            my_maximum_bucket_size = float(initial_bucket_load);
             this->swap(right);
         }else{
             my_maximum_bucket_size = right.my_maximum_bucket_size;
@@ -820,6 +887,49 @@ class concurrent_unordered_base : public Traits
         internal_clear();
     }
 
+#if __TBB_UNORDERED_NODE_HANDLE_PRESENT
+    template<typename SourceType>
+    void internal_merge(SourceType& source) {
+        typedef typename SourceType::iterator source_iterator;
+        __TBB_STATIC_ASSERT((tbb::internal::is_same_type<node_type,
+                            typename SourceType::node_type>::value),
+                            "Incompatible containers cannot be merged");
+
+        for(source_iterator it = source.begin(); it != source.end();) {
+            source_iterator where = it++;
+            if (allow_multimapping || find(get_key(*where)) == end()) {
+                std::pair<node_type, raw_iterator> extract_result = source.internal_extract(where);
+
+                // Remember the old order key
+                sokey_t old_order_key = extract_result.first.my_node->get_order_key();
+
+                // If the insertion fails, it returns ownership of the node to extract_result.first
+                // extract_result.first remains valid node handle
+                if (!insert(std::move(extract_result.first)).second) {
+                    raw_iterator next = extract_result.second;
+                    raw_iterator current = next++;
+
+                    // Revert order key to old value
+                    extract_result.first.my_node->init(old_order_key);
+
+                    __TBB_ASSERT(extract_result.first.my_node->get_order_key() >= current.get_node_ptr()->get_order_key(),
+                                "Wrong nodes order in source container");
+                    __TBB_ASSERT(next==source.my_solist.raw_end() ||
+                                 extract_result.first.my_node->get_order_key() <= next.get_node_ptr()->get_order_key(),
+                                 "Wrong nodes order in source container");
+
+                    size_t new_count = 0;// To use try_insert()
+                    bool insert_result =
+                        source.my_solist.try_insert(current, next, extract_result.first.my_node, &new_count).second;
+                    __TBB_ASSERT_EX(insert_result, "Return to source must be successful. "
+                                                   "Changing source container while merging is unsafe.");
+                }
+                extract_result.first.deactivate();
+            }
+        }
+    }
+#endif // __TBB_UNORDERED_NODE_HANDLE_PRESENT
+
 public:
     allocator_type get_allocator() const {
         return my_solist.get_allocator();
@@ -956,7 +1066,8 @@ class concurrent_unordered_base : public Traits
 
     // Modifiers
     std::pair<iterator, bool> insert(const value_type& value) {
-        return internal_insert</*AllowCreate=*/tbb::internal::true_type>(value);
+        return internal_insert</*AllowCreate=*/tbb::internal::true_type,
+                               /*AllowDestroy=*/tbb::internal::true_type>(value);
     }
 
     iterator insert(const_iterator, const value_type& value) {
@@ -966,23 +1077,43 @@ class concurrent_unordered_base : public Traits
 
 #if __TBB_CPP11_RVALUE_REF_PRESENT
     std::pair<iterator, bool> insert(value_type&& value) {
-        return internal_insert</*AllowCreate=*/tbb::internal::true_type>(std::move(value));
+        return internal_insert</*AllowCreate=*/tbb::internal::true_type,
+                               /*AllowDestroy=*/tbb::internal::true_type>(std::move(value));
     }
 
     iterator insert(const_iterator, value_type&& value) {
         // Ignore hint
         return insert(std::move(value)).first;
     }
+#endif /*__TBB_CPP11_RVALUE_REF_PRESENT*/
+
+#if __TBB_UNORDERED_NODE_HANDLE_PRESENT
+    std::pair<iterator, bool> insert(node_type&& nh) {
+        if (!nh.empty()) {
+            nodeptr_t handled_node = nh.my_node;
+            std::pair<iterator, bool> insert_result =
+                                      internal_insert</*AllowCreate=*/tbb::internal::false_type,
+                                                      /*AllowDestroy=*/tbb::internal::false_type>
+                                                      (handled_node->my_element, handled_node);
+            if (insert_result.second)
+                nh.deactivate();
+            return insert_result;
+        }
+        return std::pair<iterator, bool>(end(), false);
+    }
+
+    iterator insert(const_iterator, node_type&& nh) {
+        return insert(std::move(nh)).first;
+    }
+#endif // __TBB_UNORDERED_NODE_HANDLE_PRESENT
 
-#if __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT
+#if __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT && __TBB_CPP11_RVALUE_REF_PRESENT
     template<typename... Args>
     std::pair<iterator, bool> emplace(Args&&... args) {
         nodeptr_t pnode = my_solist.create_node_v(tbb::internal::forward<Args>(args)...);
-        const sokey_t hashed_element_key = (sokey_t) my_hash_compare(get_key(pnode->my_element));
-        const sokey_t order_key = split_order_key_regular(hashed_element_key);
-        pnode->init(order_key);
 
-        return internal_insert</*AllowCreate=*/tbb::internal::false_type>(pnode->my_element, pnode);
+        return internal_insert</*AllowCreate=*/tbb::internal::false_type,
+                               /*AllowDestroy=*/tbb::internal::true_type>(pnode->my_element, pnode);
     }
 
     template<typename... Args>
@@ -990,9 +1121,8 @@ class concurrent_unordered_base : public Traits
         // Ignore hint
         return emplace(tbb::internal::forward<Args>(args)...).first;
     }
+#endif // __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT && __TBB_CPP11_RVALUE_REF_PRESENT
 
-#endif // __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT
-#endif // __TBB_CPP11_RVALUE_REF_PRESENT
 
     template<class Iterator>
     void insert(Iterator first, Iterator last) {
@@ -1024,9 +1154,21 @@ class concurrent_unordered_base : public Traits
         return item_count;
     }
 
+#if __TBB_UNORDERED_NODE_HANDLE_PRESENT
+    node_type unsafe_extract(const_iterator where) {
+        return internal_extract(where).first;
+    }
+
+    node_type unsafe_extract(const key_type& key) {
+        pairii_t where = equal_range(key);
+        if (where.first == end()) return node_type(); // element was not found
+        return internal_extract(where.first).first;
+    }
+#endif // __TBB_UNORDERED_NODE_HANDLE_PRESENT
+
     void swap(concurrent_unordered_base& right) {
         if (this != &right) {
-            std::swap(my_hash_compare, right.my_hash_compare); // TODO: check what ADL meant here
+            std::swap(my_hash_compare, right.my_hash_compare);
             my_solist.swap(right.my_solist);
             internal_swap_buckets(right);
             std::swap(my_number_of_buckets, right.my_number_of_buckets);
@@ -1258,7 +1400,7 @@ class concurrent_unordered_base : public Traits
     }
 
     // Insert an element in the hash given its value
-    template<typename AllowCreate, typename ValueType>
+    template<typename AllowCreate, typename AllowDestroy, typename ValueType>
     std::pair<iterator, bool> internal_insert(__TBB_FORWARDING_REF(ValueType) value, nodeptr_t pnode = NULL)
     {
         const key_type *pkey = &get_key(value);
@@ -1269,6 +1411,11 @@ class concurrent_unordered_base : public Traits
         raw_iterator last = my_solist.raw_end();
         __TBB_ASSERT(previous != last, "Invalid head node");
 
+        if (pnode) {
+            // Set new order_key to node
+            pnode->init(order_key);
+        }
+
         // First node is a dummy node
         for (raw_iterator where = previous;;)
         {
@@ -1307,7 +1454,7 @@ class concurrent_unordered_base : public Traits
             else if (!allow_multimapping && solist_t::get_order_key(where) == order_key &&
                      !my_hash_compare(get_key(*where), *pkey)) // TODO: fix negation
             { // Element already in the list, return it
-                 if (pnode)
+                 if (pnode && AllowDestroy::value)
                      my_solist.destroy_node(pnode);
                 return std::pair<iterator, bool>(my_solist.get_iterator(where), false);
             }
@@ -1353,14 +1500,33 @@ class concurrent_unordered_base : public Traits
         __TBB_ASSERT(previous != last, "Invalid head node");
 
         // First node is a dummy node
-        for (raw_iterator where = previous; ; previous = where) {
+        for (raw_iterator where = previous; where != last; previous = where) {
             ++where;
-            if (where == last)
-                return end();
-            else if (my_solist.get_iterator(where) == it)
+            if (my_solist.get_iterator(where) == it)
                 return my_solist.erase_node(previous, it);
         }
+        return end();
+    }
+
+#if __TBB_UNORDERED_NODE_HANDLE_PRESENT
+    std::pair<node_type, raw_iterator> internal_extract(const_iterator it) {
+        sokey_t hash_key = sokey_t(my_hash_compare(get_key(*it)));
+        raw_iterator previous = prepare_bucket(hash_key);
+        raw_iterator last = my_solist.raw_end();
+        __TBB_ASSERT(previous != last, "Invalid head node");
+
+        for(raw_iterator where = previous; where != last; previous = where) {
+            ++where;
+            if (my_solist.get_iterator(where) == it) {
+                const_iterator result = it;
+                my_solist.erase_node(previous, it, /*allow_destroy*/tbb::internal::false_type());
+                return std::pair<node_type, raw_iterator>( node_type(result.get_node_ptr()),
+                                                           previous);
+            }
+        }
+        return std::pair<node_type, iterator>(node_type(), end());
     }
+#endif // __TBB_UNORDERED_NODE_HANDLE_PRESENT
 
     // Return the [begin, end) pair of iterators with the same key values.
     // This operation makes sense only if mapping is many-to-one.
@@ -1468,7 +1634,7 @@ class concurrent_unordered_base : public Traits
         if (my_buckets[segment] == NULL) {
             size_type sz = segment_size(segment);
             raw_iterator * new_segment = my_allocator.allocate(sz);
-            std::memset((void*) new_segment, 0, sz*sizeof(raw_iterator));
+            std::memset(static_cast<void*>(new_segment), 0, sz*sizeof(raw_iterator));
 
             if (my_buckets[segment].compare_and_swap( new_segment, NULL) != NULL)
                 my_allocator.deallocate(new_segment, sz);
@@ -1503,7 +1669,7 @@ class concurrent_unordered_base : public Traits
     // Shared variables
     atomic<size_type>                                             my_number_of_buckets;       // Current table size
     solist_t                                                      my_solist;                  // List where all the elements are kept
-    typename allocator_type::template rebind<raw_iterator>::other my_allocator;               // Allocator object for segments
+    typename tbb::internal::allocator_rebind<allocator_type, raw_iterator>::type my_allocator; // Allocator object for segments
     float                                                         my_maximum_bucket_size;     // Maximum size of the bucket
     atomic<raw_iterator*>                                         my_buckets[pointers_per_table]; // The segment table
 };
diff --git a/src/tbb/include/tbb/internal/_deprecated_header_message_guard.h b/src/tbb/include/tbb/internal/_deprecated_header_message_guard.h
new file mode 100644
index 00000000..fa993572
--- /dev/null
+++ b/src/tbb/include/tbb/internal/_deprecated_header_message_guard.h
@@ -0,0 +1,69 @@
+/*
+    Copyright (c) 2005-2020 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 "tbb/tbb_config.h"
+
+#if (!defined(TBB_SUPPRESS_DEPRECATED_MESSAGES) || (TBB_SUPPRESS_DEPRECATED_MESSAGES == 0)) && !defined(__TBB_INTERNAL_INCLUDES_DEPRECATION_MESSAGE) && \
+!defined(__TBB_condition_variable_H_include_area) && \
+!defined(__TBB_ppl_H_include_area) && \
+!defined(__TBB_thread_H_include_area) && \
+!defined(__TBB_tuple_H_include_area) && \
+!defined(__TBB_aggregator_H_include_area) && \
+!defined(__TBB_aligned_space_H_include_area) && \
+!defined(__TBB_atomic_H_include_area) && \
+!defined(__TBB_combinable_H_include_area) && \
+!defined(__TBB_concurrent_hash_map_H_include_area) && \
+!defined(__TBB_concurrent_lru_cache_H_include_area) && \
+!defined(__TBB_concurrent_map_H_include_area) && \
+!defined(__TBB_concurrent_priority_queue_H_include_area) && \
+!defined(__TBB_concurrent_queue_H_include_area) && \
+!defined(__TBB_concurrent_set_H_include_area) && \
+!defined(__TBB_concurrent_unordered_map_H_include_area) && \
+!defined(__TBB_concurrent_unordered_set_H_include_area) && \
+!defined(__TBB_concurrent_vector_H_include_area) && \
+!defined(__TBB_critical_section_H_include_area) && \
+!defined(__TBB_enumerable_thread_specific_H_include_area) && \
+!defined(__TBB_flow_graph_opencl_node_H_include_area) && \
+!defined(__TBB_flow_graph_H_include_area) && \
+!defined(__TBB_mutex_H_include_area) && \
+!defined(__TBB_parallel_do_H_include_area) && \
+!defined(__TBB_parallel_for_H_include_area) && \
+!defined(__TBB_parallel_invoke_H_include_area) && \
+!defined(__TBB_parallel_reduce_H_include_area) && \
+!defined(__TBB_parallel_scan_H_include_area) && \
+!defined(__TBB_parallel_sort_H_include_area) && \
+!defined(__TBB_parallel_while_H_include_area) && \
+!defined(__TBB_partitioner_H_include_area) && \
+!defined(__TBB_pipeline_H_include_area) && \
+!defined(__TBB_queuing_mutex_H_include_area) && \
+!defined(__TBB_queuing_rw_mutex_H_include_area) && \
+!defined(__TBB_reader_writer_lock_H_include_area) && \
+!defined(__TBB_recursive_mutex_H_include_area) && \
+!defined(__TBB_runtime_loader_H_include_area) && \
+!defined(__TBB_task_scheduler_init_H_include_area) && \
+!defined(__TBB_spin_mutex_H_include_area) && \
+!defined(__TBB_task_arena_H_include_area) && \
+!defined(__TBB_task_group_H_include_area) && \
+!defined(__TBB_task_scheduler_observer_H_include_area) && \
+!defined(__TBB_task_H_include_area) && \
+!defined(__TBB_tbb_exception_H_include_area) && \
+!defined(__TBB_tbb_profiling_H_include_area) && \
+!defined(__TBB_tbb_thread_H_include_area) && \
+!defined(__TBB_tbb_H_include_area)
+
+#define __TBB_show_deprecated_header_message
+
+#endif
diff --git a/src/tbb/include/tbb/internal/_flow_graph_async_msg_impl.h b/src/tbb/include/tbb/internal/_flow_graph_async_msg_impl.h
index 794960db..9f269ffd 100644
--- a/src/tbb/include/tbb/internal/_flow_graph_async_msg_impl.h
+++ b/src/tbb/include/tbb/internal/_flow_graph_async_msg_impl.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB__flow_graph_async_msg_impl_H
@@ -122,7 +118,7 @@ class async_storage {
 } // namespace internal
 
 template <typename T>
-class async_msg {
+class __TBB_DEPRECATED async_msg {
     template< typename > friend class receiver;
     template< typename, typename > friend struct internal::async_helpers;
 public:
diff --git a/src/tbb/include/tbb/internal/_flow_graph_body_impl.h b/src/tbb/include/tbb/internal/_flow_graph_body_impl.h
index 54f37411..e75f50da 100644
--- a/src/tbb/include/tbb/internal/_flow_graph_body_impl.h
+++ b/src/tbb/include/tbb/internal/_flow_graph_body_impl.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,15 +12,13 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB__flow_graph_body_impl_H
 #define __TBB__flow_graph_body_impl_H
 
+#include "tbb/internal/_template_helpers.h"
+
 #ifndef __TBB_flow_graph_H
 #error Do not #include this internal file directly; use public TBB headers instead.
 #endif
@@ -33,11 +31,46 @@ typedef tbb::internal::uint64_t tag_value;
 
 using tbb::internal::strip;
 
+#if __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT
+
+template<typename ... Policies> struct Policy {};
+
+template<typename ... Policies> struct has_policy;
+
+template<typename ExpectedPolicy, typename FirstPolicy, typename ...Policies>
+struct has_policy<ExpectedPolicy, FirstPolicy, Policies...> :
+    tbb::internal::bool_constant<has_policy<ExpectedPolicy, FirstPolicy>::value ||
+                                 has_policy<ExpectedPolicy, Policies...>::value> {};
+
+template<typename ExpectedPolicy, typename SinglePolicy>
+struct has_policy<ExpectedPolicy, SinglePolicy> :
+    tbb::internal::bool_constant<tbb::internal::is_same_type<ExpectedPolicy, SinglePolicy>::value> {};
+
+template<typename ExpectedPolicy, typename ...Policies>
+struct has_policy<ExpectedPolicy, Policy<Policies...> > : has_policy<ExpectedPolicy, Policies...> {};
+
+#else
+
+template<typename P1, typename P2 = void> struct Policy {};
+
+template<typename ExpectedPolicy, typename SinglePolicy>
+struct has_policy : tbb::internal::bool_constant<tbb::internal::is_same_type<ExpectedPolicy, SinglePolicy>::value> {};
+
+template<typename ExpectedPolicy, typename P>
+struct has_policy<ExpectedPolicy, Policy<P> > : has_policy<ExpectedPolicy, P> {};
+
+template<typename ExpectedPolicy, typename P1, typename P2>
+struct has_policy<ExpectedPolicy, Policy<P1, P2> > :
+    tbb::internal::bool_constant<has_policy<ExpectedPolicy, P1>::value || has_policy<ExpectedPolicy, P2>::value> {};
+
+#endif
+
 namespace graph_policy_namespace {
 
     struct rejecting { };
     struct reserving { };
     struct queueing  { };
+    struct lightweight  { };
 
     // K == type of field used for key-matching.  Each tag-matching port will be provided
     // functor that, given an object accepted by the port, will return the
@@ -52,11 +85,68 @@ namespace graph_policy_namespace {
     // old tag_matching join's new specifier
     typedef key_matching<tag_value> tag_matching;
 
+    // Aliases for Policy combinations
+    typedef interface11::internal::Policy<queueing, lightweight> queueing_lightweight;
+    typedef interface11::internal::Policy<rejecting, lightweight>  rejecting_lightweight;
+
 } // namespace graph_policy_namespace
 
 // -------------- function_body containers ----------------------
-
 //! A functor that takes no input and generates a value of type Output
+template< typename Output >
+class input_body : tbb::internal::no_assign {
+public:
+    virtual ~input_body() {}
+
+#if TBB_DEPRECATED_INPUT_NODE_BODY
+    virtual bool operator()(Output &output) = 0;
+#else
+    virtual Output operator()(flow_control& fc) = 0;
+#endif
+    virtual input_body* clone() = 0;
+};
+
+template <typename Body>
+void check_input_node_body_input_type_impl(Body) {
+    __TBB_STATIC_ASSERT((tbb::internal::is_same_type<typename tbb::internal::body_arg_detector<Body>::arg_type, flow_control&>::value),
+        "TBB Warning: input_node body requirements have been changed."
+        "To temporarily enforce deprecated API specify TBB_DEPRECATED_INPUT_NODE_BODY.");
+}
+
+template <typename Body>
+void check_input_node_body_input_type(Body) {
+    check_input_node_body_input_type_impl(&Body::operator());
+}
+
+template <typename ReturnType, typename T>
+void check_input_node_body_input_type(ReturnType(*)(T)) {
+    __TBB_STATIC_ASSERT((tbb::internal::is_same_type<T, flow_control&>::value),
+        "TBB Warning: input_node body requirements have been changed."
+        "To temporarily enforce deprecated API specify TBB_DEPRECATED_INPUT_NODE_BODY.");
+}
+
+//! The leaf for input_body
+template< typename Output, typename Body>
+class input_body_leaf : public input_body<Output> {
+public:
+    input_body_leaf( const Body &_body ) : body(_body) { }
+
+#if TBB_DEPRECATED_INPUT_NODE_BODY
+    bool operator()(Output &output) __TBB_override { return body( output ); }
+#else
+    Output operator()(flow_control& fc) __TBB_override {
+        check_input_node_body_input_type(body);
+        return body(fc);
+    }
+#endif
+    input_body_leaf* clone() __TBB_override {
+        return new input_body_leaf< Output, Body >(body);
+    }
+    Body get_body() { return body; }
+private:
+    Body body;
+};
+
 template< typename Output >
 class source_body : tbb::internal::no_assign {
 public:
@@ -70,10 +160,13 @@ template< typename Output, typename Body>
 class source_body_leaf : public source_body<Output> {
 public:
     source_body_leaf( const Body &_body ) : body(_body) { }
+
     bool operator()(Output &output) __TBB_override { return body( output ); }
+
     source_body_leaf* clone() __TBB_override {
         return new source_body_leaf< Output, Body >(body);
     }
+
     Body get_body() { return body; }
 private:
     Body body;
@@ -232,13 +325,20 @@ class type_to_key_function_body_leaf<Input,Output&,B> : public type_to_key_funct
 
 //! A task that calls a node's forward_task function
 template< typename NodeType >
-class forward_task_bypass : public task {
+class forward_task_bypass : public graph_task {
 
     NodeType &my_node;
 
 public:
 
-    forward_task_bypass( NodeType &n ) : my_node(n) {}
+    forward_task_bypass( NodeType &n
+#if __TBB_PREVIEW_FLOW_GRAPH_PRIORITIES
+                         , node_priority_t node_priority = no_priority
+    ) : graph_task(node_priority),
+#else
+    ) :
+#endif
+    my_node(n) {}
 
     task *execute() __TBB_override {
         task * new_task = my_node.forward_task();
@@ -250,14 +350,21 @@ class forward_task_bypass : public task {
 //! A task that calls a node's apply_body_bypass function, passing in an input of type Input
 //  return the task* unless it is SUCCESSFULLY_ENQUEUED, in which case return NULL
 template< typename NodeType, typename Input >
-class apply_body_task_bypass : public task {
+class apply_body_task_bypass : public graph_task {
 
     NodeType &my_node;
     Input my_input;
 
 public:
 
-    apply_body_task_bypass( NodeType &n, const Input &i ) : my_node(n), my_input(i) {}
+    apply_body_task_bypass( NodeType &n, const Input &i
+#if __TBB_PREVIEW_FLOW_GRAPH_PRIORITIES
+                            , node_priority_t node_priority = no_priority
+    ) : graph_task(node_priority),
+#else
+    ) :
+#endif
+        my_node(n), my_input(i) {}
 
     task *execute() __TBB_override {
         task * next_task = my_node.apply_body_bypass( my_input );
@@ -268,7 +375,7 @@ class apply_body_task_bypass : public task {
 
 //! A task that calls a node's apply_body_bypass function with no input
 template< typename NodeType >
-class source_task_bypass : public task {
+class source_task_bypass : public graph_task {
 
     NodeType &my_node;
 
@@ -291,18 +398,90 @@ struct empty_body {
     Output operator()( const Input & ) const { return Output(); }
 };
 
+template<typename T, typename DecrementType, typename DummyType = void>
+class decrementer;
+
+template<typename T, typename DecrementType>
+class decrementer<T, DecrementType,
+                  typename tbb::internal::enable_if<
+                      tbb::internal::is_integral<DecrementType>::value, void>::type
+                  > : public receiver<DecrementType>, tbb::internal::no_copy {
+    T* my_node;
+protected:
+
+    task* try_put_task( const DecrementType& value ) __TBB_override {
+        task* result = my_node->decrement_counter( value );
+        if( !result )
+            result = SUCCESSFULLY_ENQUEUED;
+        return result;
+    }
+
+    graph& graph_reference() const __TBB_override {
+        return my_node->my_graph;
+    }
+
+    template<typename U, typename V> friend class tbb::flow::interface11::limiter_node;
+    void reset_receiver( reset_flags f ) __TBB_override {
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
+        if (f & rf_clear_edges)
+            my_built_predecessors.clear();
+#else
+        tbb::internal::suppress_unused_warning( f );
+#endif
+    }
+
+public:
+    // Since decrementer does not make use of possibly unconstructed owner inside its
+    // constructor, my_node can be directly initialized with 'this' pointer passed from the
+    // owner, hence making method 'set_owner' needless.
+    decrementer() : my_node(NULL) {}
+    void set_owner( T *node ) { my_node = node; }
+
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
+    spin_mutex my_mutex;
+    //! The predecessor type for this node
+    typedef typename receiver<DecrementType>::predecessor_type predecessor_type;
+
+    typedef internal::edge_container<predecessor_type> built_predecessors_type;
+    typedef typename built_predecessors_type::edge_list_type predecessor_list_type;
+    built_predecessors_type &built_predecessors() __TBB_override { return my_built_predecessors; }
+
+    void internal_add_built_predecessor( predecessor_type &s) __TBB_override {
+        spin_mutex::scoped_lock l(my_mutex);
+        my_built_predecessors.add_edge( s );
+    }
+
+    void internal_delete_built_predecessor( predecessor_type &s) __TBB_override {
+        spin_mutex::scoped_lock l(my_mutex);
+        my_built_predecessors.delete_edge(s);
+    }
+
+    void copy_predecessors( predecessor_list_type &v) __TBB_override {
+        spin_mutex::scoped_lock l(my_mutex);
+        my_built_predecessors.copy_edges(v);
+    }
+
+    size_t predecessor_count() __TBB_override {
+        spin_mutex::scoped_lock l(my_mutex);
+        return my_built_predecessors.edge_count();
+    }
+protected:
+    built_predecessors_type my_built_predecessors;
+#endif  /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
+};
+
 template<typename T>
-class decrementer : public continue_receiver, tbb::internal::no_copy {
+class decrementer<T, continue_msg, void> : public continue_receiver, tbb::internal::no_copy {
 
     T *my_node;
 
     task *execute() __TBB_override {
-        return my_node->decrement_counter();
+        return my_node->decrement_counter( 1 );
     }
 
 protected:
 
-    graph& graph_reference() __TBB_override {
+    graph& graph_reference() const __TBB_override {
         return my_node->my_graph;
     }
 
@@ -310,7 +489,15 @@ class decrementer : public continue_receiver, tbb::internal::no_copy {
 
     typedef continue_msg input_type;
     typedef continue_msg output_type;
-    decrementer( int number_of_predecessors = 0 ) : continue_receiver( number_of_predecessors ) { }
+    decrementer( int number_of_predecessors = 0 )
+        : continue_receiver(
+            __TBB_FLOW_GRAPH_PRIORITY_ARG1(number_of_predecessors, tbb::flow::internal::no_priority)
+        )
+          // Since decrementer does not make use of possibly unconstructed owner inside its
+          // constructor, my_node can be directly initialized with 'this' pointer passed from the
+          // owner, hence making method 'set_owner' needless.
+        , my_node(NULL)
+    {}
     void set_owner( T *node ) { my_node = node; }
 };
 
diff --git a/src/tbb/include/tbb/internal/_flow_graph_cache_impl.h b/src/tbb/include/tbb/internal/_flow_graph_cache_impl.h
index 7fac84e8..b670ae65 100644
--- a/src/tbb/include/tbb/internal/_flow_graph_cache_impl.h
+++ b/src/tbb/include/tbb/internal/_flow_graph_cache_impl.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB__flow_graph_cache_impl_H
@@ -57,12 +53,12 @@ class node_cache {
 
     void clear() {
         while( !my_q.empty()) (void)my_q.pop();
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
         my_built_predecessors.clear();
 #endif
     }
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
     typedef edge_container<T> built_predecessors_type;
     built_predecessors_type &built_predecessors() { return my_built_predecessors; }
 
@@ -86,14 +82,14 @@ class node_cache {
         typename mutex_type::scoped_lock lock(my_mutex);
         return (size_t)(my_built_predecessors.edge_count());
     }
-#endif  /* TBB_PREVIEW_FLOW_GRAPH_FEATURES */
+#endif  /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
 
 protected:
 
     typedef M mutex_type;
     mutex_type my_mutex;
     std::queue< T * > my_q;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
     built_predecessors_type my_built_predecessors;
 #endif
 
@@ -189,7 +185,7 @@ class predecessor_cache : public node_cache< sender<T>, M > {
 
 protected:
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
     using node_cache< predecessor_type, M >::my_built_predecessors;
 #endif
     successor_type *my_owner;
@@ -290,7 +286,7 @@ class successor_cache : tbb::internal::no_copy {
     typedef sender<T> owner_type;
 #endif // __TBB_PREVIEW_ASYNC_MSG
     typedef std::list< pointer_type > successors_type;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
     edge_container<successor_type> my_built_successors;
 #endif
     successors_type my_successors;
@@ -298,7 +294,7 @@ class successor_cache : tbb::internal::no_copy {
     owner_type *my_owner;
 
 public:
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
     typedef typename edge_container<successor_type>::edge_list_type successor_list_type;
 
     edge_container<successor_type> &built_successors() { return my_built_successors; }
@@ -323,7 +319,7 @@ class successor_cache : tbb::internal::no_copy {
         return my_built_successors.edge_count();
     }
 
-#endif /* TBB_PREVIEW_FLOW_GRAPH_FEATURES */
+#endif /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
 
     successor_cache( ) : my_owner(NULL) {}
 
@@ -354,7 +350,7 @@ class successor_cache : tbb::internal::no_copy {
 
     void clear() {
         my_successors.clear();
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
         my_built_successors.clear();
 #endif
     }
@@ -365,11 +361,11 @@ class successor_cache : tbb::internal::no_copy {
  };  // successor_cache<T>
 
 //! An abstract cache of successors, specialized to continue_msg
-template<>
-class successor_cache< continue_msg > : tbb::internal::no_copy {
+template<typename M>
+class successor_cache< continue_msg, M > : tbb::internal::no_copy {
 protected:
 
-    typedef spin_rw_mutex mutex_type;
+    typedef M mutex_type;
     mutex_type my_mutex;
 
 #if __TBB_PREVIEW_ASYNC_MSG
@@ -381,7 +377,7 @@ class successor_cache< continue_msg > : tbb::internal::no_copy {
 #endif // __TBB_PREVIEW_ASYNC_MSG
     typedef std::list< pointer_type > successors_type;
     successors_type my_successors;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
     edge_container<successor_type> my_built_successors;
     typedef edge_container<successor_type>::edge_list_type successor_list_type;
 #endif
@@ -390,31 +386,31 @@ class successor_cache< continue_msg > : tbb::internal::no_copy {
 
 public:
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
 
     edge_container<successor_type> &built_successors() { return my_built_successors; }
 
     void internal_add_built_successor( successor_type &r) {
-        mutex_type::scoped_lock l(my_mutex, true);
+        typename mutex_type::scoped_lock l(my_mutex, true);
         my_built_successors.add_edge( r );
     }
 
     void internal_delete_built_successor( successor_type &r) {
-        mutex_type::scoped_lock l(my_mutex, true);
+        typename mutex_type::scoped_lock l(my_mutex, true);
         my_built_successors.delete_edge(r);
     }
 
     void copy_successors( successor_list_type &v) {
-        mutex_type::scoped_lock l(my_mutex, false);
+        typename mutex_type::scoped_lock l(my_mutex, false);
         my_built_successors.copy_edges(v);
     }
 
     size_t successor_count() {
-        mutex_type::scoped_lock l(my_mutex,false);
+        typename mutex_type::scoped_lock l(my_mutex,false);
         return my_built_successors.edge_count();
     }
 
-#endif  /* TBB_PREVIEW_FLOW_GRAPH_FEATURES */
+#endif  /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
 
     successor_cache( ) : my_owner(NULL) {}
 
@@ -423,7 +419,7 @@ class successor_cache< continue_msg > : tbb::internal::no_copy {
     virtual ~successor_cache() {}
 
     void register_successor( successor_type &r ) {
-        mutex_type::scoped_lock l(my_mutex, true);
+        typename mutex_type::scoped_lock l(my_mutex, true);
         my_successors.push_back( &r );
         if ( my_owner && r.is_continue_receiver() ) {
             r.register_predecessor( *my_owner );
@@ -431,7 +427,7 @@ class successor_cache< continue_msg > : tbb::internal::no_copy {
     }
 
     void remove_successor( successor_type &r ) {
-        mutex_type::scoped_lock l(my_mutex, true);
+        typename mutex_type::scoped_lock l(my_mutex, true);
         for ( successors_type::iterator i = my_successors.begin();
               i != my_successors.end(); ++i ) {
             if ( *i == & r ) {
@@ -446,13 +442,13 @@ class successor_cache< continue_msg > : tbb::internal::no_copy {
     }
 
     bool empty() {
-        mutex_type::scoped_lock l(my_mutex, false);
+        typename mutex_type::scoped_lock l(my_mutex, false);
         return my_successors.empty();
     }
 
     void clear() {
         my_successors.clear();
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
         my_built_successors.clear();
 #endif
     }
@@ -508,6 +504,40 @@ class broadcast_cache : public successor_cache<T, M> {
         return last_task;
     }
 
+    // call try_put_task and return list of received tasks
+#if __TBB_PREVIEW_ASYNC_MSG
+    template<typename X>
+    bool gather_successful_try_puts( const X &t, task_list &tasks ) {
+#else
+    bool gather_successful_try_puts( const T &t, task_list &tasks ) {
+#endif // __TBB_PREVIEW_ASYNC_MSG
+        bool upgraded = true;
+        bool is_at_least_one_put_successful = false;
+        typename mutex_type::scoped_lock l(this->my_mutex, upgraded);
+        typename successors_type::iterator i = this->my_successors.begin();
+        while ( i != this->my_successors.end() ) {
+            task * new_task = (*i)->try_put_task(t);
+            if(new_task) {
+                ++i;
+                if(new_task != SUCCESSFULLY_ENQUEUED) {
+                    tasks.push_back(*new_task);
+                }
+                is_at_least_one_put_successful = true;
+            }
+            else {  // failed
+                if ( (*i)->register_predecessor(*this->my_owner) ) {
+                    if (!upgraded) {
+                        l.upgrade_to_writer();
+                        upgraded = true;
+                    }
+                    i = this->my_successors.erase(i);
+                } else {
+                    ++i;
+                }
+            }
+        }
+        return is_at_least_one_put_successful;
+    }
 };
 
 //! A cache of successors that are put in a round-robin fashion
diff --git a/src/tbb/include/tbb/internal/_flow_graph_impl.h b/src/tbb/include/tbb/internal/_flow_graph_impl.h
index ffdd57be..7859e944 100644
--- a/src/tbb/include/tbb/internal/_flow_graph_impl.h
+++ b/src/tbb/include/tbb/internal/_flow_graph_impl.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_flow_graph_impl_H
@@ -26,6 +22,10 @@
 #include "../task_arena.h"
 #include "../flow_graph_abstractions.h"
 
+#if __TBB_PREVIEW_FLOW_GRAPH_PRIORITIES
+#include "../concurrent_priority_queue.h"
+#endif
+
 #include <list>
 
 #if TBB_DEPRECATED_FLOW_ENQUEUE
@@ -34,23 +34,62 @@
 #define FLOW_SPAWN(a) tbb::task::spawn((a))
 #endif
 
+#if __TBB_PREVIEW_FLOW_GRAPH_PRIORITIES
+#define __TBB_FLOW_GRAPH_PRIORITY_EXPR( expr ) expr
+#define __TBB_FLOW_GRAPH_PRIORITY_ARG0( priority ) , priority
+#define __TBB_FLOW_GRAPH_PRIORITY_ARG1( arg1, priority ) arg1, priority
+#else
+#define __TBB_FLOW_GRAPH_PRIORITY_EXPR( expr )
+#define __TBB_FLOW_GRAPH_PRIORITY_ARG0( priority )
+#define __TBB_FLOW_GRAPH_PRIORITY_ARG1( arg1, priority ) arg1
+#endif // __TBB_PREVIEW_FLOW_GRAPH_PRIORITIES
+
+#if TBB_DEPRECATED_LIMITER_NODE_CONSTRUCTOR
+#define __TBB_DEPRECATED_LIMITER_EXPR( expr ) expr
+#define __TBB_DEPRECATED_LIMITER_ARG2( arg1, arg2 ) arg1, arg2
+#define __TBB_DEPRECATED_LIMITER_ARG4( arg1, arg2, arg3, arg4 ) arg1, arg3, arg4
+#else
+#define __TBB_DEPRECATED_LIMITER_EXPR( expr )
+#define __TBB_DEPRECATED_LIMITER_ARG2( arg1, arg2 ) arg1
+#define __TBB_DEPRECATED_LIMITER_ARG4( arg1, arg2, arg3, arg4 ) arg1, arg2
+#endif // TBB_DEPRECATED_LIMITER_NODE_CONSTRUCTOR
+
 namespace tbb {
 namespace flow {
 
 namespace internal {
 static tbb::task * const SUCCESSFULLY_ENQUEUED = (task *)-1;
+#if __TBB_PREVIEW_FLOW_GRAPH_PRIORITIES
+typedef unsigned int node_priority_t;
+static const node_priority_t no_priority = node_priority_t(0);
+#endif
 }
 
 namespace interface10 {
+class graph;
+}
+
+namespace interface11 {
 
 using tbb::flow::internal::SUCCESSFULLY_ENQUEUED;
 
-class graph;
+#if __TBB_PREVIEW_FLOW_GRAPH_PRIORITIES
+using tbb::flow::internal::node_priority_t;
+using tbb::flow::internal::no_priority;
+//! Base class for tasks generated by graph nodes.
+struct graph_task : public task {
+    graph_task( node_priority_t node_priority = no_priority ) : priority( node_priority ) {}
+    node_priority_t priority;
+};
+#else
+typedef task graph_task;
+#endif /* __TBB_PREVIEW_FLOW_GRAPH_PRIORITIES */
+
 class graph_node;
 
 template <typename GraphContainerType, typename GraphNodeType>
 class graph_iterator {
-    friend class graph;
+    friend class tbb::flow::interface10::graph;
     friend class graph_node;
 public:
     typedef size_t size_type;
@@ -124,24 +163,65 @@ enum reset_flags {
 
 namespace internal {
 
-void activate_graph(graph& g);
-void deactivate_graph(graph& g);
-bool is_graph_active(graph& g);
-void spawn_in_graph_arena(graph& g, tbb::task& arena_task);
-void add_task_to_graph_reset_list(graph& g, tbb::task *tp);
-template<typename F> void execute_in_graph_arena(graph& g, F& f);
+void activate_graph(tbb::flow::interface10::graph& g);
+void deactivate_graph(tbb::flow::interface10::graph& g);
+bool is_graph_active(tbb::flow::interface10::graph& g);
+tbb::task& prioritize_task(tbb::flow::interface10::graph& g, tbb::task& arena_task);
+void spawn_in_graph_arena(tbb::flow::interface10::graph& g, tbb::task& arena_task);
+void enqueue_in_graph_arena(tbb::flow::interface10::graph &g, tbb::task& arena_task);
+void add_task_to_graph_reset_list(tbb::flow::interface10::graph& g, tbb::task *tp);
+
+#if __TBB_PREVIEW_FLOW_GRAPH_PRIORITIES
+struct graph_task_comparator {
+    bool operator()(const graph_task* left, const graph_task* right) {
+        return left->priority < right->priority;
+    }
+};
+
+typedef tbb::concurrent_priority_queue<graph_task*, graph_task_comparator> graph_task_priority_queue_t;
+
+class priority_task_selector : public task {
+public:
+    priority_task_selector(graph_task_priority_queue_t& priority_queue)
+        : my_priority_queue(priority_queue) {}
+    task* execute() __TBB_override {
+        graph_task* t = NULL;
+        bool result = my_priority_queue.try_pop(t);
+        __TBB_ASSERT_EX( result, "Number of critical tasks for scheduler and tasks"
+                         " in graph's priority queue mismatched" );
+        __TBB_ASSERT( t && t != SUCCESSFULLY_ENQUEUED,
+                      "Incorrect task submitted to graph priority queue" );
+        __TBB_ASSERT( t->priority != tbb::flow::internal::no_priority,
+                      "Tasks from graph's priority queue must have priority" );
+        task* t_next = t->execute();
+        task::destroy(*t);
+        return t_next;
+    }
+private:
+    graph_task_priority_queue_t& my_priority_queue;
+};
+#endif /* __TBB_PREVIEW_FLOW_GRAPH_PRIORITIES */
 
 }
 
+} // namespace interfaceX
+namespace interface10 {
 //! The graph class
 /** This class serves as a handle to the graph */
 class graph : tbb::internal::no_copy, public tbb::flow::graph_proxy {
-    friend class graph_node;
+    friend class tbb::flow::interface11::graph_node;
 
     template< typename Body >
-    class run_task : public task {
+    class run_task : public tbb::flow::interface11::graph_task {
     public:
-        run_task(Body& body) : my_body(body) {}
+        run_task(Body& body
+#if __TBB_PREVIEW_FLOW_GRAPH_PRIORITIES
+                 , tbb::flow::interface11::node_priority_t node_priority = tbb::flow::interface11::no_priority
+        ) : tbb::flow::interface11::graph_task(node_priority),
+#else
+        ) :
+#endif
+        my_body(body) { }
         tbb::task *execute() __TBB_override {
             my_body();
             return NULL;
@@ -151,12 +231,12 @@ class graph : tbb::internal::no_copy, public tbb::flow::graph_proxy {
     };
 
     template< typename Receiver, typename Body >
-    class run_and_put_task : public task {
+    class run_and_put_task : public tbb::flow::interface11::graph_task {
     public:
         run_and_put_task(Receiver &r, Body& body) : my_receiver(r), my_body(body) {}
         tbb::task *execute() __TBB_override {
             tbb::task *res = my_receiver.try_put_task(my_body());
-            if (res == SUCCESSFULLY_ENQUEUED) res = NULL;
+            if (res == tbb::flow::interface11::SUCCESSFULLY_ENQUEUED) res = NULL;
             return res;
         }
     private:
@@ -206,23 +286,17 @@ class graph : tbb::internal::no_copy, public tbb::flow::graph_proxy {
 
     //! Destroys the graph.
     /** Calls wait_for_all, then destroys the root task and context. */
-    ~graph() {
-        wait_for_all();
-        my_root_task->set_ref_count(0);
-        tbb::task::destroy(*my_root_task);
-        if (own_context) delete my_context;
-        delete my_task_arena;
-    }
+    ~graph();
 
 #if TBB_PREVIEW_FLOW_GRAPH_TRACE
     void set_name(const char *name);
 #endif
 
-    void increment_wait_count() {
+    __TBB_DEPRECATED void increment_wait_count() {
         reserve_wait();
     }
 
-    void decrement_wait_count() {
+    __TBB_DEPRECATED void decrement_wait_count() {
         release_wait();
     }
 
@@ -240,8 +314,8 @@ class graph : tbb::internal::no_copy, public tbb::flow::graph_proxy {
     /** The task is spawned as a child of the graph. This is useful for running tasks
     that need to block a wait_for_all() on the graph.  For example a one-off source. */
     template< typename Receiver, typename Body >
-    void run(Receiver &r, Body body) {
-        if (internal::is_graph_active(*this)) {
+    __TBB_DEPRECATED void run(Receiver &r, Body body) {
+        if (tbb::flow::interface11::internal::is_graph_active(*this)) {
             task* rtask = new (task::allocate_additional_child_of(*root_task()))
                 run_and_put_task< Receiver, Body >(r, body);
             my_task_arena->execute(spawn_functor(*rtask));
@@ -252,8 +326,8 @@ class graph : tbb::internal::no_copy, public tbb::flow::graph_proxy {
     /** The task is spawned as a child of the graph. This is useful for running tasks
     that need to block a wait_for_all() on the graph. For example a one-off source. */
     template< typename Body >
-    void run(Body body) {
-        if (internal::is_graph_active(*this)) {
+    __TBB_DEPRECATED void run(Body body) {
+        if (tbb::flow::interface11::internal::is_graph_active(*this)) {
             task* rtask = new (task::allocate_additional_child_of(*root_task())) run_task< Body >(body);
             my_task_arena->execute(spawn_functor(*rtask));
         }
@@ -269,7 +343,9 @@ class graph : tbb::internal::no_copy, public tbb::flow::graph_proxy {
             try {
 #endif
                 my_task_arena->execute(wait_functor(my_root_task));
+#if __TBB_TASK_GROUP_CONTEXT
                 cancelled = my_context->is_group_execution_cancelled();
+#endif
 #if TBB_USE_EXCEPTIONS
             }
             catch (...) {
@@ -280,99 +356,123 @@ class graph : tbb::internal::no_copy, public tbb::flow::graph_proxy {
                 throw;
             }
 #endif
+#if __TBB_TASK_GROUP_CONTEXT
             // TODO: the "if" condition below is just a work-around to support the concurrent wait
             // mode. The cancellation and exception mechanisms are still broken in this mode.
             // Consider using task group not to re-implement the same functionality.
             if (!(my_context->traits() & tbb::task_group_context::concurrent_wait)) {
                 my_context->reset();  // consistent with behavior in catch()
+#endif
                 my_root_task->set_ref_count(1);
+#if __TBB_TASK_GROUP_CONTEXT
             }
+#endif
         }
     }
 
     //! Returns the root task of the graph
-    tbb::task * root_task() {
+    __TBB_DEPRECATED tbb::task * root_task() {
         return my_root_task;
     }
 
     // ITERATORS
     template<typename C, typename N>
-    friend class graph_iterator;
+    friend class tbb::flow::interface11::graph_iterator;
 
     // Graph iterator typedefs
-    typedef graph_iterator<graph, graph_node> iterator;
-    typedef graph_iterator<const graph, const graph_node> const_iterator;
+    typedef tbb::flow::interface11::graph_iterator<graph, tbb::flow::interface11::graph_node> iterator;
+    typedef tbb::flow::interface11::graph_iterator<const graph, const tbb::flow::interface11::graph_node> const_iterator;
 
     // Graph iterator constructors
     //! start iterator
-    iterator begin() { return iterator(this, true); }
+    iterator begin();
     //! end iterator
-    iterator end() { return iterator(this, false); }
+    iterator end();
     //! start const iterator
-    const_iterator begin() const { return const_iterator(this, true); }
+    const_iterator begin() const;
     //! end const iterator
-    const_iterator end() const { return const_iterator(this, false); }
+    const_iterator end() const;
     //! start const iterator
-    const_iterator cbegin() const { return const_iterator(this, true); }
+    const_iterator cbegin() const;
     //! end const iterator
-    const_iterator cend() const { return const_iterator(this, false); }
+    const_iterator cend() const;
 
     //! return status of graph execution
     bool is_cancelled() { return cancelled; }
     bool exception_thrown() { return caught_exception; }
 
     // thread-unsafe state reset.
-    void reset(reset_flags f = rf_reset_protocol);
+    void reset(tbb::flow::interface11::reset_flags f = tbb::flow::interface11::rf_reset_protocol);
 
 private:
     tbb::task *my_root_task;
+#if __TBB_TASK_GROUP_CONTEXT
     tbb::task_group_context *my_context;
+#endif
     bool own_context;
     bool cancelled;
     bool caught_exception;
     bool my_is_active;
     task_list_type my_reset_task_list;
 
-    graph_node *my_nodes, *my_nodes_last;
+    tbb::flow::interface11::graph_node *my_nodes, *my_nodes_last;
 
     tbb::spin_mutex nodelist_mutex;
-    void register_node(graph_node *n);
-    void remove_node(graph_node *n);
+    void register_node(tbb::flow::interface11::graph_node *n);
+    void remove_node(tbb::flow::interface11::graph_node *n);
 
     tbb::task_arena* my_task_arena;
 
-    friend void internal::activate_graph(graph& g);
-    friend void internal::deactivate_graph(graph& g);
-    friend bool internal::is_graph_active(graph& g);
-    friend void internal::spawn_in_graph_arena(graph& g, tbb::task& arena_task);
-    friend void internal::add_task_to_graph_reset_list(graph& g, tbb::task *tp);
-    template<typename F> friend void internal::execute_in_graph_arena(graph& g, F& f);
+#if __TBB_PREVIEW_FLOW_GRAPH_PRIORITIES
+    tbb::flow::interface11::internal::graph_task_priority_queue_t my_priority_queue;
+#endif
+
+    friend void tbb::flow::interface11::internal::activate_graph(graph& g);
+    friend void tbb::flow::interface11::internal::deactivate_graph(graph& g);
+    friend bool tbb::flow::interface11::internal::is_graph_active(graph& g);
+    friend tbb::task& tbb::flow::interface11::internal::prioritize_task(graph& g, tbb::task& arena_task);
+    friend void tbb::flow::interface11::internal::spawn_in_graph_arena(graph& g, tbb::task& arena_task);
+    friend void tbb::flow::interface11::internal::enqueue_in_graph_arena(graph &g, tbb::task& arena_task);
+    friend void tbb::flow::interface11::internal::add_task_to_graph_reset_list(graph& g, tbb::task *tp);
 
     friend class tbb::interface7::internal::task_arena_base;
 
 };  // class graph
+} // namespace interface10
+
+namespace interface11 {
+
+using tbb::flow::interface10::graph;
+
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+namespace internal{
+class get_graph_helper;
+}
+#endif
 
 //! The base of all graph nodes.
 class graph_node : tbb::internal::no_copy {
     friend class graph;
     template<typename C, typename N>
     friend class graph_iterator;
+
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+    friend class internal::get_graph_helper;
+#endif
+
 protected:
     graph& my_graph;
     graph_node *next, *prev;
 public:
-    explicit graph_node(graph& g) : my_graph(g) {
-        my_graph.register_node(this);
-    }
-    virtual ~graph_node() {
-        my_graph.remove_node(this);
-    }
+    explicit graph_node(graph& g);
+
+    virtual ~graph_node();
 
 #if TBB_PREVIEW_FLOW_GRAPH_TRACE
     virtual void set_name(const char *name) = 0;
 #endif
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
     virtual void extract() = 0;
 #endif
 
@@ -395,19 +495,43 @@ inline bool is_graph_active(graph& g) {
     return g.my_is_active;
 }
 
-//! Executes custom functor inside graph arena
-template<typename F>
-inline void execute_in_graph_arena(graph& g, F& f) {
-    if (is_graph_active(g)) {
-        __TBB_ASSERT(g.my_task_arena && g.my_task_arena->is_active(), NULL);
-        g.my_task_arena->execute(f);
+#if __TBB_PREVIEW_FLOW_GRAPH_PRIORITIES
+inline tbb::task& prioritize_task(graph& g, tbb::task& t) {
+    task* critical_task = &t;
+    // TODO: change flow graph's interfaces to work with graph_task type instead of tbb::task.
+    graph_task* gt = static_cast<graph_task*>(&t);
+    if( gt->priority != no_priority ) {
+        //! Non-preemptive priority pattern. The original task is submitted as a work item to the
+        //! priority queue, and a new critical task is created to take and execute a work item with
+        //! the highest known priority. The reference counting responsibility is transferred (via
+        //! allocate_continuation) to the new task.
+        critical_task = new( gt->allocate_continuation() ) priority_task_selector(g.my_priority_queue);
+        tbb::internal::make_critical( *critical_task );
+        g.my_priority_queue.push(gt);
     }
+    return *critical_task;
+}
+#else
+inline tbb::task& prioritize_task(graph&, tbb::task& t) {
+    return t;
 }
+#endif /* __TBB_PREVIEW_FLOW_GRAPH_PRIORITIES */
 
 //! Spawns a task inside graph arena
 inline void spawn_in_graph_arena(graph& g, tbb::task& arena_task) {
-    graph::spawn_functor s_fn(arena_task);
-    execute_in_graph_arena(g, s_fn);
+    if (is_graph_active(g)) {
+        graph::spawn_functor s_fn(prioritize_task(g, arena_task));
+        __TBB_ASSERT(g.my_task_arena && g.my_task_arena->is_active(), NULL);
+        g.my_task_arena->execute(s_fn);
+    }
+}
+
+//! Enqueues a task inside graph arena
+inline void enqueue_in_graph_arena(graph &g, tbb::task& arena_task) {
+    if (is_graph_active(g)) {
+        __TBB_ASSERT( g.my_task_arena && g.my_task_arena->is_active(), "Is graph's arena initialized and active?" );
+        task::enqueue(prioritize_task(g, arena_task), *g.my_task_arena);
+    }
 }
 
 inline void add_task_to_graph_reset_list(graph& g, tbb::task *tp) {
@@ -416,7 +540,7 @@ inline void add_task_to_graph_reset_list(graph& g, tbb::task *tp) {
 
 } // namespace internal
 
-} // namespace interface10
+} // namespace interfaceX
 } // namespace flow
 } // namespace tbb
 
diff --git a/src/tbb/include/tbb/internal/_flow_graph_indexer_impl.h b/src/tbb/include/tbb/internal/_flow_graph_indexer_impl.h
index c8d4fd4e..2900db91 100644
--- a/src/tbb/include/tbb/internal/_flow_graph_indexer_impl.h
+++ b/src/tbb/include/tbb/internal/_flow_graph_indexer_impl.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB__flow_graph_indexer_impl_H
@@ -54,7 +50,7 @@ namespace internal {
             indexer_helper<TupleTypes,N-1>::reset_inputs(my_input, f);
             tbb::flow::get<N-1>(my_input).reset_receiver(f);
         }
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
         template<typename InputTuple>
         static inline void extract(InputTuple &my_input) {
             indexer_helper<TupleTypes,N-1>::extract(my_input);
@@ -75,7 +71,7 @@ namespace internal {
         static inline void reset_inputs(InputTuple &my_input, reset_flags f) {
             tbb::flow::get<0>(my_input).reset_receiver(f);
         }
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
         template<typename InputTuple>
         static inline void extract(InputTuple &my_input) {
             tbb::flow::get<0>(my_input).extract_receiver();
@@ -89,24 +85,24 @@ namespace internal {
         void* my_indexer_ptr;
         typedef task* (* forward_function_ptr)(T const &, void* );
         forward_function_ptr my_try_put_task;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
         spin_mutex my_pred_mutex;
         typedef typename receiver<T>::built_predecessors_type built_predecessors_type;
         built_predecessors_type my_built_predecessors;
-#endif  /* TBB_PREVIEW_FLOW_GRAPH_FEATURES */
+#endif  /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
         graph* my_graph;
     public:
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
         indexer_input_port() : my_pred_mutex(), my_graph(NULL) {}
         indexer_input_port( const indexer_input_port & other) : receiver<T>(), my_pred_mutex(), my_graph(other.my_graph) {
         }
-#endif  /* TBB_PREVIEW_FLOW_GRAPH_FEATURES */
+#endif  /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
         void set_up(void* p, forward_function_ptr f, graph& g) {
             my_indexer_ptr = p;
             my_try_put_task = f;
             my_graph = &g;
         }
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
         typedef typename receiver<T>::predecessor_list_type predecessor_list_type;
         typedef typename receiver<T>::predecessor_type predecessor_type;
 
@@ -128,7 +124,7 @@ namespace internal {
             spin_mutex::scoped_lock l(my_pred_mutex);
             my_built_predecessors.copy_edges(v);
         }
-#endif  /* TBB_PREVIEW_FLOW_GRAPH_FEATURES */
+#endif  /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
     protected:
         template< typename R, typename B > friend class run_and_put_task;
         template<typename X, typename Y> friend class internal::broadcast_cache;
@@ -137,18 +133,18 @@ namespace internal {
             return my_try_put_task(v, my_indexer_ptr);
         }
 
-        graph& graph_reference() __TBB_override {
+        graph& graph_reference() const __TBB_override {
             return *my_graph;
         }
 
     public:
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
         void reset_receiver(reset_flags f) __TBB_override { if(f&rf_clear_edges) my_built_predecessors.clear(); }
 #else
         void reset_receiver(reset_flags /*f*/) __TBB_override { }
 #endif
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
         void extract_receiver() { my_built_predecessors.receiver_extract(*this); }
 #endif
     };
@@ -180,7 +176,7 @@ namespace internal {
         typedef StructTypes tuple_types;
         typedef typename sender<output_type>::successor_type successor_type;
         typedef indexer_node_FE<InputTuple, output_type,StructTypes> input_ports_type;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
         typedef typename sender<output_type>::built_successors_type built_successors_type;
         typedef typename sender<output_type>::successor_list_type successor_list_type;
 #endif
@@ -188,7 +184,7 @@ namespace internal {
     private:
         // ----------- Aggregator ------------
         enum op_type { reg_succ, rem_succ, try__put_task
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
             , add_blt_succ, del_blt_succ,
              blt_succ_cnt, blt_succ_cpy
 #endif
@@ -202,7 +198,7 @@ namespace internal {
                 output_type const *my_arg;
                 successor_type *my_succ;
                 task *bypass_t;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
                 size_t cnt_val;
                 successor_list_type *succv;
 #endif
@@ -239,7 +235,7 @@ namespace internal {
                         __TBB_store_with_release(current->status, SUCCEEDED);  // return of try_put_task actual return value
                     }
                     break;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
                 case add_blt_succ:
                     my_successors.internal_add_built_successor(*(current->my_succ));
                     __TBB_store_with_release(current->status, SUCCEEDED);
@@ -256,7 +252,7 @@ namespace internal {
                     my_successors.copy_successors(*(current->succv));
                     __TBB_store_with_release(current->status, SUCCEEDED);
                     break;
-#endif  /* TBB_PREVIEW_FLOW_GRAPH_FEATURES */
+#endif  /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
                 }
             }
         }
@@ -292,7 +288,7 @@ namespace internal {
             return op_data.bypass_t;
         }
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
 
         built_successors_type &built_successors() __TBB_override { return my_successors.built_successors(); }
 
@@ -321,7 +317,7 @@ namespace internal {
             my_successors.built_successors().sender_extract(*this);
             indexer_helper<StructTypes,N>::extract(this->my_inputs);
         }
-#endif /* TBB_PREVIEW_FLOW_GRAPH_FEATURES */
+#endif /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
     protected:
         void reset_node(reset_flags f) __TBB_override {
             if(f & rf_clear_edges) {
diff --git a/src/tbb/include/tbb/internal/_flow_graph_item_buffer_impl.h b/src/tbb/include/tbb/internal/_flow_graph_item_buffer_impl.h
index 85d2686d..e5a97d1c 100644
--- a/src/tbb/include/tbb/internal/_flow_graph_item_buffer_impl.h
+++ b/src/tbb/include/tbb/internal/_flow_graph_item_buffer_impl.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB__flow_graph_item_buffer_impl_H
@@ -48,8 +44,7 @@ namespace internal {
     protected:
         typedef size_t size_type;
         typedef typename aligned_pair<item_type, buffer_item_state>::type buffer_item_type;
-        typedef typename A::template rebind<buffer_item_type>::other allocator_type;
-
+        typedef typename tbb::internal::allocator_rebind<A, buffer_item_type>::type allocator_type;
         buffer_item_type *my_array;
         size_type my_array_size;
         static const size_type initial_buffer_size = 4;
@@ -144,7 +139,7 @@ namespace internal {
             return get_my_item(my_tail - 1);
         }
 
-        // following methods are for reservation of the front of a bufffer.
+        // following methods are for reservation of the front of a buffer.
         void reserve_item(size_type i) { __TBB_ASSERT(my_item_valid(i) && !my_item_reserved(i), "item cannot be reserved"); item(i).second = reserved_item; }
         void release_item(size_type i) { __TBB_ASSERT(my_item_reserved(i), "item is not reserved"); item(i).second = has_item; }
 
diff --git a/src/tbb/include/tbb/internal/_flow_graph_join_impl.h b/src/tbb/include/tbb/internal/_flow_graph_join_impl.h
index 8fc32a9a..16837c7a 100644
--- a/src/tbb/include/tbb/internal/_flow_graph_join_impl.h
+++ b/src/tbb/include/tbb/internal/_flow_graph_join_impl.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB__flow_graph_join_impl_H
@@ -126,7 +122,7 @@ namespace internal {
             tbb::flow::get<N-1>(my_input).reset_receiver(f);
         }
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
         template<typename InputTuple>
         static inline void extract_inputs(InputTuple &my_input) {
             join_helper<N-1>::extract_inputs(my_input);
@@ -200,7 +196,7 @@ namespace internal {
             tbb::flow::get<0>(my_input).reset_receiver(f);
         }
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
         template<typename InputTuple>
         static inline void extract_inputs(InputTuple &my_input) {
             tbb::flow::get<0>(my_input).extract_receiver();
@@ -214,18 +210,17 @@ namespace internal {
     public:
         typedef T input_type;
         typedef typename receiver<input_type>::predecessor_type predecessor_type;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
         typedef typename receiver<input_type>::predecessor_list_type predecessor_list_type;
         typedef typename receiver<input_type>::built_predecessors_type built_predecessors_type;
 #endif
     private:
         // ----------- Aggregator ------------
         enum op_type { reg_pred, rem_pred, res_item, rel_res, con_res
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
             , add_blt_pred, del_blt_pred, blt_pred_cnt, blt_pred_cpy
 #endif
         };
-        enum op_stat {WAIT=0, SUCCEEDED, FAILED};
         typedef reserving_port<T> class_type;
 
         class reserving_port_operation : public aggregated_operation<reserving_port_operation> {
@@ -234,7 +229,7 @@ namespace internal {
             union {
                 T *my_arg;
                 predecessor_type *my_pred;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
                 size_t cnt_val;
                 predecessor_list_type *plist;
 #endif
@@ -294,7 +289,7 @@ namespace internal {
                     my_predecessors.try_consume( );
                     __TBB_store_with_release(current->status, SUCCEEDED);
                     break;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
                 case add_blt_pred:
                     my_predecessors.internal_add_built_predecessor(*(current->my_pred));
                     __TBB_store_with_release(current->status, SUCCEEDED);
@@ -311,7 +306,7 @@ namespace internal {
                     my_predecessors.copy_predecessors(*(current->plist));
                     __TBB_store_with_release(current->status, SUCCEEDED);
                     break;
-#endif  /* TBB_PREVIEW_FLOW_GRAPH_FEATURES */
+#endif  /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
                 }
             }
         }
@@ -324,7 +319,7 @@ namespace internal {
             return NULL;
         }
 
-        graph& graph_reference() __TBB_override {
+        graph& graph_reference() const __TBB_override {
             return my_join->graph_ref;
         }
 
@@ -382,7 +377,7 @@ namespace internal {
             my_aggregator.execute(&op_data);
         }
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
         built_predecessors_type &built_predecessors() __TBB_override { return my_predecessors.built_predecessors(); }
         void internal_add_built_predecessor(predecessor_type &src) __TBB_override {
             reserving_port_operation op_data(src, add_blt_pred);
@@ -410,7 +405,7 @@ namespace internal {
             my_predecessors.built_predecessors().receiver_extract(*this);
         }
 
-#endif  /* TBB_PREVIEW_FLOW_GRAPH_FEATURES */
+#endif  /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
 
         void reset_receiver( reset_flags f) __TBB_override {
             if(f & rf_clear_edges) my_predecessors.clear();
@@ -421,6 +416,10 @@ namespace internal {
         }
 
     private:
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+        friend class get_graph_helper;
+#endif
+
         forwarding_base *my_join;
         reservable_predecessor_cache< T, null_mutex > my_predecessors;
         bool reserved;
@@ -433,7 +432,7 @@ namespace internal {
         typedef T input_type;
         typedef typename receiver<input_type>::predecessor_type predecessor_type;
         typedef queueing_port<T> class_type;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
         typedef typename receiver<input_type>::built_predecessors_type built_predecessors_type;
         typedef typename receiver<input_type>::predecessor_list_type predecessor_list_type;
 #endif
@@ -441,18 +440,17 @@ namespace internal {
     // ----------- Aggregator ------------
     private:
         enum op_type { get__item, res_port, try__put_task
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
             , add_blt_pred, del_blt_pred, blt_pred_cnt, blt_pred_cpy
 #endif
         };
-        enum op_stat {WAIT=0, SUCCEEDED, FAILED};
 
         class queueing_port_operation : public aggregated_operation<queueing_port_operation> {
         public:
             char type;
             T my_val;
             T *my_arg;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
             predecessor_type *pred;
             size_t cnt_val;
             predecessor_list_type *plist;
@@ -513,7 +511,7 @@ namespace internal {
                     }
                     __TBB_store_with_release(current->status, SUCCEEDED);
                     break;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
                 case add_blt_pred:
                     my_built_predecessors.add_edge(*(current->pred));
                     __TBB_store_with_release(current->status, SUCCEEDED);
@@ -530,7 +528,7 @@ namespace internal {
                     my_built_predecessors.copy_edges(*(current->plist));
                     __TBB_store_with_release(current->status, SUCCEEDED);
                     break;
-#endif  /* TBB_PREVIEW_FLOW_GRAPH_FEATURES */
+#endif  /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
                 }
             }
         }
@@ -548,7 +546,7 @@ namespace internal {
             return op_data.bypass_t;
         }
 
-        graph& graph_reference() __TBB_override {
+        graph& graph_reference() const __TBB_override {
             return my_join->graph_ref;
         }
 
@@ -585,7 +583,7 @@ namespace internal {
             return;
         }
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
         built_predecessors_type &built_predecessors() __TBB_override { return my_built_predecessors; }
 
         void internal_add_built_predecessor(predecessor_type &p) __TBB_override {
@@ -616,20 +614,24 @@ namespace internal {
             item_buffer<T>::reset();
             my_built_predecessors.receiver_extract(*this);
         }
-#endif  /* TBB_PREVIEW_FLOW_GRAPH_FEATURES */
+#endif  /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
 
         void reset_receiver(reset_flags f) __TBB_override {
             tbb::internal::suppress_unused_warning(f);
             item_buffer<T>::reset();
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
             if (f & rf_clear_edges)
                 my_built_predecessors.clear();
 #endif
         }
 
     private:
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+        friend class get_graph_helper;
+#endif
+
         forwarding_base *my_join;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
         edge_container<predecessor_type> my_built_predecessors;
 #endif
     };  // queueing_port
@@ -667,7 +669,7 @@ namespace internal {
         typedef typename TraitsType::TtoK type_to_key_func_type;
         typedef typename TraitsType::KHash hash_compare_type;
         typedef hash_buffer< key_type, input_type, type_to_key_func_type, hash_compare_type > buffer_type;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
         typedef typename receiver<input_type>::built_predecessors_type built_predecessors_type;
         typedef typename receiver<input_type>::predecessor_list_type predecessor_list_type;
 #endif
@@ -675,18 +677,17 @@ namespace internal {
 // ----------- Aggregator ------------
     private:
         enum op_type { try__put, get__item, res_port
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
            , add_blt_pred, del_blt_pred, blt_pred_cnt, blt_pred_cpy
 #endif
         };
-        enum op_stat {WAIT=0, SUCCEEDED, FAILED};
 
         class key_matching_port_operation : public aggregated_operation<key_matching_port_operation> {
         public:
             char type;
             input_type my_val;
             input_type *my_arg;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
             predecessor_type *pred;
             size_t cnt_val;
             predecessor_list_type *plist;
@@ -729,7 +730,7 @@ namespace internal {
                     this->delete_with_key(my_join->current_key);
                     __TBB_store_with_release(current->status, SUCCEEDED);
                     break;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
                 case add_blt_pred:
                     my_built_predecessors.add_edge(*(current->pred));
                     __TBB_store_with_release(current->status, SUCCEEDED);
@@ -767,7 +768,7 @@ namespace internal {
             return rtask;
         }
 
-        graph& graph_reference() __TBB_override {
+        graph& graph_reference() const __TBB_override {
             return my_join->graph_ref;
         }
 
@@ -801,7 +802,7 @@ namespace internal {
             return op_data.status == SUCCEEDED;
         }
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
         built_predecessors_type &built_predecessors() __TBB_override { return my_built_predecessors; }
 
         void internal_add_built_predecessor(predecessor_type &p) __TBB_override {
@@ -837,7 +838,7 @@ namespace internal {
             return;
         }
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
         void extract_receiver() {
             buffer_type::reset();
             my_built_predecessors.receiver_extract(*this);
@@ -846,7 +847,7 @@ namespace internal {
         void reset_receiver(reset_flags f ) __TBB_override {
             tbb::internal::suppress_unused_warning(f);
             buffer_type::reset();
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
            if (f & rf_clear_edges)
               my_built_predecessors.clear();
 #endif
@@ -856,7 +857,7 @@ namespace internal {
         // my_join forwarding base used to count number of inputs that
         // received key.
         matching_forwarding_base<key_type> *my_join;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
         edge_container<predecessor_type> my_built_predecessors;
 #endif
     };  // key_matching_port
@@ -917,7 +918,7 @@ namespace internal {
             join_helper<N>::reset_inputs(my_inputs, f);
         }
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
         void extract( ) {
             // called outside of parallel contexts
             ports_with_no_inputs = N;
@@ -998,7 +999,7 @@ namespace internal {
             join_helper<N>::reset_inputs(my_inputs, f );
         }
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
         void extract() {
             reset_port_count();
             join_helper<N>::extract_inputs(my_inputs);
@@ -1067,7 +1068,6 @@ namespace internal {
         // and the output_buffer_type base class
     private:
         enum op_type { res_count, inc_count, may_succeed, try_make };
-        enum op_stat {WAIT=0, SUCCEEDED, FAILED};
         typedef join_node_FE<key_matching<key_type,key_hash_compare>, InputTuple, OutputTuple> class_type;
 
         class key_matching_FE_operation : public aggregated_operation<key_matching_FE_operation> {
@@ -1222,7 +1222,7 @@ namespace internal {
             output_buffer_type::reset();
         }
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
         void extract() {
             // called outside of parallel contexts
             join_helper<N>::extract_inputs(my_inputs);
@@ -1274,7 +1274,7 @@ namespace internal {
         using input_ports_type::try_to_make_tuple;
         using input_ports_type::tuple_accepted;
         using input_ports_type::tuple_rejected;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
         typedef typename sender<output_type>::built_successors_type built_successors_type;
         typedef typename sender<output_type>::successor_list_type successor_list_type;
 #endif
@@ -1282,11 +1282,10 @@ namespace internal {
     private:
         // ----------- Aggregator ------------
         enum op_type { reg_succ, rem_succ, try__get, do_fwrd, do_fwrd_bypass
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
             , add_blt_succ, del_blt_succ, blt_succ_cnt, blt_succ_cpy
 #endif
         };
-        enum op_stat {WAIT=0, SUCCEEDED, FAILED};
         typedef join_node_base<JP,InputTuple,OutputTuple> class_type;
 
         class join_node_base_operation : public aggregated_operation<join_node_base_operation> {
@@ -1295,7 +1294,7 @@ namespace internal {
             union {
                 output_type *my_arg;
                 successor_type *my_succ;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
                 size_t cnt_val;
                 successor_list_type *slist;
 #endif
@@ -1370,7 +1369,7 @@ namespace internal {
                         forwarder_busy = false;
                     }
                     break;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
                 case add_blt_succ:
                     my_successors.internal_add_built_successor(*(current->my_succ));
                     __TBB_store_with_release(current->status, SUCCEEDED);
@@ -1387,7 +1386,7 @@ namespace internal {
                     my_successors.copy_successors(*(current->slist));
                     __TBB_store_with_release(current->status, SUCCEEDED);
                     break;
-#endif  /* TBB_PREVIEW_FLOW_GRAPH_FEATURES */
+#endif  /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
                 }
             }
         }
@@ -1432,7 +1431,7 @@ namespace internal {
             return op_data.status == SUCCEEDED;
         }
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
         built_successors_type &built_successors() __TBB_override { return my_successors.built_successors(); }
 
         void internal_add_built_successor( successor_type &r) __TBB_override {
@@ -1456,9 +1455,9 @@ namespace internal {
             op_data.slist = &l;
             my_aggregator.execute(&op_data);
         }
-#endif  /* TBB_PREVIEW_FLOW_GRAPH_FEATURES */
+#endif  /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
         void extract() __TBB_override {
             input_ports_type::extract();
             my_successors.built_successors().sender_extract(*this);
diff --git a/src/tbb/include/tbb/internal/_flow_graph_node_impl.h b/src/tbb/include/tbb/internal/_flow_graph_node_impl.h
index 65a55b2d..dbc56ecd 100644
--- a/src/tbb/include/tbb/internal/_flow_graph_node_impl.h
+++ b/src/tbb/include/tbb/internal/_flow_graph_node_impl.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB__flow_graph_node_impl_H
@@ -61,15 +57,15 @@ namespace internal {
     //! Input and scheduling for a function node that takes a type Input as input
     //  The only up-ref is apply_body_impl, which should implement the function
     //  call and any handling of the result.
-    template< typename Input, typename A, typename ImplType >
+    template< typename Input, typename Policy, typename A, typename ImplType >
     class function_input_base : public receiver<Input>, tbb::internal::no_assign {
-        enum op_type {reg_pred, rem_pred, app_body, try_fwd, tryput_bypass, app_body_bypass
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+        enum op_type {reg_pred, rem_pred, try_fwd, tryput_bypass, app_body_bypass, occupy_concurrency
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
             , add_blt_pred, del_blt_pred,
             blt_pred_cnt, blt_pred_cpy   // create vector copies of preds and succs
 #endif
         };
-        typedef function_input_base<Input, A, ImplType> class_type;
+        typedef function_input_base<Input, Policy, A, ImplType> class_type;
 
     public:
 
@@ -78,26 +74,33 @@ namespace internal {
         typedef typename receiver<input_type>::predecessor_type predecessor_type;
         typedef predecessor_cache<input_type, null_mutex > predecessor_cache_type;
         typedef function_input_queue<input_type, A> input_queue_type;
-        typedef typename A::template rebind< input_queue_type >::other queue_allocator_type;
+        typedef typename tbb::internal::allocator_rebind<A, input_queue_type>::type queue_allocator_type;
+        __TBB_STATIC_ASSERT(!((internal::has_policy<queueing, Policy>::value) && (internal::has_policy<rejecting, Policy>::value)),
+                              "queueing and rejecting policies can't be specified simultaneously");
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
         typedef typename predecessor_cache_type::built_predecessors_type built_predecessors_type;
         typedef typename receiver<input_type>::predecessor_list_type predecessor_list_type;
 #endif
 
         //! Constructor for function_input_base
-        function_input_base( graph &g, size_t max_concurrency, input_queue_type *q = NULL)
-            : my_graph_ref(g), my_max_concurrency(max_concurrency), my_concurrency(0),
-              my_queue(q), forwarder_busy(false) {
+        function_input_base(
+            graph &g, __TBB_FLOW_GRAPH_PRIORITY_ARG1(size_t max_concurrency, node_priority_t priority)
+        ) : my_graph_ref(g), my_max_concurrency(max_concurrency)
+          , __TBB_FLOW_GRAPH_PRIORITY_ARG1(my_concurrency(0), my_priority(priority))
+          , my_queue(!internal::has_policy<rejecting, Policy>::value ? new input_queue_type() : NULL)
+          , forwarder_busy(false)
+        {
             my_predecessors.set_owner(this);
             my_aggregator.initialize_handler(handler_type(this));
         }
 
         //! Copy constructor
-        function_input_base( const function_input_base& src, input_queue_type *q = NULL) :
-            receiver<Input>(), tbb::internal::no_assign(),
-            my_graph_ref(src.my_graph_ref), my_max_concurrency(src.my_max_concurrency),
-            my_concurrency(0), my_queue(q), forwarder_busy(false)
+        function_input_base( const function_input_base& src)
+            : receiver<Input>(), tbb::internal::no_assign()
+            , my_graph_ref(src.my_graph_ref), my_max_concurrency(src.my_max_concurrency)
+            , __TBB_FLOW_GRAPH_PRIORITY_ARG1(my_concurrency(0), my_priority(src.my_priority))
+            , my_queue(src.my_queue ? new input_queue_type() : NULL), forwarder_busy(false)
         {
             my_predecessors.set_owner(this);
             my_aggregator.initialize_handler(handler_type(this));
@@ -111,18 +114,8 @@ namespace internal {
             if ( my_queue ) delete my_queue;
         }
 
-        //! Put to the node, returning a task if available
-        task * try_put_task( const input_type &t ) __TBB_override {
-           if ( my_max_concurrency == 0 ) {
-               return create_body_task( t );
-           } else {
-               operation_type op_data(t, tryput_bypass);
-               my_aggregator.execute(&op_data);
-               if(op_data.status == internal::SUCCEEDED) {
-                   return op_data.bypass_t;
-               }
-               return NULL;
-           }
+        task* try_put_task( const input_type& t) __TBB_override {
+            return try_put_task_impl(t, internal::has_policy<lightweight, Policy>());
         }
 
         //! Adds src to the list of cached predecessors.
@@ -141,7 +134,7 @@ namespace internal {
             return true;
         }
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
         //! Adds to list of predecessors added by make_edge
         void internal_add_built_predecessor( predecessor_type &src) __TBB_override {
             operation_type op_data(add_blt_pred);
@@ -171,7 +164,7 @@ namespace internal {
         built_predecessors_type &built_predecessors() __TBB_override {
             return my_predecessors.built_predecessors();
         }
-#endif  /* TBB_PREVIEW_FLOW_GRAPH_FEATURES */
+#endif  /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
 
     protected:
 
@@ -187,6 +180,7 @@ namespace internal {
         graph& my_graph_ref;
         const size_t my_max_concurrency;
         size_t my_concurrency;
+        __TBB_FLOW_GRAPH_PRIORITY_EXPR( node_priority_t my_priority; )
         input_queue_type *my_queue;
         predecessor_cache<input_type, null_mutex > my_predecessors;
 
@@ -197,10 +191,16 @@ namespace internal {
             __TBB_ASSERT(!(f & rf_clear_edges) || my_predecessors.empty(), "function_input_base reset failed");
         }
 
-        graph& graph_reference() __TBB_override {
+        graph& graph_reference() const __TBB_override {
             return my_graph_ref;
         }
 
+        task* try_get_postponed_task(const input_type& i) {
+            operation_type op_data(i, app_body_bypass);  // tries to pop an item or get_item
+            my_aggregator.execute(&op_data);
+            return op_data.bypass_t;
+        }
+
     private:
 
         friend class apply_body_task_bypass< class_type, input_type >;
@@ -212,10 +212,10 @@ namespace internal {
             union {
                 input_type *elem;
                 predecessor_type *r;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
                 size_t cnt_val;
                 predecessor_list_type *predv;
-#endif  /* TBB_PREVIEW_FLOW_GRAPH_FEATURES */
+#endif  /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
             };
             tbb::task *bypass_t;
             operation_type(const input_type& e, op_type t) :
@@ -228,7 +228,7 @@ namespace internal {
         friend class internal::aggregating_functor<class_type, operation_type>;
         aggregator< handler_type, operation_type > my_aggregator;
 
-        task* create_and_spawn_task(bool spawn) {
+        task* perform_queued_requests() {
             task* new_task = NULL;
             if(my_queue) {
                 if(!my_queue->empty()) {
@@ -245,13 +245,6 @@ namespace internal {
                     new_task = create_body_task(i);
                 }
             }
-            //! Spawns a task that applies a body
-            // task == NULL => g.reset(), which shouldn't occur in concurrent context
-            if(spawn && new_task) {
-                internal::spawn_in_graph_arena(graph_reference(), *new_task);
-                new_task = SUCCESSFULLY_ENQUEUED;
-            }
-
             return new_task;
         }
         void handle_operations(operation_type *op_list) {
@@ -272,27 +265,27 @@ namespace internal {
                     my_predecessors.remove(*(tmp->r));
                     __TBB_store_with_release(tmp->status, SUCCEEDED);
                     break;
-                case app_body:
-                    __TBB_ASSERT(my_max_concurrency != 0, NULL);
-                    --my_concurrency;
-                    __TBB_store_with_release(tmp->status, SUCCEEDED);
-                    if (my_concurrency<my_max_concurrency) {
-                        create_and_spawn_task(/*spawn=*/true);
-                    }
-                    break;
                 case app_body_bypass: {
                         tmp->bypass_t = NULL;
                         __TBB_ASSERT(my_max_concurrency != 0, NULL);
                         --my_concurrency;
                         if(my_concurrency<my_max_concurrency)
-                            tmp->bypass_t = create_and_spawn_task(/*spawn=*/false);
+                            tmp->bypass_t = perform_queued_requests();
 
                         __TBB_store_with_release(tmp->status, SUCCEEDED);
                     }
                     break;
                 case tryput_bypass: internal_try_put_task(tmp);  break;
                 case try_fwd: internal_forward(tmp);  break;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+                case occupy_concurrency:
+                    if (my_concurrency < my_max_concurrency) {
+                        ++my_concurrency;
+                        __TBB_store_with_release(tmp->status, SUCCEEDED);
+                    } else {
+                        __TBB_store_with_release(tmp->status, FAILED);
+                    }
+                    break;
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
                 case add_blt_pred: {
                          my_predecessors.internal_add_built_predecessor(*(tmp->r));
                         __TBB_store_with_release(tmp->status, SUCCEEDED);
@@ -310,7 +303,7 @@ namespace internal {
                     my_predecessors.copy_predecessors( *(tmp->predv) );
                     __TBB_store_with_release(tmp->status, SUCCEEDED);
                     break;
-#endif  /* TBB_PREVIEW_FLOW_GRAPH_FEATURES */
+#endif  /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
                 }
             }
         }
@@ -332,11 +325,11 @@ namespace internal {
            }
         }
 
-        //! Tries to spawn bodies if available and if concurrency allows
+        //! Creates tasks for postponed messages if available and if concurrency allows
         void internal_forward(operation_type *op) {
             op->bypass_t = NULL;
             if (my_concurrency < my_max_concurrency || !my_max_concurrency)
-                op->bypass_t = create_and_spawn_task(/*spawn=*/false);
+                op->bypass_t = perform_queued_requests();
             if(op->bypass_t)
                 __TBB_store_with_release(op->status, SUCCEEDED);
             else {
@@ -345,39 +338,61 @@ namespace internal {
             }
         }
 
+        task* internal_try_put_bypass( const input_type& t ) {
+            operation_type op_data(t, tryput_bypass);
+            my_aggregator.execute(&op_data);
+            if( op_data.status == internal::SUCCEEDED ) {
+                return op_data.bypass_t;
+            }
+            return NULL;
+        }
+
+        task* try_put_task_impl( const input_type& t, /*lightweight=*/tbb::internal::true_type ) {
+            if( my_max_concurrency == 0 ) {
+                return apply_body_bypass(t);
+            } else {
+                operation_type check_op(t, occupy_concurrency);
+                my_aggregator.execute(&check_op);
+                if( check_op.status == internal::SUCCEEDED ) {
+                    return apply_body_bypass(t);
+                }
+                return internal_try_put_bypass(t);
+            }
+        }
+
+        task* try_put_task_impl( const input_type& t, /*lightweight=*/tbb::internal::false_type ) {
+            if( my_max_concurrency == 0 ) {
+                return create_body_task(t);
+            } else {
+                return internal_try_put_bypass(t);
+            }
+        }
+
         //! Applies the body to the provided input
         //  then decides if more work is available
-        task * apply_body_bypass( input_type &i ) {
-            task * new_task = static_cast<ImplType *>(this)->apply_body_impl_bypass(i);
-            if ( my_max_concurrency != 0 ) {
-                operation_type op_data(app_body_bypass);  // tries to pop an item or get_item, enqueues another apply_body
-                my_aggregator.execute(&op_data);
-                // workaround for icc bug
-                tbb::task *ttask = op_data.bypass_t;
-                new_task = combine_tasks(my_graph_ref, new_task, ttask);
-            }
-            return new_task;
+        task * apply_body_bypass( const input_type &i ) {
+            return static_cast<ImplType *>(this)->apply_body_impl_bypass(i);
         }
 
         //! allocates a task to apply a body
         inline task * create_body_task( const input_type &input ) {
-
             return (internal::is_graph_active(my_graph_ref)) ?
-                new(task::allocate_additional_child_of(*(my_graph_ref.root_task())))
-                    apply_body_task_bypass < class_type, input_type >(*this, input) :
-                NULL;
+                new( task::allocate_additional_child_of(*(my_graph_ref.root_task())) )
+                apply_body_task_bypass < class_type, input_type >(
+                    *this, __TBB_FLOW_GRAPH_PRIORITY_ARG1(input, my_priority))
+                : NULL;
         }
 
        //! This is executed by an enqueued task, the "forwarder"
-       task *forward_task() {
+       task* forward_task() {
            operation_type op_data(try_fwd);
-           task *rval = NULL;
+           task* rval = NULL;
            do {
                op_data.status = WAIT;
                my_aggregator.execute(&op_data);
                if(op_data.status == SUCCEEDED) {
-                    // workaround for icc bug
-                   tbb::task *ttask = op_data.bypass_t;
+                   task* ttask = op_data.bypass_t;
+                   __TBB_ASSERT( ttask && ttask != SUCCESSFULLY_ENQUEUED, NULL );
                    rval = combine_tasks(my_graph_ref, rval, ttask);
                }
            } while (op_data.status == SUCCEEDED);
@@ -386,8 +401,9 @@ namespace internal {
 
        inline task *create_forward_task() {
            return (internal::is_graph_active(my_graph_ref)) ?
-               new(task::allocate_additional_child_of(*(my_graph_ref.root_task()))) forward_task_bypass< class_type >(*this) :
-               NULL;
+               new( task::allocate_additional_child_of(*(my_graph_ref.root_task())) )
+               forward_task_bypass< class_type >( __TBB_FLOW_GRAPH_PRIORITY_ARG1(*this, my_priority) )
+               : NULL;
        }
 
        //! Spawns a task that calls forward()
@@ -401,27 +417,29 @@ namespace internal {
 
     //! Implements methods for a function node that takes a type Input as input and sends
     //  a type Output to its successors.
-    template< typename Input, typename Output, typename A>
-    class function_input : public function_input_base<Input, A, function_input<Input,Output,A> > {
+    template< typename Input, typename Output, typename Policy, typename A>
+    class function_input : public function_input_base<Input, Policy, A, function_input<Input,Output,Policy,A> > {
     public:
         typedef Input input_type;
         typedef Output output_type;
         typedef function_body<input_type, output_type> function_body_type;
-        typedef function_input<Input,Output,A> my_class;
-        typedef function_input_base<Input, A, my_class> base_type;
+        typedef function_input<Input, Output, Policy,A> my_class;
+        typedef function_input_base<Input, Policy, A, my_class> base_type;
         typedef function_input_queue<input_type, A> input_queue_type;
 
         // constructor
         template<typename Body>
-        function_input( graph &g, size_t max_concurrency, Body& body, input_queue_type *q = NULL ) :
-            base_type(g, max_concurrency, q),
-            my_body( new internal::function_body_leaf< input_type, output_type, Body>(body) ),
-            my_init_body( new internal::function_body_leaf< input_type, output_type, Body>(body) ) {
+        function_input(
+            graph &g, size_t max_concurrency,
+            __TBB_FLOW_GRAPH_PRIORITY_ARG1(Body& body, node_priority_t priority)
+        ) : base_type(g, __TBB_FLOW_GRAPH_PRIORITY_ARG1(max_concurrency, priority))
+          , my_body( new internal::function_body_leaf< input_type, output_type, Body>(body) )
+          , my_init_body( new internal::function_body_leaf< input_type, output_type, Body>(body) ) {
         }
 
         //! Copy constructor
-        function_input( const function_input& src, input_queue_type *q = NULL ) :
-                base_type(src, q),
+        function_input( const function_input& src ) :
+                base_type(src),
                 my_body( src.my_init_body->clone() ),
                 my_init_body(src.my_init_body->clone() ) {
         }
@@ -437,18 +455,52 @@ namespace internal {
             return dynamic_cast< internal::function_body_leaf<input_type, output_type, Body> & >(body_ref).get_body();
         }
 
-        task * apply_body_impl_bypass( const input_type &i) {
-#if TBB_PREVIEW_FLOW_GRAPH_TRACE
+        output_type apply_body_impl( const input_type& i) {
             // There is an extra copied needed to capture the
             // body execution without the try_put
             tbb::internal::fgt_begin_body( my_body );
             output_type v = (*my_body)(i);
             tbb::internal::fgt_end_body( my_body );
-            task * new_task = successors().try_put_task( v );
+            return v;
+        }
+
+        //TODO: consider moving into the base class
+        task * apply_body_impl_bypass( const input_type &i) {
+            output_type v = apply_body_impl(i);
+#if TBB_DEPRECATED_MESSAGE_FLOW_ORDER
+            task* successor_task = successors().try_put_task(v);
+#endif
+            task* postponed_task = NULL;
+            if( base_type::my_max_concurrency != 0 ) {
+                postponed_task = base_type::try_get_postponed_task(i);
+                __TBB_ASSERT( !postponed_task || postponed_task != SUCCESSFULLY_ENQUEUED, NULL );
+            }
+#if TBB_DEPRECATED_MESSAGE_FLOW_ORDER
+            graph& g = base_type::my_graph_ref;
+            return combine_tasks(g, successor_task, postponed_task);
 #else
-            task * new_task = successors().try_put_task( (*my_body)(i) );
+            if( postponed_task ) {
+                // make the task available for other workers since we do not know successors'
+                // execution policy
+                internal::spawn_in_graph_arena(base_type::graph_reference(), *postponed_task);
+            }
+            task* successor_task = successors().try_put_task(v);
+#if _MSC_VER && !__INTEL_COMPILER
+#pragma warning (push)
+#pragma warning (disable: 4127)  /* suppress conditional expression is constant */
 #endif
-            return new_task;
+            if(internal::has_policy<lightweight, Policy>::value) {
+#if _MSC_VER && !__INTEL_COMPILER
+#pragma warning (pop)
+#endif
+                if(!successor_task) {
+                    // Return confirmative status since current
+                    // node's body has been executed anyway
+                    successor_task = SUCCESSFULLY_ENQUEUED;
+                }
+            }
+            return successor_task;
+#endif /* TBB_DEPRECATED_MESSAGE_FLOW_ORDER */
         }
 
     protected:
@@ -491,7 +543,7 @@ namespace internal {
         }
     };
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
     // helper templates to extract the output ports of an multifunction_node from graph
     template<int N> struct extract_element {
         template<typename P> static void extract_this(P &p) {
@@ -507,36 +559,108 @@ namespace internal {
     };
 #endif
 
+    template <typename OutputTuple>
+    struct init_output_ports {
+#if __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT
+        template <typename... Args>
+        static OutputTuple call(graph& g, const tbb::flow::tuple<Args...>&) {
+            return OutputTuple(Args(g)...);
+        }
+#else // __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT
+        template <typename T1>
+        static OutputTuple call(graph& g, const tbb::flow::tuple<T1>&) {
+            return OutputTuple(T1(g));
+        }
+
+        template <typename T1, typename T2>
+        static OutputTuple call(graph& g, const tbb::flow::tuple<T1, T2>&) {
+            return OutputTuple(T1(g), T2(g));
+        }
+
+        template <typename T1, typename T2, typename T3>
+        static OutputTuple call(graph& g, const tbb::flow::tuple<T1, T2, T3>&) {
+            return OutputTuple(T1(g), T2(g), T3(g));
+        }
+
+        template <typename T1, typename T2, typename T3, typename T4>
+        static OutputTuple call(graph& g, const tbb::flow::tuple<T1, T2, T3, T4>&) {
+            return OutputTuple(T1(g), T2(g), T3(g), T4(g));
+        }
+
+        template <typename T1, typename T2, typename T3, typename T4, typename T5>
+        static OutputTuple call(graph& g, const tbb::flow::tuple<T1, T2, T3, T4, T5>&) {
+            return OutputTuple(T1(g), T2(g), T3(g), T4(g), T5(g));
+        }
+#if __TBB_VARIADIC_MAX >= 6
+        template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
+        static OutputTuple call(graph& g, const tbb::flow::tuple<T1, T2, T3, T4, T5, T6>&) {
+            return OutputTuple(T1(g), T2(g), T3(g), T4(g), T5(g), T6(g));
+        }
+#endif
+#if __TBB_VARIADIC_MAX >= 7
+        template <typename T1, typename T2, typename T3, typename T4,
+                  typename T5, typename T6, typename T7>
+        static OutputTuple call(graph& g,
+                                const tbb::flow::tuple<T1, T2, T3, T4, T5, T6, T7>&) {
+            return OutputTuple(T1(g), T2(g), T3(g), T4(g), T5(g), T6(g), T7(g));
+        }
+#endif
+#if __TBB_VARIADIC_MAX >= 8
+        template <typename T1, typename T2, typename T3, typename T4,
+                  typename T5, typename T6, typename T7, typename T8>
+        static OutputTuple call(graph& g,
+                                const tbb::flow::tuple<T1, T2, T3, T4, T5, T6, T7, T8>&) {
+            return OutputTuple(T1(g), T2(g), T3(g), T4(g), T5(g), T6(g), T7(g), T8(g));
+        }
+#endif
+#if __TBB_VARIADIC_MAX >= 9
+        template <typename T1, typename T2, typename T3, typename T4,
+                  typename T5, typename T6, typename T7, typename T8, typename T9>
+        static OutputTuple call(graph& g,
+                                const tbb::flow::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9>&) {
+            return OutputTuple(T1(g), T2(g), T3(g), T4(g), T5(g), T6(g), T7(g), T8(g), T9(g));
+        }
+#endif
+#if __TBB_VARIADIC_MAX >= 9
+        template <typename T1, typename T2, typename T3, typename T4, typename T5,
+                  typename T6, typename T7, typename T8, typename T9, typename T10>
+        static OutputTuple call(graph& g,
+                                const tbb::flow::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>&) {
+            return OutputTuple(T1(g), T2(g), T3(g), T4(g), T5(g), T6(g), T7(g), T8(g), T9(g), T10(g));
+        }
+#endif
+#endif // __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT
+    }; // struct init_output_ports
+
     //! Implements methods for a function node that takes a type Input as input
     //  and has a tuple of output ports specified.
-    template< typename Input, typename OutputPortSet, typename A>
-    class multifunction_input : public function_input_base<Input, A, multifunction_input<Input,OutputPortSet,A> > {
+    template< typename Input, typename OutputPortSet, typename Policy, typename A>
+    class multifunction_input : public function_input_base<Input, Policy, A, multifunction_input<Input,OutputPortSet,Policy,A> > {
     public:
         static const int N = tbb::flow::tuple_size<OutputPortSet>::value;
         typedef Input input_type;
         typedef OutputPortSet output_ports_type;
         typedef multifunction_body<input_type, output_ports_type> multifunction_body_type;
-        typedef multifunction_input<Input,OutputPortSet,A> my_class;
-        typedef function_input_base<Input, A, my_class> base_type;
+        typedef multifunction_input<Input, OutputPortSet, Policy, A> my_class;
+        typedef function_input_base<Input, Policy, A, my_class> base_type;
         typedef function_input_queue<input_type, A> input_queue_type;
 
         // constructor
         template<typename Body>
-        multifunction_input(
-                graph &g,
-                size_t max_concurrency,
-                Body& body,
-                input_queue_type *q = NULL ) :
-            base_type(g, max_concurrency, q),
-            my_body( new internal::multifunction_body_leaf<input_type, output_ports_type, Body>(body) ),
-            my_init_body( new internal::multifunction_body_leaf<input_type, output_ports_type, Body>(body) ) {
+        multifunction_input(graph &g, size_t max_concurrency,
+                            __TBB_FLOW_GRAPH_PRIORITY_ARG1(Body& body, node_priority_t priority)
+        ) : base_type(g, __TBB_FLOW_GRAPH_PRIORITY_ARG1(max_concurrency, priority))
+          , my_body( new internal::multifunction_body_leaf<input_type, output_ports_type, Body>(body) )
+          , my_init_body( new internal::multifunction_body_leaf<input_type, output_ports_type, Body>(body) )
+          , my_output_ports(init_output_ports<output_ports_type>::call(g, my_output_ports)){
         }
 
         //! Copy constructor
-        multifunction_input( const multifunction_input& src, input_queue_type *q = NULL ) :
-                base_type(src, q),
+        multifunction_input( const multifunction_input& src ) :
+                base_type(src),
                 my_body( src.my_init_body->clone() ),
-                my_init_body(src.my_init_body->clone() ) {
+                my_init_body(src.my_init_body->clone() ),
+                my_output_ports( init_output_ports<output_ports_type>::call(src.my_graph_ref, my_output_ports) ) {
         }
 
         ~multifunction_input() {
@@ -552,18 +676,22 @@ namespace internal {
 
         // for multifunction nodes we do not have a single successor as such.  So we just tell
         // the task we were successful.
+        //TODO: consider moving common parts with implementation in function_input into separate function
         task * apply_body_impl_bypass( const input_type &i) {
             tbb::internal::fgt_begin_body( my_body );
             (*my_body)(i, my_output_ports);
             tbb::internal::fgt_end_body( my_body );
-            task * new_task = SUCCESSFULLY_ENQUEUED;
-            return new_task;
+            task* ttask = NULL;
+            if(base_type::my_max_concurrency != 0) {
+                ttask = base_type::try_get_postponed_task(i);
+            }
+            return ttask ? ttask : SUCCESSFULLY_ENQUEUED;
         }
 
         output_ports_type &output_ports(){ return my_output_ports; }
 
     protected:
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
         void extract() {
             extract_element<N>::extract_this(my_output_ports);
         }
@@ -621,7 +749,7 @@ namespace internal {
     };
 
     //! Implements methods for an executable node that takes continue_msg as input
-    template< typename Output >
+    template< typename Output, typename Policy>
     class continue_input : public continue_receiver {
     public:
 
@@ -631,18 +759,23 @@ namespace internal {
         //! The output type of this receiver
         typedef Output output_type;
         typedef function_body<input_type, output_type> function_body_type;
+        typedef continue_input<output_type, Policy> class_type;
 
         template< typename Body >
-        continue_input( graph &g, Body& body )
-            : my_graph_ref(g),
-             my_body( new internal::function_body_leaf< input_type, output_type, Body>(body) ),
-             my_init_body( new internal::function_body_leaf< input_type, output_type, Body>(body) ) { }
+        continue_input( graph &g, __TBB_FLOW_GRAPH_PRIORITY_ARG1(Body& body, node_priority_t priority) )
+            : continue_receiver(__TBB_FLOW_GRAPH_PRIORITY_ARG1(/*number_of_predecessors=*/0, priority))
+            , my_graph_ref(g)
+            , my_body( new internal::function_body_leaf< input_type, output_type, Body>(body) )
+            , my_init_body( new internal::function_body_leaf< input_type, output_type, Body>(body) )
+            { }
 
         template< typename Body >
-        continue_input( graph &g, int number_of_predecessors, Body& body )
-            : continue_receiver( number_of_predecessors ), my_graph_ref(g),
-             my_body( new internal::function_body_leaf< input_type, output_type, Body>(body) ),
-             my_init_body( new internal::function_body_leaf< input_type, output_type, Body>(body) )
+        continue_input( graph &g, int number_of_predecessors,
+                        __TBB_FLOW_GRAPH_PRIORITY_ARG1(Body& body, node_priority_t priority)
+        ) : continue_receiver( __TBB_FLOW_GRAPH_PRIORITY_ARG1(number_of_predecessors, priority) )
+          , my_graph_ref(g)
+          , my_body( new internal::function_body_leaf< input_type, output_type, Body>(body) )
+          , my_init_body( new internal::function_body_leaf< input_type, output_type, Body>(body) )
         { }
 
         continue_input( const continue_input& src ) : continue_receiver(src),
@@ -678,34 +811,42 @@ namespace internal {
 
         virtual broadcast_cache<output_type > &successors() = 0;
 
-        friend class apply_body_task_bypass< continue_input< Output >, continue_msg >;
+        friend class apply_body_task_bypass< class_type, continue_msg >;
 
         //! Applies the body to the provided input
         task *apply_body_bypass( input_type ) {
-#if TBB_PREVIEW_FLOW_GRAPH_TRACE
             // There is an extra copied needed to capture the
             // body execution without the try_put
             tbb::internal::fgt_begin_body( my_body );
             output_type v = (*my_body)( continue_msg() );
             tbb::internal::fgt_end_body( my_body );
             return successors().try_put_task( v );
-#else
-            return successors().try_put_task( (*my_body)( continue_msg() ) );
-#endif
         }
 
-        //! Spawns a task that applies the body
-        task *execute( ) __TBB_override {
-            return (internal::is_graph_active(my_graph_ref)) ?
-                new ( task::allocate_additional_child_of( *(my_graph_ref.root_task()) ) )
-                    apply_body_task_bypass< continue_input< Output >, continue_msg >( *this, continue_msg() ) :
-                NULL;
+        task* execute() __TBB_override {
+            if(!internal::is_graph_active(my_graph_ref)) {
+                return NULL;
+            }
+#if _MSC_VER && !__INTEL_COMPILER
+#pragma warning (push)
+#pragma warning (disable: 4127)  /* suppress conditional expression is constant */
+#endif
+            if(internal::has_policy<lightweight, Policy>::value) {
+#if _MSC_VER && !__INTEL_COMPILER
+#pragma warning (pop)
+#endif
+                return apply_body_bypass( continue_msg() );
+            }
+            else {
+                return new ( task::allocate_additional_child_of( *(my_graph_ref.root_task()) ) )
+                       apply_body_task_bypass< class_type, continue_msg >(
+                           *this, __TBB_FLOW_GRAPH_PRIORITY_ARG1(continue_msg(), my_priority) );
+            }
         }
 
-        graph& graph_reference() __TBB_override {
+        graph& graph_reference() const __TBB_override {
             return my_graph_ref;
         }
-
     };  // continue_input
 
     //! Implements methods for both executable and function nodes that puts Output to its successors
@@ -717,13 +858,13 @@ namespace internal {
         typedef Output output_type;
         typedef typename sender<output_type>::successor_type successor_type;
         typedef broadcast_cache<output_type> broadcast_cache_type;
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
         typedef typename sender<output_type>::built_successors_type built_successors_type;
         typedef typename sender<output_type>::successor_list_type successor_list_type;
 #endif
 
-        function_output() { my_successors.set_owner(this); }
-        function_output(const function_output & /*other*/) : sender<output_type>() {
+        function_output( graph& g) : my_graph_ref(g) { my_successors.set_owner(this); }
+        function_output(const function_output & other) : sender<output_type>(), my_graph_ref(other.my_graph_ref) {
             my_successors.set_owner(this);
         }
 
@@ -739,7 +880,7 @@ namespace internal {
             return true;
         }
 
-#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
         built_successors_type &built_successors() __TBB_override { return successors().built_successors(); }
 
 
@@ -758,7 +899,7 @@ namespace internal {
         void  copy_successors( successor_list_type &v) __TBB_override {
             successors().copy_successors(v);
         }
-#endif  /* TBB_PREVIEW_FLOW_GRAPH_FEATURES */
+#endif  /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
 
         // for multifunction_node.  The function_body that implements
         // the node will have an input and an output tuple of ports.  To put
@@ -773,9 +914,11 @@ namespace internal {
         }
 
         broadcast_cache_type &successors() { return my_successors; }
+
+        graph& graph_reference() const { return my_graph_ref; }
     protected:
         broadcast_cache_type my_successors;
-
+        graph& my_graph_ref;
     };  // function_output
 
     template< typename Output >
@@ -785,8 +928,8 @@ namespace internal {
         typedef function_output<output_type> base_type;
         using base_type::my_successors;
 
-        multifunction_output() : base_type() {my_successors.set_owner(this);}
-        multifunction_output( const multifunction_output &/*other*/) : base_type() { my_successors.set_owner(this); }
+        multifunction_output(graph& g) : base_type(g) {my_successors.set_owner(this);}
+        multifunction_output( const multifunction_output& other) : base_type(other.my_graph_ref) { my_successors.set_owner(this); }
 
         bool try_put(const output_type &i) {
             task *res = try_put_task(i);
@@ -797,6 +940,8 @@ namespace internal {
             return true;
         }
 
+        using base_type::graph_reference;
+
     protected:
 
         task* try_put_task(const output_type &i) {
@@ -808,7 +953,7 @@ namespace internal {
     };  // multifunction_output
 
 //composite_node
-#if TBB_PREVIEW_FLOW_GRAPH_TRACE && __TBB_FLOW_GRAPH_CPP11_FEATURES
+#if __TBB_FLOW_GRAPH_CPP11_FEATURES
     template<typename CompositeType>
     void add_nodes_impl(CompositeType*, bool) {}
 
@@ -816,10 +961,7 @@ namespace internal {
     void add_nodes_impl(CompositeType *c_node, bool visible, const NodeType1& n1, const NodeTypes&... n) {
         void *addr = const_cast<NodeType1 *>(&n1);
 
-        if(visible)
-            tbb::internal::itt_relation_add( tbb::internal::ITT_DOMAIN_FLOW, c_node, tbb::internal::FLOW_NODE, tbb::internal::__itt_relation_is_parent_of, addr, tbb::internal::FLOW_NODE );
-        else
-            tbb::internal::itt_relation_add( tbb::internal::ITT_DOMAIN_FLOW, addr, tbb::internal::FLOW_NODE, tbb::internal::__itt_relation_is_child_of, c_node, tbb::internal::FLOW_NODE );
+        fgt_alias_port(c_node, addr, visible);
         add_nodes_impl(c_node, visible, n...);
     }
 #endif
diff --git a/src/tbb/include/tbb/internal/_flow_graph_node_set_impl.h b/src/tbb/include/tbb/internal/_flow_graph_node_set_impl.h
new file mode 100644
index 00000000..f5ec6d0e
--- /dev/null
+++ b/src/tbb/include/tbb/internal/_flow_graph_node_set_impl.h
@@ -0,0 +1,269 @@
+/*
+    Copyright (c) 2019-2020 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.
+*/
+
+#ifndef __TBB_flow_graph_node_set_impl_H
+#define __TBB_flow_graph_node_set_impl_H
+
+#ifndef __TBB_flow_graph_H
+#error Do not #include this internal file directly; use public TBB headers instead.
+#endif
+
+// Included in namespace tbb::flow::interfaceX (in flow_graph.h)
+
+namespace internal {
+
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+// Visual Studio 2019 reports an error while calling predecessor_selector::get and successor_selector::get
+// Seems like the well-formed expression in trailing decltype is treated as ill-formed
+// TODO: investigate problems with decltype in trailing return types or find the cross-platform solution
+#define __TBB_MSVC_DISABLE_TRAILING_DECLTYPE (_MSC_VER >= 1900)
+
+namespace order {
+struct undefined {};
+struct following {};
+struct preceding {};
+}
+
+class get_graph_helper {
+public:
+    // TODO: consider making graph_reference() public and consistent interface to get a reference to the graph
+    // and remove get_graph_helper
+    template <typename T>
+    static graph& get(const T& object) {
+        return get_impl(object, std::is_base_of<graph_node, T>());
+    }
+
+private:
+    // Get graph from the object of type derived from graph_node
+    template <typename T>
+    static graph& get_impl(const T& object, std::true_type) {
+        return static_cast<const graph_node*>(&object)->my_graph;
+    }
+
+    template <typename T>
+    static graph& get_impl(const T& object, std::false_type) {
+        return object.graph_reference();
+    }
+};
+
+template<typename Order, typename... Nodes>
+struct node_set {
+    typedef Order order_type;
+
+    tbb::flow::tuple<Nodes&...> nodes;
+    node_set(Nodes&... ns) : nodes(ns...) {}
+
+    template <typename... Nodes2>
+    node_set(const node_set<order::undefined, Nodes2...>& set) : nodes(set.nodes) {}
+
+    graph& graph_reference() const {
+        return get_graph_helper::get(std::get<0>(nodes));
+    }
+};
+
+namespace alias_helpers {
+template <typename T> using output_type = typename T::output_type;
+template <typename T> using output_ports_type = typename T::output_ports_type;
+template <typename T> using input_type = typename T::input_type;
+template <typename T> using input_ports_type = typename T::input_ports_type;
+} // namespace alias_helpers
+
+template <typename T>
+using has_output_type = tbb::internal::supports<T, alias_helpers::output_type>;
+
+template <typename T>
+using has_input_type = tbb::internal::supports<T, alias_helpers::input_type>;
+
+template <typename T>
+using has_input_ports_type = tbb::internal::supports<T, alias_helpers::input_ports_type>;
+
+template <typename T>
+using has_output_ports_type = tbb::internal::supports<T, alias_helpers::output_ports_type>;
+
+template<typename T>
+struct is_sender : std::is_base_of<sender<typename T::output_type>, T> {};
+
+template<typename T>
+struct is_receiver : std::is_base_of<receiver<typename T::input_type>, T> {};
+
+template <typename Node>
+struct is_async_node : std::false_type {};
+
+template <typename... Args>
+struct is_async_node<tbb::flow::interface11::async_node<Args...>> : std::true_type {};
+
+template<typename FirstPredecessor, typename... Predecessors>
+node_set<order::following, FirstPredecessor, Predecessors...>
+follows(FirstPredecessor& first_predecessor, Predecessors&... predecessors) {
+    __TBB_STATIC_ASSERT((tbb::internal::conjunction<has_output_type<FirstPredecessor>,
+                                                   has_output_type<Predecessors>...>::value),
+                        "Not all node's predecessors has output_type typedef");
+    __TBB_STATIC_ASSERT((tbb::internal::conjunction<is_sender<FirstPredecessor>, is_sender<Predecessors>...>::value),
+                        "Not all node's predecessors are senders");
+    return node_set<order::following, FirstPredecessor, Predecessors...>(first_predecessor, predecessors...);
+}
+
+template<typename... Predecessors>
+node_set<order::following, Predecessors...>
+follows(node_set<order::undefined, Predecessors...>& predecessors_set) {
+    __TBB_STATIC_ASSERT((tbb::internal::conjunction<has_output_type<Predecessors>...>::value),
+                        "Not all nodes in the set has output_type typedef");
+    __TBB_STATIC_ASSERT((tbb::internal::conjunction<is_sender<Predecessors>...>::value),
+                        "Not all nodes in the set are senders");
+    return node_set<order::following, Predecessors...>(predecessors_set);
+}
+
+template<typename FirstSuccessor, typename... Successors>
+node_set<order::preceding, FirstSuccessor, Successors...>
+precedes(FirstSuccessor& first_successor, Successors&... successors) {
+    __TBB_STATIC_ASSERT((tbb::internal::conjunction<has_input_type<FirstSuccessor>,
+                                                    has_input_type<Successors>...>::value),
+                        "Not all node's successors has input_type typedef");
+    __TBB_STATIC_ASSERT((tbb::internal::conjunction<is_receiver<FirstSuccessor>, is_receiver<Successors>...>::value),
+                        "Not all node's successors are receivers");
+    return node_set<order::preceding, FirstSuccessor, Successors...>(first_successor, successors...);
+}
+
+template<typename... Successors>
+node_set<order::preceding, Successors...>
+precedes(node_set<order::undefined, Successors...>& successors_set) {
+    __TBB_STATIC_ASSERT((tbb::internal::conjunction<has_input_type<Successors>...>::value),
+                        "Not all nodes in the set has input_type typedef");
+    __TBB_STATIC_ASSERT((tbb::internal::conjunction<is_receiver<Successors>...>::value),
+                        "Not all nodes in the set are receivers");
+    return node_set<order::preceding, Successors...>(successors_set);
+}
+
+template <typename Node, typename... Nodes>
+node_set<order::undefined, Node, Nodes...>
+make_node_set(Node& first_node, Nodes&... nodes) {
+    return node_set<order::undefined, Node, Nodes...>(first_node, nodes...);
+}
+
+template<size_t I>
+class successor_selector {
+    template <typename NodeType>
+    static auto get_impl(NodeType& node, std::true_type) -> decltype(input_port<I>(node)) {
+        return input_port<I>(node);
+    }
+
+    template <typename NodeType>
+    static NodeType& get_impl(NodeType& node, std::false_type) { return node; }
+
+public:
+    template <typename NodeType>
+#if __TBB_MSVC_DISABLE_TRAILING_DECLTYPE
+    static auto& get(NodeType& node)
+#else
+    static auto get(NodeType& node) -> decltype(get_impl(node, has_input_ports_type<NodeType>()))
+#endif
+	{
+        return get_impl(node, has_input_ports_type<NodeType>());
+    }
+};
+
+template<size_t I>
+class predecessor_selector {
+    template <typename NodeType>
+    static auto internal_get(NodeType& node, std::true_type) -> decltype(output_port<I>(node)) {
+        return output_port<I>(node);
+    }
+
+    template <typename NodeType>
+    static NodeType& internal_get(NodeType& node, std::false_type) { return node;}
+
+    template <typename NodeType>
+#if __TBB_MSVC_DISABLE_TRAILING_DECLTYPE
+    static auto& get_impl(NodeType& node, std::false_type)
+#else
+    static auto get_impl(NodeType& node, std::false_type) -> decltype(internal_get(node, has_output_ports_type<NodeType>()))
+#endif
+	{
+        return internal_get(node, has_output_ports_type<NodeType>());
+    }
+
+    template <typename AsyncNode>
+    static AsyncNode& get_impl(AsyncNode& node, std::true_type) { return node; }
+
+public:
+    template <typename NodeType>
+#if __TBB_MSVC_DISABLE_TRAILING_DECLTYPE
+    static auto& get(NodeType& node)
+#else
+    static auto get(NodeType& node) -> decltype(get_impl(node, is_async_node<NodeType>()))
+#endif
+	{
+        return get_impl(node, is_async_node<NodeType>());
+    }
+};
+
+template<size_t I>
+class make_edges_helper {
+public:
+    template<typename PredecessorsTuple, typename NodeType>
+    static void connect_predecessors(PredecessorsTuple& predecessors, NodeType& node) {
+        make_edge(std::get<I>(predecessors), successor_selector<I>::get(node));
+        make_edges_helper<I - 1>::connect_predecessors(predecessors, node);
+    }
+
+    template<typename SuccessorsTuple, typename NodeType>
+    static void connect_successors(NodeType& node, SuccessorsTuple& successors) {
+        make_edge(predecessor_selector<I>::get(node), std::get<I>(successors));
+        make_edges_helper<I - 1>::connect_successors(node, successors);
+    }
+};
+
+template<>
+struct make_edges_helper<0> {
+    template<typename PredecessorsTuple, typename NodeType>
+    static void connect_predecessors(PredecessorsTuple& predecessors, NodeType& node) {
+        make_edge(std::get<0>(predecessors), successor_selector<0>::get(node));
+    }
+
+    template<typename SuccessorsTuple, typename NodeType>
+    static void connect_successors(NodeType& node, SuccessorsTuple& successors) {
+        make_edge(predecessor_selector<0>::get(node), std::get<0>(successors));
+    }
+};
+
+// TODO: consider adding an overload for making edges between node sets
+template<typename NodeType, typename OrderFlagType, typename... Args>
+void make_edges(const node_set<OrderFlagType, Args...>& s, NodeType& node) {
+    const std::size_t SetSize = tbb::flow::tuple_size<decltype(s.nodes)>::value;
+    make_edges_helper<SetSize - 1>::connect_predecessors(s.nodes, node);
+}
+
+template <typename NodeType, typename OrderFlagType, typename... Args>
+void make_edges(NodeType& node, const node_set<OrderFlagType, Args...>& s) {
+    const std::size_t SetSize = tbb::flow::tuple_size<decltype(s.nodes)>::value;
+    make_edges_helper<SetSize - 1>::connect_successors(node, s.nodes);
+}
+
+template <typename NodeType, typename... Nodes>
+void make_edges_in_order(const node_set<order::following, Nodes...>& ns, NodeType& node) {
+    make_edges(ns, node);
+}
+
+template <typename NodeType, typename... Nodes>
+void make_edges_in_order(const node_set<order::preceding, Nodes...>& ns, NodeType& node) {
+    make_edges(node, ns);
+}
+
+#endif // __TBB_CPP11_PRESENT
+
+} // namespace internal
+
+#endif // __TBB_flow_graph_node_set_impl_H
diff --git a/src/tbb/include/tbb/internal/_flow_graph_nodes_deduction.h b/src/tbb/include/tbb/internal/_flow_graph_nodes_deduction.h
new file mode 100644
index 00000000..caf2f689
--- /dev/null
+++ b/src/tbb/include/tbb/internal/_flow_graph_nodes_deduction.h
@@ -0,0 +1,298 @@
+/*
+    Copyright (c) 2005-2020 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.
+*/
+
+#ifndef __TBB_flow_graph_nodes_deduction_H
+#define __TBB_flow_graph_nodes_deduction_H
+
+#if __TBB_CPP17_DEDUCTION_GUIDES_PRESENT
+
+namespace tbb {
+namespace flow {
+namespace interface11 {
+
+template <typename Input, typename Output>
+struct declare_body_types {
+    using input_type = Input;
+    using output_type = Output;
+};
+
+struct NoInputBody {};
+
+template <typename Output>
+struct declare_body_types<NoInputBody, Output> {
+    using output_type = Output;
+};
+
+template <typename T> struct body_types;
+
+template <typename T, typename Input, typename Output>
+struct body_types<Output (T::*)(const Input&) const> : declare_body_types<Input, Output> {};
+
+template <typename T, typename Input, typename Output>
+struct body_types<Output (T::*)(const Input&)> : declare_body_types<Input, Output> {};
+
+template <typename T, typename Input, typename Output>
+struct body_types<Output (T::*)(Input&) const> : declare_body_types<Input, Output> {};
+
+template <typename T, typename Input, typename Output>
+struct body_types<Output (T::*)(Input&)> : declare_body_types<Input, Output> {};
+
+template <typename Input, typename Output>
+struct body_types<Output (*)(Input&)> : declare_body_types<Input, Output> {};
+
+template <typename Input, typename Output>
+struct body_types<Output (*)(const Input&)> : declare_body_types<Input, Output> {};
+
+template <typename T, typename Output>
+struct body_types<Output (T::*)(flow_control&) const> : declare_body_types<NoInputBody, Output> {};
+
+template <typename T, typename Output>
+struct body_types<Output (T::*)(flow_control&)> : declare_body_types<NoInputBody, Output> {};
+
+template <typename Output>
+struct body_types<Output (*)(flow_control&)> : declare_body_types<NoInputBody, Output> {};
+
+template <typename Body>
+using input_t = typename body_types<Body>::input_type;
+
+template <typename Body>
+using output_t = typename body_types<Body>::output_type;
+
+template <typename T, typename Input, typename Output>
+auto decide_on_operator_overload(Output (T::*name)(const Input&) const)->decltype(name);
+
+template <typename T, typename Input, typename Output>
+auto decide_on_operator_overload(Output (T::*name)(const Input&))->decltype(name);
+
+template <typename T, typename Input, typename Output>
+auto decide_on_operator_overload(Output (T::*name)(Input&) const)->decltype(name);
+
+template <typename T, typename Input, typename Output>
+auto decide_on_operator_overload(Output (T::*name)(Input&))->decltype(name);
+
+template <typename Input, typename Output>
+auto decide_on_operator_overload(Output (*name)(const Input&))->decltype(name);
+
+template <typename Input, typename Output>
+auto decide_on_operator_overload(Output (*name)(Input&))->decltype(name);
+
+template <typename Body>
+decltype(decide_on_operator_overload(&Body::operator())) decide_on_callable_type(int);
+
+template <typename Body>
+decltype(decide_on_operator_overload(std::declval<Body>())) decide_on_callable_type(...);
+
+// Deduction guides for Flow Graph nodes
+#if TBB_USE_SOURCE_NODE_AS_ALIAS
+#if TBB_DEPRECATED_INPUT_NODE_BODY
+template <typename GraphOrSet, typename Body>
+source_node(GraphOrSet&&, Body)
+->source_node<input_t<decltype(decide_on_callable_type<Body>(0))>>;
+#else
+template <typename GraphOrSet, typename Body>
+source_node(GraphOrSet&&, Body)
+->source_node<output_t<decltype(decide_on_callable_type<Body>(0))>>;
+#endif // TBB_DEPRECATED_INPUT_NODE_BODY
+#else
+template <typename GraphOrSet, typename Body>
+source_node(GraphOrSet&&, Body, bool = true)
+->source_node<input_t<decltype(decide_on_callable_type<Body>(0))>>;
+#endif
+
+#if TBB_DEPRECATED_INPUT_NODE_BODY
+template <typename GraphOrSet, typename Body>
+input_node(GraphOrSet&&, Body, bool = true)
+->input_node<input_t<decltype(decide_on_callable_type<Body>(0))>>;
+#else
+template <typename GraphOrSet, typename Body>
+input_node(GraphOrSet&&, Body)
+->input_node<output_t<decltype(decide_on_callable_type<Body>(0))>>;
+#endif
+
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+
+template <typename NodeSet>
+struct decide_on_set;
+
+template <typename Node, typename... Nodes>
+struct decide_on_set<node_set<internal::order::following, Node, Nodes...>> {
+    using type = typename Node::output_type;
+};
+
+template <typename Node, typename... Nodes>
+struct decide_on_set<node_set<internal::order::preceding, Node, Nodes...>> {
+    using type = typename Node::input_type;
+};
+
+template <typename NodeSet>
+using decide_on_set_t = typename decide_on_set<std::decay_t<NodeSet>>::type;
+
+template <typename NodeSet>
+broadcast_node(const NodeSet&)
+->broadcast_node<decide_on_set_t<NodeSet>>;
+
+template <typename NodeSet>
+buffer_node(const NodeSet&)
+->buffer_node<decide_on_set_t<NodeSet>>;
+
+template <typename NodeSet>
+queue_node(const NodeSet&)
+->queue_node<decide_on_set_t<NodeSet>>;
+#endif // __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+
+template <typename GraphOrProxy, typename Sequencer>
+sequencer_node(GraphOrProxy&&, Sequencer)
+->sequencer_node<input_t<decltype(decide_on_callable_type<Sequencer>(0))>>;
+
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+template <typename NodeSet, typename Compare>
+priority_queue_node(const NodeSet&, const Compare&)
+->priority_queue_node<decide_on_set_t<NodeSet>, Compare>;
+
+template <typename NodeSet>
+priority_queue_node(const NodeSet&)
+->priority_queue_node<decide_on_set_t<NodeSet>, std::less<decide_on_set_t<NodeSet>>>;
+#endif // __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+
+template <typename Key>
+struct join_key {
+    using type = Key;
+};
+
+template <typename T>
+struct join_key<const T&> {
+    using type = T&;
+};
+
+template <typename Key>
+using join_key_t = typename join_key<Key>::type;
+
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+template <typename Policy, typename... Predecessors>
+join_node(const node_set<internal::order::following, Predecessors...>&, Policy)
+->join_node<std::tuple<typename Predecessors::output_type...>,
+            Policy>;
+
+template <typename Policy, typename Successor, typename... Successors>
+join_node(const node_set<internal::order::preceding, Successor, Successors...>&, Policy)
+->join_node<typename Successor::input_type, Policy>;
+
+template <typename... Predecessors>
+join_node(const node_set<internal::order::following, Predecessors...>)
+->join_node<std::tuple<typename Predecessors::output_type...>,
+            queueing>;
+
+template <typename Successor, typename... Successors>
+join_node(const node_set<internal::order::preceding, Successor, Successors...>)
+->join_node<typename Successor::input_type, queueing>;
+#endif
+
+template <typename GraphOrProxy, typename Body, typename... Bodies>
+join_node(GraphOrProxy&&, Body, Bodies...)
+->join_node<std::tuple<input_t<decltype(decide_on_callable_type<Body>(0))>,
+                       input_t<decltype(decide_on_callable_type<Bodies>(0))>...>,
+            key_matching<join_key_t<output_t<decltype(decide_on_callable_type<Body>(0))>>>>;
+
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+template <typename... Predecessors>
+indexer_node(const node_set<internal::order::following, Predecessors...>&)
+->indexer_node<typename Predecessors::output_type...>;
+#endif
+
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+template <typename NodeSet>
+limiter_node(const NodeSet&, size_t)
+->limiter_node<decide_on_set_t<NodeSet>>;
+
+template <typename Predecessor, typename... Predecessors>
+split_node(const node_set<internal::order::following, Predecessor, Predecessors...>&)
+->split_node<typename Predecessor::output_type>;
+
+template <typename... Successors>
+split_node(const node_set<internal::order::preceding, Successors...>&)
+->split_node<std::tuple<typename Successors::input_type...>>;
+
+#endif
+
+template <typename GraphOrSet, typename Body, typename Policy>
+function_node(GraphOrSet&&,
+              size_t, Body,
+            __TBB_FLOW_GRAPH_PRIORITY_ARG1(Policy, node_priority_t = tbb::flow::internal::no_priority))
+->function_node<input_t<decltype(decide_on_callable_type<Body>(0))>,
+                output_t<decltype(decide_on_callable_type<Body>(0))>,
+                Policy>;
+
+template <typename GraphOrSet, typename Body>
+function_node(GraphOrSet&&, size_t,
+              __TBB_FLOW_GRAPH_PRIORITY_ARG1(Body, node_priority_t = tbb::flow::internal::no_priority))
+->function_node<input_t<decltype(decide_on_callable_type<Body>(0))>,
+                output_t<decltype(decide_on_callable_type<Body>(0))>,
+                queueing>;
+
+template <typename Output>
+struct continue_output {
+    using type = Output;
+};
+
+template <>
+struct continue_output<void> {
+    using type = continue_msg;
+};
+
+template <typename T>
+using continue_output_t = typename continue_output<T>::type;
+
+template <typename GraphOrSet, typename Body, typename Policy>
+continue_node(GraphOrSet&&, Body,
+              __TBB_FLOW_GRAPH_PRIORITY_ARG1(Policy, node_priority_t = tbb::flow::internal::no_priority))
+->continue_node<continue_output_t<std::invoke_result_t<Body, continue_msg>>,
+                Policy>;
+
+template <typename GraphOrSet, typename Body, typename Policy>
+continue_node(GraphOrSet&&,
+              int, Body,
+              __TBB_FLOW_GRAPH_PRIORITY_ARG1(Policy, node_priority_t = tbb::flow::internal::no_priority))
+->continue_node<continue_output_t<std::invoke_result_t<Body, continue_msg>>,
+                Policy>;
+
+template <typename GraphOrSet, typename Body>
+continue_node(GraphOrSet&&,
+              __TBB_FLOW_GRAPH_PRIORITY_ARG1(Body, node_priority_t = tbb::flow::internal::no_priority))
+->continue_node<continue_output_t<std::invoke_result_t<Body, continue_msg>>,
+                internal::Policy<void>>;
+
+template <typename GraphOrSet, typename Body>
+continue_node(GraphOrSet&&, int,
+              __TBB_FLOW_GRAPH_PRIORITY_ARG1(Body, node_priority_t = tbb::flow::internal::no_priority))
+->continue_node<continue_output_t<std::invoke_result_t<Body, continue_msg>>,
+                internal::Policy<void>>;
+
+#if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+
+template <typename NodeSet>
+overwrite_node(const NodeSet&)
+->overwrite_node<decide_on_set_t<NodeSet>>;
+
+template <typename NodeSet>
+write_once_node(const NodeSet&)
+->write_once_node<decide_on_set_t<NodeSet>>;
+#endif // __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+} // namespace interfaceX
+} // namespace flow
+} // namespace tbb
+
+#endif // __TBB_CPP17_DEDUCTION_GUIDES_PRESENT
+#endif // __TBB_flow_graph_nodes_deduction_H
diff --git a/src/tbb/include/tbb/internal/_flow_graph_streaming_node.h b/src/tbb/include/tbb/internal/_flow_graph_streaming_node.h
index 493f76e8..4ef990bf 100644
--- a/src/tbb/include/tbb/internal/_flow_graph_streaming_node.h
+++ b/src/tbb/include/tbb/internal/_flow_graph_streaming_node.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_flow_graph_streaming_H
@@ -42,7 +38,7 @@ struct port_ref_impl {
 // The purpose of the port_ref_impl is the pretty syntax: the deduction of a compile-time constant is processed from the return type.
 // So it is possible to use this helper without parentheses, e.g. "port_ref<0>".
 template <int N1, int N2 = N1>
-internal::port_ref_impl<N1,N2> port_ref() {
+__TBB_DEPRECATED internal::port_ref_impl<N1,N2> port_ref() {
     return internal::port_ref_impl<N1,N2>();
 };
 
@@ -303,10 +299,11 @@ O---O              |   |                      O---O           |   |
 \--------------------------------------------------------------------------------------------/
 */
 template<typename... Args>
-class streaming_node;
+class __TBB_DEPRECATED streaming_node;
 
 template<typename... Ports, typename JP, typename StreamFactory>
-class streaming_node< tuple<Ports...>, JP, StreamFactory >
+class __TBB_DEPRECATED
+streaming_node< tuple<Ports...>, JP, StreamFactory >
     : public composite_node < typename internal::streaming_node_traits<JP, StreamFactory, Ports...>::input_tuple,
                               typename internal::streaming_node_traits<JP, StreamFactory, Ports...>::output_tuple >
     , public internal::kernel_executor_helper< StreamFactory, typename internal::streaming_node_traits<JP, StreamFactory, Ports...>::kernel_input_tuple >
@@ -466,6 +463,7 @@ class streaming_node< tuple<Ports...>, JP, StreamFactory >
         device_selector_base *my_device_selector;
     };
 
+    // TODO: investigate why copy-construction is disallowed
     class args_storage_base : tbb::internal::no_copy {
     public:
         typedef typename kernel_multifunction_node::output_ports_type output_ports_type;
@@ -481,7 +479,7 @@ class streaming_node< tuple<Ports...>, JP, StreamFactory >
         {}
 
         args_storage_base( const args_storage_base &k )
-            : my_kernel( k.my_kernel ), my_factory( k.my_factory )
+            : tbb::internal::no_copy(), my_kernel( k.my_kernel ), my_factory( k.my_factory )
         {}
 
         const kernel_type my_kernel;
diff --git a/src/tbb/include/tbb/internal/_flow_graph_tagged_buffer_impl.h b/src/tbb/include/tbb/internal/_flow_graph_tagged_buffer_impl.h
index 46755fe0..92291129 100644
--- a/src/tbb/include/tbb/internal/_flow_graph_tagged_buffer_impl.h
+++ b/src/tbb/include/tbb/internal/_flow_graph_tagged_buffer_impl.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 // a hash table buffer that can expand, and can support as many deletions as
diff --git a/src/tbb/include/tbb/internal/_flow_graph_trace_impl.h b/src/tbb/include/tbb/internal/_flow_graph_trace_impl.h
index 111810c3..65809c39 100644
--- a/src/tbb/include/tbb/internal/_flow_graph_trace_impl.h
+++ b/src/tbb/include/tbb/internal/_flow_graph_trace_impl.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,21 +12,48 @@
     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.
-
-
-
-
 */
 
 #ifndef _FGT_GRAPH_TRACE_IMPL_H
 #define _FGT_GRAPH_TRACE_IMPL_H
 
 #include "../tbb_profiling.h"
+#if (_MSC_VER >= 1900)
+    #include <intrin.h>
+#endif
 
 namespace tbb {
     namespace internal {
 
+#if TBB_USE_THREADING_TOOLS
+    #if TBB_PREVIEW_FLOW_GRAPH_TRACE
+        #if (_MSC_VER >= 1900)
+            #define CODEPTR() (_ReturnAddress())
+        #elif __TBB_GCC_VERSION >= 40800
+            #define CODEPTR() ( __builtin_return_address(0))
+        #else
+            #define CODEPTR() NULL
+        #endif
+    #else
+        #define CODEPTR() NULL
+    #endif /* TBB_PREVIEW_FLOW_GRAPH_TRACE */
+
+static inline void fgt_alias_port(void *node, void *p, bool visible) {
+    if(visible)
+        itt_relation_add( ITT_DOMAIN_FLOW, node, FLOW_NODE, __itt_relation_is_parent_of, p, FLOW_NODE );
+    else
+        itt_relation_add( ITT_DOMAIN_FLOW, p, FLOW_NODE, __itt_relation_is_child_of, node, FLOW_NODE );
+}
+
+static inline void fgt_composite ( void* codeptr, void *node, void *graph ) {
+    itt_make_task_group( ITT_DOMAIN_FLOW, node, FLOW_NODE, graph, FLOW_GRAPH, FLOW_COMPOSITE_NODE );
+    suppress_unused_warning( codeptr );
 #if TBB_PREVIEW_FLOW_GRAPH_TRACE
+    if (codeptr != NULL) {
+        register_node_addr(ITT_DOMAIN_FLOW, node, FLOW_NODE, CODE_ADDRESS, &codeptr);
+    }
+#endif
+}
 
 static inline void fgt_internal_alias_input_port( void *node, void *p, string_index name_index ) {
     itt_make_task_group( ITT_DOMAIN_FLOW, p, FLOW_INPUT_PORT, node, FLOW_NODE, name_index );
@@ -81,14 +108,23 @@ static inline void fgt_internal_create_input_port( void *node, void *p, string_i
     itt_make_task_group( ITT_DOMAIN_FLOW, p, FLOW_INPUT_PORT, node, FLOW_NODE, name_index );
 }
 
-static inline void fgt_internal_create_output_port( void *node, void *p, string_index name_index ) {
-    itt_make_task_group( ITT_DOMAIN_FLOW, p, FLOW_OUTPUT_PORT, node, FLOW_NODE, name_index );
+static inline void fgt_internal_create_output_port( void* codeptr, void *node, void *p, string_index name_index ) {
+    itt_make_task_group(ITT_DOMAIN_FLOW, p, FLOW_OUTPUT_PORT, node, FLOW_NODE, name_index);
+    suppress_unused_warning( codeptr );
+#if TBB_PREVIEW_FLOW_GRAPH_TRACE
+    if (codeptr != NULL) {
+        register_node_addr(ITT_DOMAIN_FLOW, node, FLOW_NODE, CODE_ADDRESS, &codeptr);
+    }
+#endif
 }
 
 template<typename InputType>
 void register_input_port(void *node, tbb::flow::receiver<InputType>* port, string_index name_index) {
     // TODO: Make fgt_internal_create_input_port a function template?
-    fgt_internal_create_input_port( node, port, name_index);
+    // In C++03 dependent name lookup from the template definition context
+    // works only for function declarations with external linkage:
+    // http://www.open-std.org/JTC1/SC22/WG21/docs/cwg_defects.html#561
+    fgt_internal_create_input_port(node, static_cast<void*>(port), name_index);
 }
 
 template < typename PortsTuple, int N >
@@ -107,23 +143,23 @@ struct fgt_internal_input_helper<PortsTuple, 1> {
 };
 
 template<typename OutputType>
-void register_output_port(void *node, tbb::flow::sender<OutputType>* port, string_index name_index) {
+void register_output_port(void* codeptr, void *node, tbb::flow::sender<OutputType>* port, string_index name_index) {
     // TODO: Make fgt_internal_create_output_port a function template?
-    fgt_internal_create_output_port( node, static_cast<void *>(port), name_index);
+    fgt_internal_create_output_port( codeptr, node, static_cast<void *>(port), name_index);
 }
 
 template < typename PortsTuple, int N >
 struct fgt_internal_output_helper {
-    static void register_port( void *node, PortsTuple &ports ) {
-        register_output_port( node, &(tbb::flow::get<N-1>(ports)), static_cast<tbb::internal::string_index>(FLOW_OUTPUT_PORT_0 + N - 1) );
-        fgt_internal_output_helper<PortsTuple, N-1>::register_port( node, ports );
+    static void register_port( void* codeptr, void *node, PortsTuple &ports ) {
+        register_output_port( codeptr, node, &(tbb::flow::get<N-1>(ports)), static_cast<tbb::internal::string_index>(FLOW_OUTPUT_PORT_0 + N - 1) );
+        fgt_internal_output_helper<PortsTuple, N-1>::register_port( codeptr, node, ports );
     }
 };
 
 template < typename PortsTuple >
 struct fgt_internal_output_helper<PortsTuple,1> {
-    static void register_port( void *node, PortsTuple &ports ) {
-        register_output_port( node, &(tbb::flow::get<0>(ports)), FLOW_OUTPUT_PORT_0 );
+    static void register_port( void* codeptr, void *node, PortsTuple &ports ) {
+        register_output_port( codeptr, node, &(tbb::flow::get<0>(ports)), FLOW_OUTPUT_PORT_0 );
     }
 };
 
@@ -154,56 +190,61 @@ static inline void fgt_body( void *node, void *body ) {
 }
 
 template< int N, typename PortsTuple >
-static inline void fgt_multioutput_node( string_index t, void *g, void *input_port, PortsTuple &ports ) {
+static inline void fgt_multioutput_node(void* codeptr, string_index t, void *g, void *input_port, PortsTuple &ports ) {
     itt_make_task_group( ITT_DOMAIN_FLOW, input_port, FLOW_NODE, g, FLOW_GRAPH, t );
     fgt_internal_create_input_port( input_port, input_port, FLOW_INPUT_PORT_0 );
-    fgt_internal_output_helper<PortsTuple, N>::register_port( input_port, ports );
+    fgt_internal_output_helper<PortsTuple, N>::register_port(codeptr, input_port, ports );
 }
 
 template< int N, typename PortsTuple >
-static inline void fgt_multioutput_node_with_body( string_index t, void *g, void *input_port, PortsTuple &ports, void *body ) {
+static inline void fgt_multioutput_node_with_body( void* codeptr, string_index t, void *g, void *input_port, PortsTuple &ports, void *body ) {
     itt_make_task_group( ITT_DOMAIN_FLOW, input_port, FLOW_NODE, g, FLOW_GRAPH, t );
     fgt_internal_create_input_port( input_port, input_port, FLOW_INPUT_PORT_0 );
-    fgt_internal_output_helper<PortsTuple, N>::register_port( input_port, ports );
+    fgt_internal_output_helper<PortsTuple, N>::register_port( codeptr, input_port, ports );
     fgt_body( input_port, body );
 }
 
 template< int N, typename PortsTuple >
-static inline void fgt_multiinput_node( string_index t, void *g, PortsTuple &ports, void *output_port) {
+static inline void fgt_multiinput_node( void* codeptr, string_index t, void *g, PortsTuple &ports, void *output_port) {
     itt_make_task_group( ITT_DOMAIN_FLOW, output_port, FLOW_NODE, g, FLOW_GRAPH, t );
-    fgt_internal_create_output_port( output_port, output_port, FLOW_OUTPUT_PORT_0 );
+    fgt_internal_create_output_port( codeptr, output_port, output_port, FLOW_OUTPUT_PORT_0 );
     fgt_internal_input_helper<PortsTuple, N>::register_port( output_port, ports );
 }
 
-static inline void fgt_multiinput_multioutput_node( string_index t, void *n, void *g ) {
+static inline void fgt_multiinput_multioutput_node( void* codeptr, string_index t, void *n, void *g ) {
     itt_make_task_group( ITT_DOMAIN_FLOW, n, FLOW_NODE, g, FLOW_GRAPH, t );
+    suppress_unused_warning( codeptr );
+#if TBB_PREVIEW_FLOW_GRAPH_TRACE
+    if (codeptr != NULL) {
+        register_node_addr(ITT_DOMAIN_FLOW, n, FLOW_NODE, CODE_ADDRESS, &codeptr);
+    }
+#endif
 }
 
-static inline void fgt_node( string_index t, void *g, void *output_port ) {
+static inline void fgt_node( void* codeptr, string_index t, void *g, void *output_port ) {
     itt_make_task_group( ITT_DOMAIN_FLOW, output_port, FLOW_NODE, g, FLOW_GRAPH, t );
-    fgt_internal_create_output_port( output_port, output_port, FLOW_OUTPUT_PORT_0 );
+    fgt_internal_create_output_port( codeptr, output_port, output_port, FLOW_OUTPUT_PORT_0 );
 }
 
-static inline void fgt_node_with_body( string_index t, void *g, void *output_port, void *body ) {
+static void fgt_node_with_body( void* codeptr, string_index t, void *g, void *output_port, void *body ) {
     itt_make_task_group( ITT_DOMAIN_FLOW, output_port, FLOW_NODE, g, FLOW_GRAPH, t );
-    fgt_internal_create_output_port( output_port, output_port, FLOW_OUTPUT_PORT_0 );
+    fgt_internal_create_output_port(codeptr, output_port, output_port, FLOW_OUTPUT_PORT_0 );
     fgt_body( output_port, body );
 }
 
-
-static inline void fgt_node( string_index t, void *g, void *input_port, void *output_port ) {
-    fgt_node( t, g, output_port );
+static inline void fgt_node( void* codeptr, string_index t, void *g, void *input_port, void *output_port ) {
+    fgt_node( codeptr, t, g, output_port );
     fgt_internal_create_input_port( output_port, input_port, FLOW_INPUT_PORT_0 );
 }
 
-static inline void fgt_node_with_body( string_index t, void *g, void *input_port, void *output_port, void *body ) {
-    fgt_node_with_body( t, g, output_port, body );
+static inline void  fgt_node_with_body( void* codeptr, string_index t, void *g, void *input_port, void *output_port, void *body ) {
+    fgt_node_with_body( codeptr, t, g, output_port, body );
     fgt_internal_create_input_port( output_port, input_port, FLOW_INPUT_PORT_0 );
 }
 
 
-static inline void  fgt_node( string_index t, void *g, void *input_port, void *decrement_port, void *output_port ) {
-    fgt_node( t, g, input_port, output_port );
+static inline void  fgt_node( void* codeptr, string_index t, void *g, void *input_port, void *decrement_port, void *output_port ) {
+    fgt_node( codeptr, t, g, input_port, output_port );
     fgt_internal_create_input_port( output_port, decrement_port, FLOW_INPUT_PORT_1 );
 }
 
@@ -239,7 +280,7 @@ static inline void fgt_async_reserve( void *node, void *graph ) {
     itt_region_begin( ITT_DOMAIN_FLOW, node, FLOW_NODE, graph, FLOW_GRAPH, FLOW_NULL );
 }
 
-static inline void fgt_async_commit( void *node, void *graph ) {
+static inline void fgt_async_commit( void *node, void * /*graph*/) {
     itt_region_end( ITT_DOMAIN_FLOW, node, FLOW_NODE );
 }
 
@@ -251,7 +292,13 @@ static inline void fgt_release_wait( void *graph ) {
     itt_region_end( ITT_DOMAIN_FLOW, graph, FLOW_GRAPH );
 }
 
-#else // TBB_PREVIEW_FLOW_GRAPH_TRACE
+#else // TBB_USE_THREADING_TOOLS
+
+#define CODEPTR() NULL
+
+static inline void fgt_alias_port(void * /*node*/, void * /*p*/, bool /*visible*/ ) { }
+
+static inline void fgt_composite ( void* /*codeptr*/, void * /*node*/, void * /*graph*/ ) { }
 
 static inline void fgt_graph( void * /*g*/ ) { }
 
@@ -266,22 +313,22 @@ static inline void fgt_graph_desc( void * /*g*/, const char * /*desc*/ ) { }
 static inline void fgt_body( void * /*node*/, void * /*body*/ ) { }
 
 template< int N, typename PortsTuple >
-static inline void fgt_multioutput_node( string_index /*t*/, void * /*g*/, void * /*input_port*/, PortsTuple & /*ports*/ ) { }
+static inline void fgt_multioutput_node( void* /*codeptr*/, string_index /*t*/, void * /*g*/, void * /*input_port*/, PortsTuple & /*ports*/ ) { }
 
 template< int N, typename PortsTuple >
-static inline void fgt_multioutput_node_with_body( string_index /*t*/, void * /*g*/, void * /*input_port*/, PortsTuple & /*ports*/, void * /*body*/ ) { }
+static inline void fgt_multioutput_node_with_body( void* /*codeptr*/, string_index /*t*/, void * /*g*/, void * /*input_port*/, PortsTuple & /*ports*/, void * /*body*/ ) { }
 
 template< int N, typename PortsTuple >
-static inline void fgt_multiinput_node( string_index /*t*/, void * /*g*/, PortsTuple & /*ports*/, void * /*output_port*/ ) { }
+static inline void fgt_multiinput_node( void* /*codeptr*/, string_index /*t*/, void * /*g*/, PortsTuple & /*ports*/, void * /*output_port*/ ) { }
 
-static inline void fgt_multiinput_multioutput_node( string_index /*t*/, void * /*node*/, void * /*graph*/ ) { }
+static inline void fgt_multiinput_multioutput_node( void* /*codeptr*/, string_index /*t*/, void * /*node*/, void * /*graph*/ ) { }
 
-static inline void fgt_node( string_index /*t*/, void * /*g*/, void * /*output_port*/ ) { }
-static inline void fgt_node( string_index /*t*/, void * /*g*/, void * /*input_port*/, void * /*output_port*/ ) { }
-static inline void  fgt_node( string_index /*t*/, void * /*g*/, void * /*input_port*/, void * /*decrement_port*/, void * /*output_port*/ ) { }
+static inline void fgt_node( void* /*codeptr*/, string_index /*t*/, void * /*g*/, void * /*output_port*/ ) { }
+static inline void fgt_node( void* /*codeptr*/, string_index /*t*/, void * /*g*/, void * /*input_port*/, void * /*output_port*/ ) { }
+static inline void  fgt_node( void* /*codeptr*/, string_index /*t*/, void * /*g*/, void * /*input_port*/, void * /*decrement_port*/, void * /*output_port*/ ) { }
 
-static inline void fgt_node_with_body( string_index /*t*/, void * /*g*/, void * /*output_port*/, void * /*body*/ ) { }
-static inline void fgt_node_with_body( string_index /*t*/, void * /*g*/, void * /*input_port*/, void * /*output_port*/, void * /*body*/ ) { }
+static inline void fgt_node_with_body( void* /*codeptr*/, string_index /*t*/, void * /*g*/, void * /*output_port*/, void * /*body*/ ) { }
+static inline void fgt_node_with_body( void* /*codeptr*/, string_index /*t*/, void * /*g*/, void * /*input_port*/, void * /*output_port*/, void * /*body*/ ) { }
 
 static inline void fgt_make_edge( void * /*output_port*/, void * /*input_port*/ ) { }
 static inline void fgt_remove_edge( void * /*output_port*/, void * /*input_port*/ ) { }
@@ -296,7 +343,20 @@ static inline void fgt_async_commit( void * /*node*/, void * /*graph*/ ) { }
 static inline void fgt_reserve_wait( void * /*graph*/ ) { }
 static inline void fgt_release_wait( void * /*graph*/ ) { }
 
-#endif // TBB_PREVIEW_FLOW_GRAPH_TRACE
+template< typename NodeType >
+void fgt_multiinput_multioutput_node_desc( const NodeType * /*node*/, const char * /*desc*/ ) { }
+
+template < typename PortsTuple, int N >
+struct fgt_internal_input_alias_helper {
+    static void alias_port( void * /*node*/, PortsTuple & /*ports*/ ) { }
+};
+
+template < typename PortsTuple, int N >
+struct fgt_internal_output_alias_helper {
+    static void alias_port( void * /*node*/, PortsTuple & /*ports*/ ) { }
+};
+
+#endif // TBB_USE_THREADING_TOOLS
 
     } // namespace internal
 } // namespace tbb
diff --git a/src/tbb/include/tbb/internal/_flow_graph_types_impl.h b/src/tbb/include/tbb/internal/_flow_graph_types_impl.h
index 73b5f547..f374831b 100644
--- a/src/tbb/include/tbb/internal/_flow_graph_types_impl.h
+++ b/src/tbb/include/tbb/internal/_flow_graph_types_impl.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB__flow_graph_types_impl_H
@@ -48,7 +44,7 @@ namespace internal {
         typedef KHashp KHash;
     };
 
-// wrap each element of a tuple in a template, and make a tuple of the result.
+    // wrap each element of a tuple in a template, and make a tuple of the result.
     template<int N, template<class> class PT, typename TypeTuple>
     struct wrap_tuple_elements;
 
@@ -57,6 +53,19 @@ namespace internal {
     template<int N, template<class> class PT, typename KeyTraits, typename TypeTuple>
     struct wrap_key_tuple_elements;
 
+#if __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT && __TBB_CPP11_VARIADIC_TUPLE_PRESENT
+    template<int N, template<class> class PT,  typename... Args>
+    struct wrap_tuple_elements<N, PT, tbb::flow::tuple<Args...> >{
+        typedef typename tbb::flow::tuple<PT<Args>... > type;
+    };
+
+    template<int N, template<class> class PT, typename KeyTraits, typename... Args>
+    struct wrap_key_tuple_elements<N, PT, KeyTraits, tbb::flow::tuple<Args...> > {
+        typedef typename KeyTraits::key_type K;
+        typedef typename KeyTraits::hash_compare_type KHash;
+        typedef typename tbb::flow::tuple<PT<KeyTrait<K, KHash, Args> >... > type;
+    };
+#else
     template<template<class> class PT, typename TypeTuple>
     struct wrap_tuple_elements<1, PT, TypeTuple> {
         typedef typename tbb::flow::tuple<
@@ -314,6 +323,7 @@ namespace internal {
                 PT<KeyTrait9> > type;
     };
 #endif
+#endif /* __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT && __TBB_CPP11_VARIADIC_TUPLE_PRESENT */
 
 #if __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT
     template< int... S > class sequence {};
diff --git a/src/tbb/include/tbb/internal/_mutex_padding.h b/src/tbb/include/tbb/internal/_mutex_padding.h
index 6c1d9b59..d26f5f48 100644
--- a/src/tbb/include/tbb/internal/_mutex_padding.h
+++ b/src/tbb/include/tbb/internal/_mutex_padding.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_mutex_padding_H
diff --git a/src/tbb/include/tbb/internal/_node_handle_impl.h b/src/tbb/include/tbb/internal/_node_handle_impl.h
new file mode 100644
index 00000000..2088aa8b
--- /dev/null
+++ b/src/tbb/include/tbb/internal/_node_handle_impl.h
@@ -0,0 +1,168 @@
+/*
+    Copyright (c) 2019-2020 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.
+*/
+
+#ifndef __TBB_node_handle_H
+#define __TBB_node_handle_H
+
+#include "_allocator_traits.h"
+#include "../tbb_config.h"
+
+
+namespace tbb {
+
+// This classes must be declared here for correct friendly relationship
+// TODO: Consider creation some internal class to access node_handle private fields without any friendly classes
+namespace interface5 {
+namespace internal {
+    template <typename T, typename Allocator>
+    class split_ordered_list;
+    template <typename Traits>
+    class concurrent_unordered_base;
+}
+}
+
+namespace interface10{
+namespace internal {
+    template<typename Traits>
+    class concurrent_skip_list;
+}
+}
+
+namespace internal {
+
+template<typename Value, typename Node, typename Allocator>
+class node_handle_base {
+public:
+    typedef Allocator allocator_type;
+protected:
+    typedef Node node;
+    typedef tbb::internal::allocator_traits<allocator_type> traits_type;
+public:
+
+    node_handle_base() : my_node(NULL), my_allocator() {}
+    node_handle_base(node_handle_base&& nh) : my_node(nh.my_node),
+                                              my_allocator(std::move(nh.my_allocator)) {
+        nh.my_node = NULL;
+    }
+
+    bool empty() const { return my_node == NULL; }
+    explicit operator bool() const { return my_node != NULL; }
+
+    ~node_handle_base() { internal_destroy(); }
+
+    node_handle_base& operator=(node_handle_base&& nh) {
+        internal_destroy();
+        my_node = nh.my_node;
+        typedef typename traits_type::propagate_on_container_move_assignment pocma_type;
+        tbb::internal::allocator_move_assignment(my_allocator, nh.my_allocator, pocma_type());
+        nh.deactivate();
+        return *this;
+    }
+
+    void swap(node_handle_base& nh) {
+        std::swap(my_node, nh.my_node);
+        typedef typename traits_type::propagate_on_container_swap pocs_type;
+        tbb::internal::allocator_swap(my_allocator, nh.my_allocator, pocs_type());
+    }
+
+    allocator_type get_allocator() const {
+        return my_allocator;
+    }
+
+protected:
+    node_handle_base(node* n) : my_node(n) {}
+
+    void internal_destroy() {
+        if(my_node) {
+            traits_type::destroy(my_allocator, my_node->storage());
+            typename tbb::internal::allocator_rebind<allocator_type, node>::type node_allocator;
+            node_allocator.deallocate(my_node, 1);
+        }
+    }
+
+    void deactivate() { my_node = NULL; }
+
+    node* my_node;
+    allocator_type my_allocator;
+};
+
+// node handle for maps
+template<typename Key, typename Value, typename Node, typename Allocator>
+class node_handle : public node_handle_base<Value, Node, Allocator> {
+    typedef node_handle_base<Value, Node, Allocator> base_type;
+public:
+    typedef Key key_type;
+    typedef typename Value::second_type mapped_type;
+    typedef typename base_type::allocator_type allocator_type;
+
+    node_handle() : base_type() {}
+
+    key_type& key() const {
+        __TBB_ASSERT(!this->empty(), "Cannot get key from the empty node_type object");
+        return *const_cast<key_type*>(&(this->my_node->value().first));
+    }
+
+    mapped_type& mapped() const {
+        __TBB_ASSERT(!this->empty(), "Cannot get mapped value from the empty node_type object");
+        return this->my_node->value().second;
+    }
+
+private:
+    template<typename T, typename A>
+    friend class tbb::interface5::internal::split_ordered_list;
+
+    template<typename Traits>
+    friend class tbb::interface5::internal::concurrent_unordered_base;
+
+    template<typename Traits>
+    friend class tbb::interface10::internal::concurrent_skip_list;
+
+    node_handle(typename base_type::node* n) : base_type(n) {}
+};
+
+// node handle for sets
+template<typename Key, typename Node, typename Allocator>
+class node_handle<Key, Key, Node, Allocator> : public node_handle_base<Key, Node, Allocator> {
+    typedef node_handle_base<Key, Node, Allocator> base_type;
+public:
+    typedef Key value_type;
+    typedef typename base_type::allocator_type allocator_type;
+
+    node_handle() : base_type() {}
+
+    value_type& value() const {
+        __TBB_ASSERT(!this->empty(), "Cannot get value from the empty node_type object");
+        return *const_cast<value_type*>(&(this->my_node->value()));
+    }
+
+private:
+    template<typename T, typename A>
+    friend class tbb::interface5::internal::split_ordered_list;
+
+    template<typename Traits>
+    friend class tbb::interface5::internal::concurrent_unordered_base;
+
+    template<typename Traits>
+    friend class tbb::interface10::internal::concurrent_skip_list;
+
+    node_handle(typename base_type::node* n) : base_type(n) {}
+};
+
+
+}// namespace internal
+}// namespace tbb
+
+#endif /*__TBB_node_handle_H*/
diff --git a/src/tbb/include/tbb/internal/_range_iterator.h b/src/tbb/include/tbb/internal/_range_iterator.h
index 5ebc42e8..df00e88d 100644
--- a/src/tbb/include/tbb/internal/_range_iterator.h
+++ b/src/tbb/include/tbb/internal/_range_iterator.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_range_iterator_H
diff --git a/src/tbb/include/tbb/internal/_tbb_hash_compare_impl.h b/src/tbb/include/tbb/internal/_tbb_hash_compare_impl.h
index 6381e2dc..82f0df13 100644
--- a/src/tbb/include/tbb/internal/_tbb_hash_compare_impl.h
+++ b/src/tbb/include/tbb/internal/_tbb_hash_compare_impl.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 // must be included outside namespaces.
@@ -62,23 +58,23 @@ static const size_t hash_multiplier = tbb::internal::select_size_t_constant<2654
 
 //! Hasher functions
 template<typename T>
-inline size_t tbb_hasher( const T& t ) {
+__TBB_DEPRECATED_MSG("tbb::tbb_hasher is deprecated, use std::hash") inline size_t tbb_hasher( const T& t ) {
     return static_cast<size_t>( t ) * internal::hash_multiplier;
 }
 template<typename P>
-inline size_t tbb_hasher( P* ptr ) {
+__TBB_DEPRECATED_MSG("tbb::tbb_hasher is deprecated, use std::hash") inline size_t tbb_hasher( P* ptr ) {
     size_t const h = reinterpret_cast<size_t>( ptr );
     return (h >> 3) ^ h;
 }
 template<typename E, typename S, typename A>
-inline size_t tbb_hasher( const std::basic_string<E,S,A>& s ) {
+__TBB_DEPRECATED_MSG("tbb::tbb_hasher is deprecated, use std::hash") inline size_t tbb_hasher( const std::basic_string<E,S,A>& s ) {
     size_t h = 0;
     for( const E* c = s.c_str(); *c; ++c )
         h = static_cast<size_t>(*c) ^ (h * internal::hash_multiplier);
     return h;
 }
 template<typename F, typename S>
-inline size_t tbb_hasher( const std::pair<F,S>& p ) {
+__TBB_DEPRECATED_MSG("tbb::tbb_hasher is deprecated, use std::hash") inline size_t tbb_hasher( const std::pair<F,S>& p ) {
     return tbb_hasher(p.first) ^ tbb_hasher(p.second);
 }
 
@@ -87,7 +83,7 @@ using interface5::tbb_hasher;
 
 // Template class for hash compare
 template<typename Key>
-class tbb_hash
+class __TBB_DEPRECATED_MSG("tbb::tbb_hash is deprecated, use std::hash") tbb_hash
 {
 public:
     tbb_hash() {}
diff --git a/src/tbb/include/tbb/internal/_tbb_strings.h b/src/tbb/include/tbb/internal/_tbb_strings.h
index 5c836e64..df443f3f 100644
--- a/src/tbb/include/tbb/internal/_tbb_strings.h
+++ b/src/tbb/include/tbb/internal/_tbb_strings.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 TBB_STRING_RESOURCE(FLOW_BROADCAST_NODE, "broadcast_node")
@@ -66,6 +62,18 @@ TBB_STRING_RESOURCE(FLOW_INDEXER_NODE, "indexer_node")
 TBB_STRING_RESOURCE(FLOW_COMPOSITE_NODE, "composite_node")
 TBB_STRING_RESOURCE(FLOW_ASYNC_NODE, "async_node")
 TBB_STRING_RESOURCE(FLOW_OPENCL_NODE, "opencl_node")
-// TODO: Drop following string prefix "tbb_" here and in FGA's collector
-TBB_STRING_RESOURCE(FGT_ALGORITHM, "tbb_algorithm")
-TBB_STRING_RESOURCE(FGT_PARALLEL_FOR, "tbb_parallel_for")
+TBB_STRING_RESOURCE(ALGORITHM, "tbb_algorithm")
+TBB_STRING_RESOURCE(PARALLEL_FOR, "tbb_parallel_for")
+TBB_STRING_RESOURCE(PARALLEL_DO, "tbb_parallel_do")
+TBB_STRING_RESOURCE(PARALLEL_INVOKE, "tbb_parallel_invoke")
+TBB_STRING_RESOURCE(PARALLEL_REDUCE, "tbb_parallel_reduce")
+TBB_STRING_RESOURCE(PARALLEL_SCAN, "tbb_parallel_scan")
+TBB_STRING_RESOURCE(PARALLEL_SORT, "tbb_parallel_sort")
+TBB_STRING_RESOURCE(CUSTOM_CTX, "tbb_custom")
+TBB_STRING_RESOURCE(FLOW_TASKS, "tbb_flow_graph")
+TBB_STRING_RESOURCE(PARALLEL_FOR_TASK, "tbb_parallel_for_task")
+// TODO: Drop following string prefix "fgt_" here and in FGA's collector
+TBB_STRING_RESOURCE(USER_EVENT, "fgt_user_event")
+#if __TBB_CPF_BUILD || (TBB_PREVIEW_FLOW_GRAPH_TRACE && TBB_USE_THREADING_TOOLS)
+TBB_STRING_RESOURCE(CODE_ADDRESS, "code_address")
+#endif
diff --git a/src/tbb/include/tbb/internal/_tbb_trace_impl.h b/src/tbb/include/tbb/internal/_tbb_trace_impl.h
index e7eb5784..38dc68cf 100644
--- a/src/tbb/include/tbb/internal/_tbb_trace_impl.h
+++ b/src/tbb/include/tbb/internal/_tbb_trace_impl.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef _FGT_TBB_TRACE_IMPL_H
@@ -27,18 +23,17 @@ namespace tbb {
     namespace internal {
 
 #if TBB_PREVIEW_ALGORITHM_TRACE
-
         static inline void fgt_algorithm( string_index t, void *algorithm, void *parent ) {
-            itt_make_task_group( ITT_DOMAIN_FLOW, algorithm, FGT_ALGORITHM, parent, FGT_ALGORITHM, t );
+            itt_make_task_group( ITT_DOMAIN_FLOW, algorithm, ALGORITHM, parent, ALGORITHM, t );
         }
         static inline void fgt_begin_algorithm( string_index t, void *algorithm ) {
-            itt_task_begin( ITT_DOMAIN_FLOW, algorithm, FGT_ALGORITHM, NULL, FLOW_NULL, t );
+            itt_task_begin( ITT_DOMAIN_FLOW, algorithm, ALGORITHM, NULL, FLOW_NULL, t );
         }
         static inline void fgt_end_algorithm( void * ) {
             itt_task_end( ITT_DOMAIN_FLOW );
         }
         static inline void fgt_alg_begin_body( string_index t, void *body, void *algorithm ) {
-            itt_task_begin( ITT_DOMAIN_FLOW, body, FLOW_BODY, algorithm, FGT_ALGORITHM, t );
+            itt_task_begin( ITT_DOMAIN_FLOW, body, FLOW_BODY, algorithm, ALGORITHM, t );
         }
         static inline void fgt_alg_end_body( void * ) {
             itt_task_end( ITT_DOMAIN_FLOW );
diff --git a/src/tbb/include/tbb/internal/_tbb_windef.h b/src/tbb/include/tbb/internal/_tbb_windef.h
index e798dee4..b2eb9d5d 100644
--- a/src/tbb/include/tbb/internal/_tbb_windef.h
+++ b/src/tbb/include/tbb/internal/_tbb_windef.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,17 +12,13 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_tbb_windef_H
 #error Do not #include this internal file directly; use public TBB headers instead.
 #endif /* __TBB_tbb_windef_H */
 
-// Check that the target Windows version has all API calls requried for TBB.
+// Check that the target Windows version has all API calls required for TBB.
 // Do not increase the version in condition beyond 0x0500 without prior discussion!
 #if defined(_WIN32_WINNT) && _WIN32_WINNT<0x0501
 #error TBB is unable to run on old Windows versions; _WIN32_WINNT must be 0x0501 or greater.
@@ -54,7 +50,7 @@ namespace std {
 #    endif
 #endif
 
-#if (__TBB_BUILD || __TBBMALLOC_BUILD) && !defined(__TBB_NO_IMPLICIT_LINKAGE)
+#if (__TBB_BUILD || __TBBMALLOC_BUILD || __TBBBIND_BUILD) && !defined(__TBB_NO_IMPLICIT_LINKAGE)
 #define __TBB_NO_IMPLICIT_LINKAGE 1
 #endif
 
diff --git a/src/tbb/include/tbb/internal/_template_helpers.h b/src/tbb/include/tbb/internal/_template_helpers.h
index 1e0abbe8..08470430 100644
--- a/src/tbb/include/tbb/internal/_template_helpers.h
+++ b/src/tbb/include/tbb/internal/_template_helpers.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_template_helpers_H
@@ -23,6 +19,14 @@
 
 #include <utility>
 #include <cstddef>
+#include "../tbb_config.h"
+#if __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT && __TBB_CPP11_TEMPLATE_ALIASES_PRESENT
+#include <type_traits>
+#endif
+#if __TBB_CPP11_PRESENT
+#include <iterator>
+#include <memory> // allocator_traits
+#endif
 
 namespace tbb { namespace internal {
 
@@ -60,11 +64,41 @@ template<class W>          struct is_same_type<W,W> { static const bool value =
 template<typename T> struct is_ref { static const bool value = false; };
 template<typename U> struct is_ref<U&> { static const bool value = true; };
 
+//! Partial support for std::is_integral
+template<typename T> struct is_integral_impl             { static const bool value = false; };
+template<>           struct is_integral_impl<bool>       { static const bool value = true;  };
+template<>           struct is_integral_impl<char>       { static const bool value = true;  };
+#if __TBB_CPP11_PRESENT
+template<>           struct is_integral_impl<char16_t>   { static const bool value = true;  };
+template<>           struct is_integral_impl<char32_t>   { static const bool value = true;  };
+#endif
+template<>           struct is_integral_impl<wchar_t>    { static const bool value = true;  };
+template<>           struct is_integral_impl<short>      { static const bool value = true;  };
+template<>           struct is_integral_impl<int>        { static const bool value = true;  };
+template<>           struct is_integral_impl<long>       { static const bool value = true;  };
+template<>           struct is_integral_impl<long long>  { static const bool value = true;  };
+
+template<typename T>
+struct is_integral : is_integral_impl<typename strip<T>::type> {};
+
 #if __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT
 //! std::void_t internal implementation (to avoid GCC < 4.7 "template aliases" absence)
 template<typename...> struct void_t { typedef void type; };
 #endif
 
+#if __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT && __TBB_CPP11_TEMPLATE_ALIASES_PRESENT
+
+// Generic SFINAE helper for expression checks, based on the idea demonstrated in ISO C++ paper n4502
+template<typename T, typename, template<typename> class... Checks>
+struct supports_impl { typedef std::false_type type; };
+template<typename T, template<typename> class... Checks>
+struct supports_impl<T, typename void_t<Checks<T>...>::type, Checks...> { typedef std::true_type type; };
+
+template<typename T, template<typename> class... Checks>
+using supports = typename supports_impl<T, void, Checks...>::type;
+
+#endif /* __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT && __TBB_CPP11_TEMPLATE_ALIASES_PRESENT */
+
 #if __TBB_CPP11_RVALUE_REF_PRESENT && __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT
 
 //! Allows to store a function parameter pack as a variable and later pass it to another function
@@ -153,6 +187,125 @@ stored_pack<Types...> save_pack( Types&&... types ) {
 }
 
 #endif /* __TBB_CPP11_RVALUE_REF_PRESENT && __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT */
+
+#if __TBB_CPP14_INTEGER_SEQUENCE_PRESENT
+
+using std::index_sequence;
+using std::make_index_sequence;
+
+#elif __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT && __TBB_CPP11_TEMPLATE_ALIASES_PRESENT
+
+template<std::size_t... S> class index_sequence {};
+
+template<std::size_t N, std::size_t... S>
+struct make_index_sequence_impl : make_index_sequence_impl < N - 1, N - 1, S... > {};
+
+template<std::size_t... S>
+struct make_index_sequence_impl <0, S...> {
+    using type = index_sequence<S...>;
+};
+
+template<std::size_t N>
+using make_index_sequence = typename tbb::internal::make_index_sequence_impl<N>::type;
+
+#endif /* __TBB_CPP14_INTEGER_SEQUENCE_PRESENT */
+
+#if __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT
+template<typename... Args>
+struct conjunction;
+
+template<typename First, typename... Args>
+struct conjunction<First, Args...>
+    : std::conditional<bool(First::value), conjunction<Args...>, First>::type {};
+
+template<typename T>
+struct conjunction<T> : T {};
+
+template<>
+struct conjunction<> : std::true_type {};
+
+#endif
+
+#if __TBB_CPP11_PRESENT
+
+template< typename Iter >
+using iterator_value_t = typename std::iterator_traits<Iter>::value_type;
+
+template< typename Iter >
+using iterator_key_t = typename std::remove_const<typename iterator_value_t<Iter>::first_type>::type;
+
+template< typename Iter >
+using iterator_mapped_t = typename iterator_value_t<Iter>::second_type;
+
+template< typename A > using value_type = typename A::value_type;
+template< typename A > using alloc_ptr_t = typename std::allocator_traits<A>::pointer;
+template< typename A > using has_allocate = decltype(std::declval<alloc_ptr_t<A>&>() = std::declval<A>().allocate(0));
+template< typename A > using has_deallocate = decltype(std::declval<A>().deallocate(std::declval<alloc_ptr_t<A>>(), 0));
+
+// value_type should be checked first because it can be used in other checks (via allocator_traits)
+template< typename T >
+using is_allocator = supports<T, value_type, has_allocate, has_deallocate>;
+
+#if __TBB_CPP14_VARIABLE_TEMPLATES_PRESENT
+
+template< typename T >
+static constexpr bool is_allocator_v = is_allocator<T>::value;
+
+#endif /*__TBB_CPP14_VARIABLE_TEMPLATES */
+
+template< std::size_t N, typename... Args >
+struct pack_element {
+    using type = void;
+};
+
+template< std::size_t N, typename T, typename... Args >
+struct pack_element<N, T, Args...> {
+    using type = typename pack_element<N - 1, Args...>::type;
+};
+
+template< typename T, typename... Args >
+struct pack_element<0, T, Args...> {
+    using type = T;
+};
+
+template< std::size_t N, typename... Args >
+using pack_element_t = typename pack_element<N, Args...>::type;
+
+// Helper alias for heterogeneous lookup functions in containers
+// template parameter K and std::conditional are needed to provide immediate context
+// and postpone getting is_trasparent from the compare functor until method instantiation.
+template <typename Comp, typename K>
+using is_transparent = typename std::conditional<true, Comp, K>::type::is_transparent;
+
+#endif /* __TBB_CPP11_PRESENT */
+
+template <typename F>
+struct body_arg_detector;
+
+template <typename Callable, typename ReturnType, typename T>
+struct body_arg_detector<ReturnType(Callable::*)(T)> {
+    typedef T arg_type;
+};
+
+template <typename Callable, typename ReturnType, typename T>
+struct body_arg_detector<ReturnType(Callable::*)(T) const> {
+    typedef T arg_type;
+};
+
+#if __TBB_CPP11_PRESENT
+using std::conditional;
+#else
+template <bool C, typename T, typename U>
+struct conditional {
+    typedef U type;
+};
+
+template <typename T, typename U>
+struct conditional<true, T, U> {
+    typedef T type;
+};
+#endif
+
 } } // namespace internal, namespace tbb
 
 #endif /* __TBB_template_helpers_H */
diff --git a/src/tbb/include/tbb/internal/_warning_suppress_disable_notice.h b/src/tbb/include/tbb/internal/_warning_suppress_disable_notice.h
new file mode 100644
index 00000000..1b536463
--- /dev/null
+++ b/src/tbb/include/tbb/internal/_warning_suppress_disable_notice.h
@@ -0,0 +1,27 @@
+/*
+    Copyright (c) 2005-2020 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 __TBB_SUPPRESS_INTERNAL_DEPRECATED_MESSAGES
+
+#if __INTEL_COMPILER || _MSC_VER
+#pragma warning( pop )
+#elif __GNUC__
+#pragma GCC diagnostic pop
+#elif __clang__
+#pragma clang diagnostic pop
+#endif
+
+#endif  // __TBB_SUPPRESS_INTERNAL_DEPRECATED_MESSAGES
diff --git a/src/tbb/include/tbb/internal/_warning_suppress_enable_notice.h b/src/tbb/include/tbb/internal/_warning_suppress_enable_notice.h
new file mode 100644
index 00000000..3b927231
--- /dev/null
+++ b/src/tbb/include/tbb/internal/_warning_suppress_enable_notice.h
@@ -0,0 +1,32 @@
+/*
+    Copyright (c) 2005-2020 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 "../tbb_config.h"
+
+#if __TBB_SUPPRESS_INTERNAL_DEPRECATED_MESSAGES
+
+#if _MSC_VER || __INTEL_COMPILER
+#pragma warning( push )
+#pragma warning( disable: 4996 )
+#elif __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#elif __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+#endif
+
+#endif  // __TBB_SUPPRESS_INTERNAL_DEPRECATED_MESSAGES
diff --git a/src/tbb/include/tbb/internal/_x86_eliding_mutex_impl.h b/src/tbb/include/tbb/internal/_x86_eliding_mutex_impl.h
index ef5f9223..11be329d 100644
--- a/src/tbb/include/tbb/internal/_x86_eliding_mutex_impl.h
+++ b/src/tbb/include/tbb/internal/_x86_eliding_mutex_impl.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB__x86_eliding_mutex_impl_H
diff --git a/src/tbb/include/tbb/internal/_x86_rtm_rw_mutex_impl.h b/src/tbb/include/tbb/internal/_x86_rtm_rw_mutex_impl.h
index b08c2331..9373aaa0 100644
--- a/src/tbb/include/tbb/internal/_x86_rtm_rw_mutex_impl.h
+++ b/src/tbb/include/tbb/internal/_x86_rtm_rw_mutex_impl.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB__x86_rtm_rw_mutex_impl_H
@@ -88,11 +84,11 @@ class x86_rtm_rw_mutex: private spin_rw_mutex {
 
     static x86_rtm_rw_mutex* internal_get_mutex( const spin_rw_mutex::scoped_lock& lock )
     {
-        return static_cast<x86_rtm_rw_mutex*>( lock.internal_get_mutex() );
+        return static_cast<x86_rtm_rw_mutex*>( lock.mutex );
     }
     static void internal_set_mutex( spin_rw_mutex::scoped_lock& lock, spin_rw_mutex* mtx )
     {
-        lock.internal_set_mutex( mtx );
+        lock.mutex = mtx;
     }
     //! @endcond
 public:
@@ -171,7 +167,8 @@ class x86_rtm_rw_mutex: private spin_rw_mutex {
         bool upgrade_to_writer() {
             x86_rtm_rw_mutex* mutex = x86_rtm_rw_mutex::internal_get_mutex(my_scoped_lock);
             __TBB_ASSERT( mutex, "lock is not acquired" );
-            __TBB_ASSERT( transaction_state==RTM_transacting_reader || transaction_state==RTM_real_reader, "Invalid state for upgrade" );
+            if (transaction_state == RTM_transacting_writer || transaction_state == RTM_real_writer)
+                return true; // Already a writer
             return mutex->internal_upgrade(*this);
         }
 
@@ -180,7 +177,8 @@ class x86_rtm_rw_mutex: private spin_rw_mutex {
         bool downgrade_to_reader() {
             x86_rtm_rw_mutex* mutex = x86_rtm_rw_mutex::internal_get_mutex(my_scoped_lock);
             __TBB_ASSERT( mutex, "lock is not acquired" );
-            __TBB_ASSERT( transaction_state==RTM_transacting_writer || transaction_state==RTM_real_writer, "Invalid state for downgrade" );
+            if (transaction_state == RTM_transacting_reader || transaction_state == RTM_real_reader)
+                return true; // Already a reader
             return mutex->internal_downgrade(*this);
         }
 
diff --git a/src/tbb/include/tbb/iterators.h b/src/tbb/include/tbb/iterators.h
new file mode 100644
index 00000000..2d4da9c9
--- /dev/null
+++ b/src/tbb/include/tbb/iterators.h
@@ -0,0 +1,326 @@
+/*
+    Copyright (c) 2017-2020 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.
+*/
+
+#ifndef __TBB_iterators_H
+#define __TBB_iterators_H
+
+#include <iterator>
+#include <limits>
+
+#include "tbb_config.h"
+#include "tbb_stddef.h"
+
+#if __TBB_CPP11_PRESENT
+
+#include <type_traits>
+
+namespace tbb {
+
+template <typename IntType>
+class counting_iterator {
+    __TBB_STATIC_ASSERT(std::numeric_limits<IntType>::is_integer, "Cannot instantiate counting_iterator with a non-integer type");
+public:
+    typedef typename std::make_signed<IntType>::type difference_type;
+    typedef IntType value_type;
+    typedef const IntType* pointer;
+    typedef const IntType& reference;
+    typedef std::random_access_iterator_tag iterator_category;
+
+    counting_iterator() : my_counter() {}
+    explicit counting_iterator(IntType init) : my_counter(init) {}
+
+    reference operator*() const { return my_counter; }
+    value_type operator[](difference_type i) const { return *(*this + i); }
+
+    difference_type operator-(const counting_iterator& it) const { return my_counter - it.my_counter; }
+
+    counting_iterator& operator+=(difference_type forward) { my_counter += forward; return *this; }
+    counting_iterator& operator-=(difference_type backward) { return *this += -backward; }
+    counting_iterator& operator++() { return *this += 1; }
+    counting_iterator& operator--() { return *this -= 1; }
+
+    counting_iterator operator++(int) {
+        counting_iterator it(*this);
+        ++(*this);
+        return it;
+    }
+    counting_iterator operator--(int) {
+        counting_iterator it(*this);
+        --(*this);
+        return it;
+    }
+
+    counting_iterator operator-(difference_type backward) const { return counting_iterator(my_counter - backward); }
+    counting_iterator operator+(difference_type forward) const { return counting_iterator(my_counter + forward); }
+    friend counting_iterator operator+(difference_type forward, const counting_iterator it) { return it + forward; }
+
+    bool operator==(const counting_iterator& it) const { return *this - it == 0; }
+    bool operator!=(const counting_iterator& it) const { return !(*this == it); }
+    bool operator<(const counting_iterator& it) const {return *this - it < 0; }
+    bool operator>(const counting_iterator& it) const { return it < *this; }
+    bool operator<=(const counting_iterator& it) const { return !(*this > it); }
+    bool operator>=(const counting_iterator& it) const { return !(*this < it); }
+
+private:
+    IntType my_counter;
+};
+} //namespace tbb
+
+
+#include <tuple>
+
+#include "internal/_template_helpers.h" // index_sequence, make_index_sequence
+
+namespace tbb {
+namespace internal {
+
+template<size_t N>
+struct tuple_util {
+    template<typename TupleType, typename DifferenceType>
+    static void increment(TupleType& it, DifferenceType forward) {
+        std::get<N-1>(it) += forward;
+        tuple_util<N-1>::increment(it, forward);
+    }
+    template<typename TupleType, typename DifferenceType>
+    static bool check_sync(const TupleType& it1, const TupleType& it2, DifferenceType val) {
+        if(std::get<N-1>(it1) - std::get<N-1>(it2) != val)
+            return false;
+        return tuple_util<N-1>::check_sync(it1, it2, val);
+    }
+};
+
+template<>
+struct tuple_util<0> {
+    template<typename TupleType, typename DifferenceType>
+    static void increment(TupleType&, DifferenceType) {}
+    template<typename TupleType, typename DifferenceType>
+    static bool check_sync(const TupleType&, const TupleType&, DifferenceType) { return true;}
+};
+
+template <typename TupleReturnType>
+struct make_references {
+    template <typename TupleType, std::size_t... Is>
+    TupleReturnType operator()(const TupleType& t, tbb::internal::index_sequence<Is...>) {
+        return std::tie( *std::get<Is>(t)... );
+    }
+};
+
+// A simple wrapper over a tuple of references.
+// The class is designed to hold a temporary tuple of reference
+// after dereferencing a zip_iterator; in particular, it is needed
+// to swap these rvalue tuples. Any other usage is not supported.
+template<typename... T>
+struct tuplewrapper : public std::tuple<typename std::enable_if<std::is_reference<T>::value, T&&>::type...> {
+    // In the context of this class, T is a reference, so T&& is a "forwarding reference"
+    typedef std::tuple<T&&...> base_type;
+    // Construct from the result of std::tie
+    tuplewrapper(const base_type& in) : base_type(in) {}
+#if __INTEL_COMPILER
+    // ICC cannot generate copy ctor & assignment
+    tuplewrapper(const tuplewrapper& rhs) : base_type(rhs) {}
+    tuplewrapper& operator=(const tuplewrapper& rhs) {
+        *this = base_type(rhs);
+        return *this;
+    }
+#endif
+    // Assign any tuple convertible to std::tuple<T&&...>: *it = a_tuple;
+    template<typename... U>
+    tuplewrapper& operator=(const std::tuple<U...>& other) {
+        base_type::operator=(other);
+        return *this;
+    }
+#if _LIBCPP_VERSION
+    // (Necessary for libc++ tuples) Convert to a tuple of values: v = *it;
+    operator std::tuple<typename std::remove_reference<T>::type...>() { return base_type(*this); }
+#endif
+    // Swap rvalue tuples: swap(*it1,*it2);
+    friend void swap(tuplewrapper&& a, tuplewrapper&& b) {
+        std::swap<T&&...>(a,b);
+    }
+};
+
+} //namespace internal
+
+template <typename... Types>
+class zip_iterator {
+    __TBB_STATIC_ASSERT(sizeof...(Types)>0, "Cannot instantiate zip_iterator with empty template parameter pack");
+    static const std::size_t num_types = sizeof...(Types);
+    typedef std::tuple<Types...> it_types;
+public:
+    typedef typename std::make_signed<std::size_t>::type difference_type;
+    typedef std::tuple<typename std::iterator_traits<Types>::value_type...> value_type;
+#if __INTEL_COMPILER && __INTEL_COMPILER < 1800 && _MSC_VER
+    typedef std::tuple<typename std::iterator_traits<Types>::reference...> reference;
+#else
+    typedef tbb::internal::tuplewrapper<typename std::iterator_traits<Types>::reference...> reference;
+#endif
+    typedef std::tuple<typename std::iterator_traits<Types>::pointer...> pointer;
+    typedef std::random_access_iterator_tag iterator_category;
+
+    zip_iterator() : my_it() {}
+    explicit zip_iterator(Types... args) : my_it(std::make_tuple(args...)) {}
+    zip_iterator(const zip_iterator& input) : my_it(input.my_it) {}
+    zip_iterator& operator=(const zip_iterator& input) {
+        my_it = input.my_it;
+        return *this;
+    }
+
+    reference operator*() const {
+        return tbb::internal::make_references<reference>()(my_it, tbb::internal::make_index_sequence<num_types>());
+    }
+    reference operator[](difference_type i) const { return *(*this + i); }
+
+    difference_type operator-(const zip_iterator& it) const {
+        __TBB_ASSERT(internal::tuple_util<num_types>::check_sync(my_it, it.my_it, std::get<0>(my_it) - std::get<0>(it.my_it)),
+                     "Components of zip_iterator are not synchronous");
+        return std::get<0>(my_it) - std::get<0>(it.my_it);
+    }
+
+    zip_iterator& operator+=(difference_type forward) {
+        internal::tuple_util<num_types>::increment(my_it, forward);
+        return *this;
+    }
+    zip_iterator& operator-=(difference_type backward) { return *this += -backward; }
+    zip_iterator& operator++() { return *this += 1; }
+    zip_iterator& operator--() { return *this -= 1; }
+
+    zip_iterator operator++(int) {
+        zip_iterator it(*this);
+        ++(*this);
+        return it;
+    }
+    zip_iterator operator--(int) {
+        zip_iterator it(*this);
+        --(*this);
+        return it;
+    }
+
+    zip_iterator operator-(difference_type backward) const {
+        zip_iterator it(*this);
+        return it -= backward;
+    }
+    zip_iterator operator+(difference_type forward) const {
+        zip_iterator it(*this);
+        return it += forward;
+    }
+    friend zip_iterator operator+(difference_type forward, const zip_iterator& it) { return it + forward; }
+
+    bool operator==(const zip_iterator& it) const {
+        return *this - it == 0;
+    }
+    it_types base() const { return my_it; }
+
+    bool operator!=(const zip_iterator& it) const { return !(*this == it); }
+    bool operator<(const zip_iterator& it) const { return *this - it < 0; }
+    bool operator>(const zip_iterator& it) const { return it < *this; }
+    bool operator<=(const zip_iterator& it) const { return !(*this > it); }
+    bool operator>=(const zip_iterator& it) const { return !(*this < it); }
+private:
+    it_types my_it;
+};
+
+template<typename... T>
+zip_iterator<T...> make_zip_iterator(T... args) { return zip_iterator<T...>(args...); }
+
+template <typename UnaryFunc, typename Iter>
+class transform_iterator {
+public:
+    typedef typename std::iterator_traits<Iter>::value_type value_type;
+    typedef typename std::iterator_traits<Iter>::difference_type difference_type;
+#if __TBB_CPP17_INVOKE_RESULT_PRESENT
+    typedef typename std::invoke_result<UnaryFunc, typename std::iterator_traits<Iter>::reference>::type reference;
+#else
+    typedef typename std::result_of<UnaryFunc(typename std::iterator_traits<Iter>::reference)>::type reference;
+#endif
+    typedef typename std::iterator_traits<Iter>::pointer pointer;
+    typedef typename std::random_access_iterator_tag iterator_category;
+
+    transform_iterator(Iter it, UnaryFunc unary_func) : my_it(it), my_unary_func(unary_func) {
+        __TBB_STATIC_ASSERT((std::is_same<typename std::iterator_traits<Iter>::iterator_category,
+                             std::random_access_iterator_tag>::value), "Random access iterator required.");
+    }
+    transform_iterator(const transform_iterator& input) : my_it(input.my_it), my_unary_func(input.my_unary_func) { }
+    transform_iterator& operator=(const transform_iterator& input) {
+        my_it = input.my_it;
+        return *this;
+    }
+    reference operator*() const {
+        return my_unary_func(*my_it);
+    }
+    reference operator[](difference_type i) const {
+        return *(*this + i);
+    }
+    transform_iterator& operator++() {
+        ++my_it;
+        return *this;
+    }
+    transform_iterator& operator--() {
+        --my_it;
+        return *this;
+    }
+    transform_iterator operator++(int) {
+        transform_iterator it(*this);
+        ++(*this);
+        return it;
+    }
+    transform_iterator operator--(int) {
+        transform_iterator it(*this);
+        --(*this);
+        return it;
+    }
+    transform_iterator operator+(difference_type forward) const {
+        return { my_it + forward, my_unary_func };
+    }
+    transform_iterator operator-(difference_type backward) const {
+        return { my_it - backward, my_unary_func };
+    }
+    transform_iterator& operator+=(difference_type forward) {
+        my_it += forward;
+        return *this;
+    }
+    transform_iterator& operator-=(difference_type backward) {
+        my_it -= backward;
+        return *this;
+    }
+    friend transform_iterator operator+(difference_type forward, const transform_iterator& it) {
+        return it + forward;
+    }
+    difference_type operator-(const transform_iterator& it) const {
+        return my_it - it.my_it;
+    }
+    bool operator==(const transform_iterator& it) const { return *this - it == 0; }
+    bool operator!=(const transform_iterator& it) const { return !(*this == it); }
+    bool operator<(const transform_iterator& it) const { return *this - it < 0; }
+    bool operator>(const transform_iterator& it) const { return it < *this; }
+    bool operator<=(const transform_iterator& it) const { return !(*this > it); }
+    bool operator>=(const transform_iterator& it) const { return !(*this < it); }
+
+    Iter base() const { return my_it; }
+private:
+    Iter my_it;
+    const UnaryFunc my_unary_func;
+};
+
+template<typename UnaryFunc, typename Iter>
+transform_iterator<UnaryFunc, Iter> make_transform_iterator(Iter it, UnaryFunc unary_func) {
+    return transform_iterator<UnaryFunc, Iter>(it, unary_func);
+}
+
+} //namespace tbb
+
+#endif //__TBB_CPP11_PRESENT
+
+#endif /* __TBB_iterators_H */
diff --git a/src/tbb/include/tbb/machine/gcc_armv7.h b/src/tbb/include/tbb/machine/gcc_arm.h
similarity index 94%
rename from src/tbb/include/tbb/machine/gcc_armv7.h
rename to src/tbb/include/tbb/machine/gcc_arm.h
index 642c14fe..284a3f9e 100644
--- a/src/tbb/include/tbb/machine/gcc_armv7.h
+++ b/src/tbb/include/tbb/machine/gcc_arm.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 /*
@@ -26,10 +22,7 @@
 #error Do not include this file directly; include tbb_machine.h instead
 #endif
 
-//TODO: is ARMv7 is the only version ever to support?
-#if !(__ARM_ARCH_7A__)
-#error compilation requires an ARMv7-a architecture.
-#endif
+#if __ARM_ARCH_7A__
 
 #include <sys/param.h>
 #include <unistd.h>
@@ -171,15 +164,6 @@ static inline int64_t __TBB_machine_fetchadd8(volatile void *ptr, int64_t addend
     return result;
 }
 
-inline void __TBB_machine_pause (int32_t delay )
-{
-    while(delay>0)
-    {
-	__TBB_compiler_fence();
-        delay--;
-    }
-}
-
 namespace tbb {
 namespace internal {
     template <typename T, size_t S>
@@ -205,7 +189,6 @@ namespace internal {
 
 #define __TBB_CompareAndSwap4(P,V,C) __TBB_machine_cmpswp4(P,V,C)
 #define __TBB_CompareAndSwap8(P,V,C) __TBB_machine_cmpswp8(P,V,C)
-#define __TBB_Pause(V) __TBB_machine_pause(V)
 
 // Use generics for some things
 #define __TBB_USE_GENERIC_PART_WORD_CAS                         1
@@ -215,3 +198,19 @@ namespace internal {
 #define __TBB_USE_GENERIC_HALF_FENCED_LOAD_STORE                1
 #define __TBB_USE_GENERIC_DWORD_LOAD_STORE                      1
 #define __TBB_USE_GENERIC_SEQUENTIAL_CONSISTENCY_LOAD_STORE     1
+#elif defined __aarch64__
+// Generic gcc implementations are fine for ARMv8-a except __TBB_PAUSE.
+#include "gcc_generic.h"
+#else
+#error compilation requires an ARMv7-a or ARMv8-a architecture.
+#endif // __ARM_ARCH_7A__
+
+inline void __TBB_machine_pause (int32_t delay)
+{
+    while(delay>0)
+    {
+        __asm__ __volatile__("yield" ::: "memory");
+        delay--;
+    }
+}
+#define __TBB_Pause(V) __TBB_machine_pause(V)
diff --git a/src/tbb/include/tbb/machine/gcc_generic.h b/src/tbb/include/tbb/machine/gcc_generic.h
index 5fc2a901..9b157721 100644
--- a/src/tbb/include/tbb/machine/gcc_generic.h
+++ b/src/tbb/include/tbb/machine/gcc_generic.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 !defined(__TBB_machine_H) || defined(__TBB_machine_gcc_generic_H)
@@ -106,23 +102,17 @@ __TBB_MACHINE_DEFINE_ATOMICS(8,int64_t)
 
 #undef __TBB_MACHINE_DEFINE_ATOMICS
 
-namespace tbb{ namespace internal { namespace gcc_builtins {
-    inline int clz(unsigned int x){ return __builtin_clz(x);};
-    inline int clz(unsigned long int x){ return __builtin_clzl(x);};
-    inline int clz(unsigned long long int x){ return __builtin_clzll(x);};
-}}}
-//gcc __builtin_clz builtin count _number_ of leading zeroes
-static inline intptr_t __TBB_machine_lg( uintptr_t x ) {
-    return sizeof(x)*8 - tbb::internal::gcc_builtins::clz(x) -1 ;
-}
-
-
 typedef unsigned char __TBB_Flag;
 typedef __TBB_atomic __TBB_Flag __TBB_atomic_flag;
 
 #if __TBB_GCC_VERSION < 40700
 // Use __sync_* builtins
 
+// Use generic machine_load_store functions if there are no builtin atomics
+#define __TBB_USE_GENERIC_HALF_FENCED_LOAD_STORE            1
+#define __TBB_USE_GENERIC_RELAXED_LOAD_STORE                1
+#define __TBB_USE_GENERIC_SEQUENTIAL_CONSISTENCY_LOAD_STORE 1
+
 static inline void __TBB_machine_or( volatile void *ptr, uintptr_t addend ) {
     __sync_fetch_and_or(reinterpret_cast<volatile uintptr_t *>(ptr),addend);
 }
@@ -158,6 +148,59 @@ inline void __TBB_machine_unlock_byte( __TBB_atomic_flag &flag ) {
     __atomic_clear(&flag,__ATOMIC_RELEASE);
 }
 
+namespace tbb { namespace internal {
+
+/** GCC atomic operation intrinsics might miss compiler fence.
+    Adding it after load-with-acquire, before store-with-release, and
+    on both sides of sequentially consistent operations is sufficient for correctness. **/
+
+template <typename T, int MemOrder>
+inline T __TBB_machine_atomic_load( const volatile T& location) {
+    if (MemOrder == __ATOMIC_SEQ_CST) __TBB_compiler_fence();
+    T value = __atomic_load_n(&location, MemOrder);
+    if (MemOrder != __ATOMIC_RELAXED) __TBB_compiler_fence();
+    return value;
+}
+
+template <typename T, int MemOrder>
+inline void __TBB_machine_atomic_store( volatile T& location, T value) {
+    if (MemOrder != __ATOMIC_RELAXED) __TBB_compiler_fence();
+    __atomic_store_n(&location, value, MemOrder);
+    if (MemOrder == __ATOMIC_SEQ_CST) __TBB_compiler_fence();
+}
+
+template <typename T, size_t S>
+struct machine_load_store {
+    static T load_with_acquire ( const volatile T& location ) {
+        return __TBB_machine_atomic_load<T, __ATOMIC_ACQUIRE>(location);
+    }
+    static void store_with_release ( volatile T &location, T value ) {
+        __TBB_machine_atomic_store<T, __ATOMIC_RELEASE>(location, value);
+    }
+};
+
+template <typename T, size_t S>
+struct machine_load_store_relaxed {
+    static inline T load ( const volatile T& location ) {
+        return __TBB_machine_atomic_load<T, __ATOMIC_RELAXED>(location);
+    }
+    static inline void store ( volatile T& location, T value ) {
+        __TBB_machine_atomic_store<T, __ATOMIC_RELAXED>(location, value);
+    }
+};
+
+template <typename T, size_t S>
+struct machine_load_store_seq_cst {
+    static T load ( const volatile T& location ) {
+        return __TBB_machine_atomic_load<T, __ATOMIC_SEQ_CST>(location);
+    }
+    static void store ( volatile T &location, T value ) {
+        __TBB_machine_atomic_store<T, __ATOMIC_SEQ_CST>(location, value);
+    }
+};
+
+}} // namespace tbb::internal
+
 #endif // __TBB_GCC_VERSION < 40700
 
 // Machine specific atomic operations
@@ -167,18 +210,24 @@ inline void __TBB_machine_unlock_byte( __TBB_atomic_flag &flag ) {
 #define __TBB_TryLockByte   __TBB_machine_try_lock_byte
 #define __TBB_UnlockByte    __TBB_machine_unlock_byte
 
-// Definition of other functions
-#define __TBB_Log2(V)           __TBB_machine_lg(V)
+// __builtin_clz counts the number of leading zeroes
+namespace tbb{ namespace internal { namespace gcc_builtins {
+    inline int clz(unsigned int x){ return __builtin_clz(x); }
+    inline int clz(unsigned long int x){ return __builtin_clzl(x); }
+    inline int clz(unsigned long long int x){ return __builtin_clzll(x); }
+}}}
+// logarithm is the index of the most significant non-zero bit
+static inline intptr_t __TBB_machine_lg( uintptr_t x ) {
+    // If P is a power of 2 and x<P, then (P-1)-x == (P-1) XOR x
+    return (sizeof(x)*8 - 1) ^ tbb::internal::gcc_builtins::clz(x);
+}
 
-// TODO: implement with __atomic_* builtins where available
-#define __TBB_USE_GENERIC_HALF_FENCED_LOAD_STORE            1
-#define __TBB_USE_GENERIC_RELAXED_LOAD_STORE                1
-#define __TBB_USE_GENERIC_SEQUENTIAL_CONSISTENCY_LOAD_STORE 1
+#define __TBB_Log2(V)  __TBB_machine_lg(V)
 
 #if __TBB_WORDSIZE==4
     #define __TBB_USE_GENERIC_DWORD_LOAD_STORE              1
 #endif
 
 #if __TBB_x86_32 || __TBB_x86_64
-#include "gcc_itsx.h"
+#include "gcc_ia32_common.h"
 #endif
diff --git a/src/tbb/include/tbb/machine/gcc_ia32_common.h b/src/tbb/include/tbb/machine/gcc_ia32_common.h
index f5efc375..975d389e 100644
--- a/src/tbb/include/tbb/machine/gcc_ia32_common.h
+++ b/src/tbb/include/tbb/machine/gcc_ia32_common.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,19 +12,15 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_machine_gcc_ia32_common_H
 #define __TBB_machine_gcc_ia32_common_H
 
+#ifndef __TBB_Log2
 //TODO: Add a higher-level function, e.g. tbb::internal::log2(), into tbb_stddef.h, which
 //uses __TBB_Log2 and contains the assert and remove the assert from here and all other
 //platform-specific headers.
-//TODO: Check if use of gcc intrinsic gives a better chance for cross call optimizations
 template <typename T>
 static inline intptr_t __TBB_machine_lg( T x ) {
     __TBB_ASSERT(x>0, "The logarithm of a non-positive value is undefined.");
@@ -33,6 +29,7 @@ static inline intptr_t __TBB_machine_lg( T x ) {
     return j;
 }
 #define __TBB_Log2(V)  __TBB_machine_lg(V)
+#endif /* !__TBB_Log2 */
 
 #ifndef __TBB_Pause
 //TODO: check if raising a ratio of pause instructions to loop control instructions
diff --git a/src/tbb/include/tbb/machine/gcc_itsx.h b/src/tbb/include/tbb/machine/gcc_itsx.h
index caa35441..5e93a202 100644
--- a/src/tbb/include/tbb/machine/gcc_itsx.h
+++ b/src/tbb/include/tbb/machine/gcc_itsx.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 !defined(__TBB_machine_H) || defined(__TBB_machine_gcc_itsx_H)
diff --git a/src/tbb/include/tbb/machine/ibm_aix51.h b/src/tbb/include/tbb/machine/ibm_aix51.h
index a905b4e1..c8246848 100644
--- a/src/tbb/include/tbb/machine/ibm_aix51.h
+++ b/src/tbb/include/tbb/machine/ibm_aix51.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 // TODO: revise by comparing with mac_ppc.h
diff --git a/src/tbb/include/tbb/machine/icc_generic.h b/src/tbb/include/tbb/machine/icc_generic.h
index 04863000..c4675b8e 100644
--- a/src/tbb/include/tbb/machine/icc_generic.h
+++ b/src/tbb/include/tbb/machine/icc_generic.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 !defined(__TBB_machine_H) || defined(__TBB_machine_icc_generic_H)
@@ -23,7 +19,7 @@
 #endif
 
 #if ! __TBB_ICC_BUILTIN_ATOMICS_PRESENT
-    #error "Intel C++ Compiler of at least 12.0 version is needed to use ICC intrinsics port"
+    #error "Intel(R) C++ Compiler of at least 12.0 version is needed to use ICC intrinsics port"
 #endif
 
 #define __TBB_machine_icc_generic_H
diff --git a/src/tbb/include/tbb/machine/linux_common.h b/src/tbb/include/tbb/machine/linux_common.h
index 4d2d355b..9dc6c813 100644
--- a/src/tbb/include/tbb/machine/linux_common.h
+++ b/src/tbb/include/tbb/machine/linux_common.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_machine_H
@@ -30,19 +26,44 @@
 #include <sys/syscall.h>
 
 #if defined(SYS_futex)
+/* This header file is included for Linux and some other systems that may support futexes.*/
 
 #define __TBB_USE_FUTEX 1
+
+#if defined(__has_include)
+#define __TBB_has_include __has_include
+#else
+#define __TBB_has_include(x) 0
+#endif
+
+/*
+If available, use typical headers where futex API is defined. While Linux and OpenBSD
+are known to provide such headers, other systems might have them as well.
+*/
+#if defined(__linux__) || __TBB_has_include(<linux/futex.h>)
+#include <linux/futex.h>
+#elif defined(__OpenBSD__) || __TBB_has_include(<sys/futex.h>)
+#include <sys/futex.h>
+#endif
+
 #include <limits.h>
 #include <errno.h>
-// Unfortunately, some versions of Linux do not have a header that defines FUTEX_WAIT and FUTEX_WAKE.
 
-#ifdef FUTEX_WAIT
+/*
+Some systems might not define the macros or use different names. In such case we expect
+the actual parameter values to match Linux: 0 for wait, 1 for wake.
+*/
+#if defined(FUTEX_WAIT_PRIVATE)
+#define __TBB_FUTEX_WAIT FUTEX_WAIT_PRIVATE
+#elif defined(FUTEX_WAIT)
 #define __TBB_FUTEX_WAIT FUTEX_WAIT
 #else
 #define __TBB_FUTEX_WAIT 0
 #endif
 
-#ifdef FUTEX_WAKE
+#if defined(FUTEX_WAKE_PRIVATE)
+#define __TBB_FUTEX_WAKE FUTEX_WAKE_PRIVATE
+#elif defined(FUTEX_WAKE)
 #define __TBB_FUTEX_WAKE FUTEX_WAKE
 #else
 #define __TBB_FUTEX_WAKE 1
diff --git a/src/tbb/include/tbb/machine/linux_ia32.h b/src/tbb/include/tbb/machine/linux_ia32.h
index 932d343d..3942d8bf 100644
--- a/src/tbb/include/tbb/machine/linux_ia32.h
+++ b/src/tbb/include/tbb/machine/linux_ia32.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 !defined(__TBB_machine_H) || defined(__TBB_machine_linux_ia32_H)
diff --git a/src/tbb/include/tbb/machine/linux_ia64.h b/src/tbb/include/tbb/machine/linux_ia64.h
index f4772288..28b2bc41 100644
--- a/src/tbb/include/tbb/machine/linux_ia64.h
+++ b/src/tbb/include/tbb/machine/linux_ia64.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 !defined(__TBB_machine_H) || defined(__TBB_machine_linux_ia64_H)
diff --git a/src/tbb/include/tbb/machine/linux_intel64.h b/src/tbb/include/tbb/machine/linux_intel64.h
index 02153c2a..907ead52 100644
--- a/src/tbb/include/tbb/machine/linux_intel64.h
+++ b/src/tbb/include/tbb/machine/linux_intel64.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 !defined(__TBB_machine_H) || defined(__TBB_machine_linux_intel64_H)
diff --git a/src/tbb/include/tbb/machine/mac_ppc.h b/src/tbb/include/tbb/machine/mac_ppc.h
index 13f387b4..2eb5ad3a 100644
--- a/src/tbb/include/tbb/machine/mac_ppc.h
+++ b/src/tbb/include/tbb/machine/mac_ppc.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 !defined(__TBB_machine_H) || defined(__TBB_machine_gcc_power_H)
diff --git a/src/tbb/include/tbb/machine/macos_common.h b/src/tbb/include/tbb/machine/macos_common.h
index 119ad979..87bb5e3e 100644
--- a/src/tbb/include/tbb/machine/macos_common.h
+++ b/src/tbb/include/tbb/machine/macos_common.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 !defined(__TBB_machine_H) || defined(__TBB_machine_macos_common_H)
diff --git a/src/tbb/include/tbb/machine/mic_common.h b/src/tbb/include/tbb/machine/mic_common.h
index 8765d39f..8c844f1d 100644
--- a/src/tbb/include/tbb/machine/mic_common.h
+++ b/src/tbb/include/tbb/machine/mic_common.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_mic_common_H
diff --git a/src/tbb/include/tbb/machine/msvc_armv7.h b/src/tbb/include/tbb/machine/msvc_armv7.h
index 40d22020..e83c077e 100644
--- a/src/tbb/include/tbb/machine/msvc_armv7.h
+++ b/src/tbb/include/tbb/machine/msvc_armv7.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 !defined(__TBB_machine_H) || defined(__TBB_msvc_armv7_H)
diff --git a/src/tbb/include/tbb/machine/msvc_ia32_common.h b/src/tbb/include/tbb/machine/msvc_ia32_common.h
index 8b4814bc..2e17836d 100644
--- a/src/tbb/include/tbb/machine/msvc_ia32_common.h
+++ b/src/tbb/include/tbb/machine/msvc_ia32_common.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 !defined(__TBB_machine_H) || defined(__TBB_machine_msvc_ia32_common_H)
@@ -49,7 +45,7 @@
     }}}
 #endif
 
-#if _MSC_VER>=1600 && (!__INTEL_COMPILER || __INTEL_COMPILER>=1310)
+#if __TBB_MSVC_PART_WORD_INTERLOCKED_INTRINSICS_PRESENT
     // S is the operand size in bytes, B is the suffix for intrinsics for that size
     #define __TBB_MACHINE_DEFINE_ATOMICS(S,B,T,U)                                           \
     __pragma(intrinsic( _InterlockedCompareExchange##B ))                                   \
@@ -75,8 +71,7 @@
     #endif
 
     #undef __TBB_MACHINE_DEFINE_ATOMICS
-    #define __TBB_ATOMIC_PRIMITIVES_DEFINED
-#endif /*_MSC_VER>=1600*/
+#endif /* __TBB_MSVC_PART_WORD_INTERLOCKED_INTRINSICS_PRESENT */
 
 #if _MSC_VER>=1300 || __INTEL_COMPILER>=1100
     #pragma intrinsic(_ReadWriteBarrier)
diff --git a/src/tbb/include/tbb/machine/sunos_sparc.h b/src/tbb/include/tbb/machine/sunos_sparc.h
index 9119f402..b5864ba7 100644
--- a/src/tbb/include/tbb/machine/sunos_sparc.h
+++ b/src/tbb/include/tbb/machine/sunos_sparc.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 
diff --git a/src/tbb/include/tbb/machine/windows_api.h b/src/tbb/include/tbb/machine/windows_api.h
index d362abc5..54987915 100644
--- a/src/tbb/include/tbb/machine/windows_api.h
+++ b/src/tbb/include/tbb/machine/windows_api.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_machine_windows_api_H
diff --git a/src/tbb/include/tbb/machine/windows_ia32.h b/src/tbb/include/tbb/machine/windows_ia32.h
index 8db0d2b8..62968226 100644
--- a/src/tbb/include/tbb/machine/windows_ia32.h
+++ b/src/tbb/include/tbb/machine/windows_ia32.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 !defined(__TBB_machine_H) || defined(__TBB_machine_windows_ia32_H)
@@ -43,7 +39,7 @@ extern "C" {
     __int64 __TBB_EXPORTED_FUNC __TBB_machine_load8 (const volatile void *ptr);
 }
 
-#ifndef __TBB_ATOMIC_PRIMITIVES_DEFINED
+#if !__TBB_MSVC_PART_WORD_INTERLOCKED_INTRINSICS_PRESENT
 
 #define __TBB_MACHINE_DEFINE_ATOMICS(S,T,U,A,C) \
 static inline T __TBB_machine_cmpswp##S ( volatile void * ptr, U value, U comparand ) { \
@@ -93,7 +89,7 @@ __TBB_MACHINE_DEFINE_ATOMICS(4, ptrdiff_t, ptrdiff_t, eax, ecx)
 
 #undef __TBB_MACHINE_DEFINE_ATOMICS
 
-#endif /*__TBB_ATOMIC_PRIMITIVES_DEFINED*/
+#endif /* __TBB_MSVC_PART_WORD_INTERLOCKED_INTRINSICS_PRESENT */
 
 //TODO: Check if it possible and profitable for IA-32 architecture on (Linux and Windows)
 //to use of 64-bit load/store via floating point registers together with full fence
diff --git a/src/tbb/include/tbb/machine/windows_intel64.h b/src/tbb/include/tbb/machine/windows_intel64.h
index 86abd6ad..6e2a2cc7 100644
--- a/src/tbb/include/tbb/machine/windows_intel64.h
+++ b/src/tbb/include/tbb/machine/windows_intel64.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 !defined(__TBB_machine_H) || defined(__TBB_machine_windows_intel64_H)
@@ -29,7 +25,7 @@
 
 #include "msvc_ia32_common.h"
 
-#ifndef __TBB_ATOMIC_PRIMITIVES_DEFINED
+#if !__TBB_MSVC_PART_WORD_INTERLOCKED_INTRINSICS_PRESENT
 
 #include <intrin.h>
 #pragma intrinsic(_InterlockedCompareExchange,_InterlockedExchangeAdd,_InterlockedExchange)
@@ -66,7 +62,7 @@ inline __int64 __TBB_machine_fetchstore8 (volatile void *ptr, __int64 value ) {
     return _InterlockedExchange64( (__int64*)ptr, value );
 }
 
-#endif /*__TBB_ATOMIC_PRIMITIVES_DEFINED*/
+#endif /* __TBB_MSVC_PART_WORD_INTERLOCKED_INTRINSICS_PRESENT */
 
 #define __TBB_USE_FETCHSTORE_AS_FULL_FENCED_STORE           1
 #define __TBB_USE_GENERIC_HALF_FENCED_LOAD_STORE            1
diff --git a/src/tbb/include/tbb/memory_pool.h b/src/tbb/include/tbb/memory_pool.h
index b3bba397..99a31d6a 100644
--- a/src/tbb/include/tbb/memory_pool.h
+++ b/src/tbb/include/tbb/memory_pool.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_memory_pool_H
diff --git a/src/tbb/include/tbb/mutex.h b/src/tbb/include/tbb/mutex.h
index e40b4cd0..94269f3d 100644
--- a/src/tbb/include/tbb/mutex.h
+++ b/src/tbb/include/tbb/mutex.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,15 +12,25 @@
     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 "internal/_deprecated_header_message_guard.h"
 
+#if !defined(__TBB_show_deprecation_message_mutex_H) && defined(__TBB_show_deprecated_header_message)
+#define  __TBB_show_deprecation_message_mutex_H
+#pragma message("TBB Warning: tbb/mutex.h is deprecated. For details, please see Deprecated Features appendix in the TBB reference manual.")
+#endif
 
-
-*/
+#if defined(__TBB_show_deprecated_header_message)
+#undef __TBB_show_deprecated_header_message
+#endif
 
 #ifndef __TBB_mutex_H
 #define __TBB_mutex_H
 
+#define __TBB_mutex_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #if _WIN32||_WIN64
 #include "machine/windows_api.h"
 #else
@@ -36,7 +46,7 @@ namespace tbb {
 
 //! Wrapper around the platform's native lock.
 /** @ingroup synchronization */
-class mutex : internal::mutex_copy_deprecated_and_disabled {
+class __TBB_DEPRECATED_IN_VERBOSE_MODE_MSG("tbb::critical_section is deprecated, use std::mutex") mutex : internal::mutex_copy_deprecated_and_disabled {
 public:
     //! Construct unacquired mutex.
     mutex() {
@@ -230,4 +240,7 @@ __TBB_DEFINE_PROFILING_SET_NAME(mutex)
 
 } // namespace tbb
 
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_mutex_H_include_area
+
 #endif /* __TBB_mutex_H */
diff --git a/src/tbb/include/tbb/null_mutex.h b/src/tbb/include/tbb/null_mutex.h
index 85c660e3..3c7bad1a 100644
--- a/src/tbb/include/tbb/null_mutex.h
+++ b/src/tbb/include/tbb/null_mutex.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_null_mutex_H
diff --git a/src/tbb/include/tbb/null_rw_mutex.h b/src/tbb/include/tbb/null_rw_mutex.h
index fa0c8035..f1ea4df6 100644
--- a/src/tbb/include/tbb/null_rw_mutex.h
+++ b/src/tbb/include/tbb/null_rw_mutex.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_null_rw_mutex_H
diff --git a/src/tbb/include/tbb/parallel_do.h b/src/tbb/include/tbb/parallel_do.h
index 15275682..1b63e279 100644
--- a/src/tbb/include/tbb/parallel_do.h
+++ b/src/tbb/include/tbb/parallel_do.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,15 +12,14 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_parallel_do_H
 #define __TBB_parallel_do_H
 
+#define __TBB_parallel_do_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #include "internal/_range_iterator.h"
 #include "internal/_template_helpers.h"
 #include "task.h"
@@ -500,7 +499,7 @@ void parallel_do( Iterator first, Iterator last, const Body& body )
     if ( first == last )
         return;
 #if __TBB_TASK_GROUP_CONTEXT
-    task_group_context context;
+    task_group_context context(internal::PARALLEL_DO);
 #endif
     interface9::internal::select_parallel_do( first, last, body, &Body::operator()
 #if __TBB_TASK_GROUP_CONTEXT
@@ -548,4 +547,7 @@ using interface9::parallel_do_feeder;
 
 } // namespace
 
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_parallel_do_H_include_area
+
 #endif /* __TBB_parallel_do_H */
diff --git a/src/tbb/include/tbb/parallel_for.h b/src/tbb/include/tbb/parallel_for.h
index 19549e19..0b4861f4 100644
--- a/src/tbb/include/tbb/parallel_for.h
+++ b/src/tbb/include/tbb/parallel_for.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,15 +12,14 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_parallel_for_H
 #define __TBB_parallel_for_H
 
+#define __TBB_parallel_for_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #include <new>
 #include "task.h"
 #include "partitioner.h"
@@ -58,7 +57,7 @@ namespace internal {
             my_body(body),
             my_partition(partitioner)
         {
-            tbb::internal::fgt_algorithm(tbb::internal::FGT_PARALLEL_FOR, this, NULL); 
+            tbb::internal::fgt_algorithm(tbb::internal::PARALLEL_FOR_TASK, this, NULL);
         }
         //! Splitting constructor used to generate children.
         /** parent_ becomes left child.  Newly constructed object is right child. */
@@ -68,7 +67,7 @@ namespace internal {
             my_partition(parent_.my_partition, split_obj)
         {
             my_partition.set_affinity(*this);
-            tbb::internal::fgt_algorithm(tbb::internal::FGT_PARALLEL_FOR, this, (void *)&parent_); 
+            tbb::internal::fgt_algorithm(tbb::internal::PARALLEL_FOR_TASK, this, (void *)&parent_);
         }
         //! Construct right child from the given range as response to the demand.
         /** parent_ remains left child.  Newly constructed object is right child. */
@@ -79,7 +78,7 @@ namespace internal {
         {
             my_partition.set_affinity(*this);
             my_partition.align_depth( d );
-            tbb::internal::fgt_algorithm(tbb::internal::FGT_PARALLEL_FOR, this, (void *)&parent_); 
+            tbb::internal::fgt_algorithm(tbb::internal::PARALLEL_FOR_TASK, this, (void *)&parent_);
         }
         static void run(  const Range& range, const Body& body, Partitioner& partitioner ) {
             if( !range.empty() ) {
@@ -88,13 +87,13 @@ namespace internal {
 #else
                 // Bound context prevents exceptions from body to affect nesting or sibling algorithms,
                 // and allows users to handle exceptions safely by wrapping parallel_for in the try-block.
-                task_group_context context;
+                task_group_context context(PARALLEL_FOR);
                 start_for& a = *new(task::allocate_root(context)) start_for(range,body,partitioner);
 #endif /* __TBB_TASK_GROUP_CONTEXT && !TBB_JOIN_OUTER_TASK_GROUP */
 		// REGION BEGIN
-                fgt_begin_algorithm( tbb::internal::FGT_PARALLEL_FOR, (void*)&a );
+                fgt_begin_algorithm( tbb::internal::PARALLEL_FOR_TASK, (void*)&context );
                 task::spawn_root_and_wait(a);
-                fgt_end_algorithm( (void*)&a );
+                fgt_end_algorithm( (void*)&context );
 		// REGION END
             }
         }
@@ -103,17 +102,17 @@ namespace internal {
             if( !range.empty() ) {
                 start_for& a = *new(task::allocate_root(context)) start_for(range,body,partitioner);
 		// REGION BEGIN
-                fgt_begin_algorithm( tbb::internal::FGT_PARALLEL_FOR, (void*)&a );
+                fgt_begin_algorithm( tbb::internal::PARALLEL_FOR_TASK, (void*)&context );
                 task::spawn_root_and_wait(a);
-                fgt_end_algorithm( (void*)&a );
+                fgt_end_algorithm( (void*)&context );
 		// END REGION
             }
         }
 #endif /* __TBB_TASK_GROUP_CONTEXT */
         //! Run body for range, serves as callback for partitioner
-        void run_body( Range &r ) { 
-            fgt_alg_begin_body( tbb::internal::FGT_PARALLEL_FOR, (void *)const_cast<Body*>(&(this->my_body)), (void*)this );
-            my_body( r ); 
+        void run_body( Range &r ) {
+            fgt_alg_begin_body( tbb::internal::PARALLEL_FOR_TASK, (void *)const_cast<Body*>(&(this->my_body)), (void*)this );
+            my_body( r );
             fgt_alg_end_body( (void *)const_cast<Body*>(&(this->my_body)) );
         }
 
@@ -420,4 +419,7 @@ using strict_ppl::parallel_for;
 #undef __TBB_NORMAL_EXECUTION
 #endif
 
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_parallel_for_H_include_area
+
 #endif /* __TBB_parallel_for_H */
diff --git a/src/tbb/include/tbb/parallel_for_each.h b/src/tbb/include/tbb/parallel_for_each.h
index 6c2ec9f0..e1da1bbd 100644
--- a/src/tbb/include/tbb/parallel_for_each.h
+++ b/src/tbb/include/tbb/parallel_for_each.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_parallel_for_each_H
diff --git a/src/tbb/include/tbb/parallel_invoke.h b/src/tbb/include/tbb/parallel_invoke.h
index 0dd7590e..4be4bdb7 100644
--- a/src/tbb/include/tbb/parallel_invoke.h
+++ b/src/tbb/include/tbb/parallel_invoke.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,16 +12,16 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_parallel_invoke_H
 #define __TBB_parallel_invoke_H
 
+#define __TBB_parallel_invoke_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #include "task.h"
+#include "tbb_profiling.h"
 
 #if __TBB_VARIADIC_PARALLEL_INVOKE
     #include <utility> // std::forward
@@ -31,7 +31,9 @@ namespace tbb {
 
 #if !__TBB_TASK_GROUP_CONTEXT
     /** Dummy to avoid cluttering the bulk of the header with enormous amount of ifdefs. **/
-    struct task_group_context {};
+    struct task_group_context {
+        task_group_context(tbb::internal::string_index){}
+    };
 #endif /* __TBB_TASK_GROUP_CONTEXT */
 
 //! @cond INTERNAL
@@ -223,7 +225,7 @@ namespace internal {
     // task_group_context is not in the pack, needs to be added
     template<typename F0, typename F1, typename... F>
     void parallel_invoke_impl(false_type, F0&& f0, F1&& f1, F&&... f) {
-        tbb::task_group_context context;
+        tbb::task_group_context context(PARALLEL_INVOKE);
         // Add context to the arguments, and redirect to the other overload
         parallel_invoke_impl(true_type(), std::forward<F0>(f0), std::forward<F1>(f1), std::forward<F>(f)..., context);
     }
@@ -385,31 +387,31 @@ void parallel_invoke(const F0& f0, const F1& f1, const F2& f2, const F3& f3, con
 // two arguments
 template<typename F0, typename F1>
 void parallel_invoke(const F0& f0, const F1& f1) {
-    task_group_context context;
+    task_group_context context(internal::PARALLEL_INVOKE);
     parallel_invoke<F0, F1>(f0, f1, context);
 }
 // three arguments
 template<typename F0, typename F1, typename F2>
 void parallel_invoke(const F0& f0, const F1& f1, const F2& f2) {
-    task_group_context context;
+    task_group_context context(internal::PARALLEL_INVOKE);
     parallel_invoke<F0, F1, F2>(f0, f1, f2, context);
 }
 // four arguments
 template<typename F0, typename F1, typename F2, typename F3 >
 void parallel_invoke(const F0& f0, const F1& f1, const F2& f2, const F3& f3) {
-    task_group_context context;
+    task_group_context context(internal::PARALLEL_INVOKE);
     parallel_invoke<F0, F1, F2, F3>(f0, f1, f2, f3, context);
 }
 // five arguments
 template<typename F0, typename F1, typename F2, typename F3, typename F4>
 void parallel_invoke(const F0& f0, const F1& f1, const F2& f2, const F3& f3, const F4& f4) {
-    task_group_context context;
+    task_group_context context(internal::PARALLEL_INVOKE);
     parallel_invoke<F0, F1, F2, F3, F4>(f0, f1, f2, f3, f4, context);
 }
 // six arguments
 template<typename F0, typename F1, typename F2, typename F3, typename F4, typename F5>
 void parallel_invoke(const F0& f0, const F1& f1, const F2& f2, const F3& f3, const F4& f4, const F5& f5) {
-    task_group_context context;
+    task_group_context context(internal::PARALLEL_INVOKE);
     parallel_invoke<F0, F1, F2, F3, F4, F5>(f0, f1, f2, f3, f4, f5, context);
 }
 // seven arguments
@@ -417,7 +419,7 @@ template<typename F0, typename F1, typename F2, typename F3, typename F4, typena
 void parallel_invoke(const F0& f0, const F1& f1, const F2& f2, const F3& f3, const F4& f4,
                      const F5& f5, const F6& f6)
 {
-    task_group_context context;
+    task_group_context context(internal::PARALLEL_INVOKE);
     parallel_invoke<F0, F1, F2, F3, F4, F5, F6>(f0, f1, f2, f3, f4, f5, f6, context);
 }
 // eight arguments
@@ -426,7 +428,7 @@ template<typename F0, typename F1, typename F2, typename F3, typename F4,
 void parallel_invoke(const F0& f0, const F1& f1, const F2& f2, const F3& f3, const F4& f4,
                      const F5& f5, const F6& f6, const F7& f7)
 {
-    task_group_context context;
+    task_group_context context(internal::PARALLEL_INVOKE);
     parallel_invoke<F0, F1, F2, F3, F4, F5, F6, F7>(f0, f1, f2, f3, f4, f5, f6, f7, context);
 }
 // nine arguments
@@ -435,7 +437,7 @@ template<typename F0, typename F1, typename F2, typename F3, typename F4,
 void parallel_invoke(const F0& f0, const F1& f1, const F2& f2, const F3& f3, const F4& f4,
                      const F5& f5, const F6& f6, const F7& f7, const F8& f8)
 {
-    task_group_context context;
+    task_group_context context(internal::PARALLEL_INVOKE);
     parallel_invoke<F0, F1, F2, F3, F4, F5, F6, F7, F8>(f0, f1, f2, f3, f4, f5, f6, f7, f8, context);
 }
 // ten arguments
@@ -444,7 +446,7 @@ template<typename F0, typename F1, typename F2, typename F3, typename F4,
 void parallel_invoke(const F0& f0, const F1& f1, const F2& f2, const F3& f3, const F4& f4,
                      const F5& f5, const F6& f6, const F7& f7, const F8& f8, const F9& f9)
 {
-    task_group_context context;
+    task_group_context context(internal::PARALLEL_INVOKE);
     parallel_invoke<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9>(f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, context);
 }
 #endif // __TBB_VARIADIC_PARALLEL_INVOKE
@@ -452,4 +454,7 @@ void parallel_invoke(const F0& f0, const F1& f1, const F2& f2, const F3& f3, con
 
 } // namespace
 
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_parallel_invoke_H_include_area
+
 #endif /* __TBB_parallel_invoke_H */
diff --git a/src/tbb/include/tbb/parallel_reduce.h b/src/tbb/include/tbb/parallel_reduce.h
index ab9c9f73..da2e2f8d 100644
--- a/src/tbb/include/tbb/parallel_reduce.h
+++ b/src/tbb/include/tbb/parallel_reduce.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,15 +12,14 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_parallel_reduce_H
 #define __TBB_parallel_reduce_H
 
+#define __TBB_parallel_reduce_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #include <new>
 #include "task.h"
 #include "aligned_space.h"
@@ -136,7 +135,7 @@ namespace internal {
 #else
                 // Bound context prevents exceptions from body to affect nesting or sibling algorithms,
                 // and allows users to handle exceptions safely by wrapping parallel_for in the try-block.
-                task_group_context context;
+                task_group_context context(PARALLEL_REDUCE);
                 task::spawn_root_and_wait( *new(task::allocate_root(context)) start_reduce(range,&body,partitioner) );
 #endif /* __TBB_TASK_GROUP_CONTEXT && !TBB_JOIN_OUTER_TASK_GROUP */
             }
@@ -236,10 +235,10 @@ namespace internal {
         }
         //! Splitting constructor used to generate children.
         /** parent_ becomes left child.  Newly constructed object is right child. */
-        start_deterministic_reduce( start_deterministic_reduce& parent_, finish_type& c ) :
+        start_deterministic_reduce( start_deterministic_reduce& parent_, finish_type& c, typename Partitioner::split_type& split_obj ) :
             my_body( c.my_right_body ),
-            my_range( parent_.my_range, split() ),
-            my_partition( parent_.my_partition, split() )
+            my_range( parent_.my_range, split_obj ),
+            my_partition( parent_.my_partition, split_obj )
         {
         }
 
@@ -251,7 +250,7 @@ namespace internal {
 #else
                 // Bound context prevents exceptions from body to affect nesting or sibling algorithms,
                 // and allows users to handle exceptions safely by wrapping parallel_for in the try-block.
-                task_group_context context;
+                task_group_context context(PARALLEL_REDUCE);
                 task::spawn_root_and_wait( *new(task::allocate_root(context)) start_deterministic_reduce(range,body,partitioner) );
 #endif /* __TBB_TASK_GROUP_CONTEXT && !TBB_JOIN_OUTER_TASK_GROUP */
             }
@@ -263,11 +262,11 @@ namespace internal {
         }
 #endif /* __TBB_TASK_GROUP_CONTEXT */
 
-        void offer_work( typename Partitioner::split_type& ) {
+        void offer_work( typename Partitioner::split_type& split_obj) {
             task* tasks[2];
             allocate_sibling(static_cast<task*>(this), tasks, sizeof(start_deterministic_reduce), sizeof(finish_type));
             new((void*)tasks[0]) finish_type(my_body);
-            new((void*)tasks[1]) start_deterministic_reduce(*this, *static_cast<finish_type*>(tasks[0]));
+            new((void*)tasks[1]) start_deterministic_reduce(*this, *static_cast<finish_type*>(tasks[0]), split_obj);
             spawn(*tasks[1]);
         }
 
@@ -393,6 +392,13 @@ void parallel_reduce( const Range& range, Body& body, affinity_partitioner& part
 }
 
 #if __TBB_TASK_GROUP_CONTEXT
+//! Parallel iteration with reduction, default partitioner and user-supplied context.
+/** @ingroup algorithms **/
+template<typename Range, typename Body>
+void parallel_reduce( const Range& range, Body& body, task_group_context& context ) {
+    internal::start_reduce<Range,Body,const __TBB_DEFAULT_PARTITIONER>::run( range, body, __TBB_DEFAULT_PARTITIONER(), context );
+}
+
 //! Parallel iteration with reduction, simple partitioner and user-supplied context.
 /** @ingroup algorithms **/
 template<typename Range, typename Body>
@@ -480,6 +486,17 @@ Value parallel_reduce( const Range& range, const Value& identity, const RealBody
 }
 
 #if __TBB_TASK_GROUP_CONTEXT
+//! Parallel iteration with reduction, default partitioner and user-supplied context.
+/** @ingroup algorithms **/
+template<typename Range, typename Value, typename RealBody, typename Reduction>
+Value parallel_reduce( const Range& range, const Value& identity, const RealBody& real_body, const Reduction& reduction,
+                       task_group_context& context ) {
+    internal::lambda_reduce_body<Range,Value,RealBody,Reduction> body(identity, real_body, reduction);
+    internal::start_reduce<Range,internal::lambda_reduce_body<Range,Value,RealBody,Reduction>,const __TBB_DEFAULT_PARTITIONER>
+                          ::run( range, body, __TBB_DEFAULT_PARTITIONER(), context );
+    return body.result();
+}
+
 //! Parallel iteration with reduction, simple partitioner and user-supplied context.
 /** @ingroup algorithms **/
 template<typename Range, typename Value, typename RealBody, typename Reduction>
@@ -634,4 +651,7 @@ Value parallel_deterministic_reduce( const Range& range, const Value& identity,
 
 } // namespace tbb
 
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_parallel_reduce_H_include_area
+
 #endif /* __TBB_parallel_reduce_H */
diff --git a/src/tbb/include/tbb/parallel_scan.h b/src/tbb/include/tbb/parallel_scan.h
index d3668695..7930b5c4 100644
--- a/src/tbb/include/tbb/parallel_scan.h
+++ b/src/tbb/include/tbb/parallel_scan.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,15 +12,14 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_parallel_scan_H
 #define __TBB_parallel_scan_H
 
+#define __TBB_parallel_scan_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #include "task.h"
 #include "aligned_space.h"
 #include <new>
@@ -410,5 +409,8 @@ Value parallel_scan( const Range& range, const Value& identity, const Scan& scan
 
 } // namespace tbb
 
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_parallel_scan_H_include_area
+
 #endif /* __TBB_parallel_scan_H */
 
diff --git a/src/tbb/include/tbb/parallel_sort.h b/src/tbb/include/tbb/parallel_sort.h
index 07d3907b..b865b2ee 100644
--- a/src/tbb/include/tbb/parallel_sort.h
+++ b/src/tbb/include/tbb/parallel_sort.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,21 +12,23 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_parallel_sort_H
 #define __TBB_parallel_sort_H
 
+#define __TBB_parallel_sort_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #include "parallel_for.h"
 #include "blocked_range.h"
 #include "internal/_range_iterator.h"
 #include <algorithm>
 #include <iterator>
 #include <functional>
+#if __TBB_TASK_GROUP_CONTEXT
+    #include "tbb_profiling.h"
+#endif
 
 namespace tbb {
 
@@ -159,7 +161,7 @@ struct quick_sort_body {
 template<typename RandomAccessIterator, typename Compare>
 void parallel_quick_sort( RandomAccessIterator begin, RandomAccessIterator end, const Compare& comp ) {
 #if __TBB_TASK_GROUP_CONTEXT
-    task_group_context my_context;
+    task_group_context my_context(PARALLEL_SORT);
     const int serial_cutoff = 9;
 
     __TBB_ASSERT( begin + serial_cutoff < end, "min_parallel_size is smaller than serial cutoff?" );
@@ -230,13 +232,6 @@ void parallel_sort(Range& rng, const Compare& comp) {
     parallel_sort(tbb::internal::first(rng), tbb::internal::last(rng), comp);
 }
 
-//! Sorts the data in const rng using the given comparator
-/** @ingroup algorithms **/
-template<typename Range, typename Compare>
-void parallel_sort(const Range& rng, const Compare& comp) {
-    parallel_sort(tbb::internal::first(rng), tbb::internal::last(rng), comp);
-}
-
 //! Sorts the data in rng with a default comparator \c std::less<RandomAccessIterator>
 /** @ingroup algorithms **/
 template<typename Range>
@@ -244,13 +239,6 @@ void parallel_sort(Range& rng) {
     parallel_sort(tbb::internal::first(rng), tbb::internal::last(rng));
 }
 
-//! Sorts the data in const rng with a default comparator \c std::less<RandomAccessIterator>
-/** @ingroup algorithms **/
-template<typename Range>
-void parallel_sort(const Range& rng) {
-    parallel_sort(tbb::internal::first(rng), tbb::internal::last(rng));
-}
-
 //! Sorts the data in the range \c [begin,end) with a default comparator \c std::less<T>
 /** @ingroup algorithms **/
 template<typename T>
@@ -262,5 +250,8 @@ inline void parallel_sort( T * begin, T * end ) {
 
 } // namespace tbb
 
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_parallel_sort_H_include_area
+
 #endif
 
diff --git a/src/tbb/include/tbb/parallel_while.h b/src/tbb/include/tbb/parallel_while.h
index 2f37a41a..65984af5 100644
--- a/src/tbb/include/tbb/parallel_while.h
+++ b/src/tbb/include/tbb/parallel_while.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,15 +12,14 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_parallel_while
 #define __TBB_parallel_while
 
+#define __TBB_parallel_while_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #include "task.h"
 #include <new>
 
@@ -183,4 +182,7 @@ void parallel_while<Body>::add( const value_type& item ) {
 
 } // namespace
 
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_parallel_while_H_include_area
+
 #endif /* __TBB_parallel_while */
diff --git a/src/tbb/include/tbb/partitioner.h b/src/tbb/include/tbb/partitioner.h
index d7ebdbfe..c130d349 100644
--- a/src/tbb/include/tbb/partitioner.h
+++ b/src/tbb/include/tbb/partitioner.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,15 +12,14 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_partitioner_H
 #define __TBB_partitioner_H
 
+#define __TBB_partitioner_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #ifndef __TBB_INITIAL_CHUNKS
 // initial task divisions per thread
 #define __TBB_INITIAL_CHUNKS 2
@@ -50,6 +49,7 @@
 #endif // __TBB_DEFINE_MIC
 
 #include "task.h"
+#include "task_arena.h"
 #include "aligned_space.h"
 #include "atomic.h"
 #include "internal/_template_helpers.h"
@@ -76,7 +76,7 @@ namespace interface9 {
 namespace internal { //< @cond INTERNAL
 size_t __TBB_EXPORTED_FUNC get_initial_auto_partitioner_divisor();
 
-//! Defines entry point for affinity partitioner into tbb run-time library.
+//! Defines entry point for affinity partitioner into TBB run-time library.
 class affinity_partitioner_base_v3: no_copy {
     friend class tbb::affinity_partitioner;
     friend class tbb::interface9::internal::affinity_partition_type;
@@ -257,25 +257,6 @@ struct partition_type_base {
     }
 };
 
-//! Class determines whether template parameter has static boolean constant
-//! 'is_splittable_in_proportion' initialized with value of 'true' or not.
-/** If template parameter has such field that has been initialized with non-zero
-*  value then class field will be set to 'true', otherwise - 'false'
-*/
-template <typename Range>
-class is_splittable_in_proportion {
-private:
-    typedef char yes[1];
-    typedef char no[2];
-
-    template <typename range_type> static yes& decide(typename enable_if<range_type::is_splittable_in_proportion>::type *);
-    template <typename range_type> static no& decide(...);
-public:
-    // equals to 'true' if and only if static const variable 'is_splittable_in_proportion' of template parameter
-    // initialized with the value of 'true'
-    static const bool value = (sizeof(decide<Range>(0)) == sizeof(yes));
-};
-
 //! Provides default splitting strategy for partition objects.
 template <typename Partition>
 struct adaptive_mode : partition_type_base<Partition> {
@@ -294,6 +275,28 @@ struct adaptive_mode : partition_type_base<Partition> {
     }
 };
 
+//! A helper class to create a proportional_split object for a given type of Range.
+/** If the Range has static boolean constant 'is_splittable_in_proportion' set to 'true',
+    the created object splits a provided value in an implemenation-defined proportion;
+    otherwise it represents equal-size split. */
+// TODO: check if this helper can be a nested class of proportional_mode.
+template <typename Range, typename = void>
+struct proportion_helper {
+    static proportional_split get_split(size_t) { return proportional_split(1,1); }
+};
+template <typename Range>
+struct proportion_helper<Range, typename enable_if<Range::is_splittable_in_proportion, void>::type> {
+    static proportional_split get_split(size_t n) {
+#if __TBB_NONUNIFORM_TASK_CREATION
+        size_t right = (n + 2) / 3;
+#else
+        size_t right = n / 2;
+#endif
+        size_t left = n - right;
+        return proportional_split(left, right);
+    }
+};
+
 //! Provides proportional splitting strategy for partition objects
 template <typename Partition>
 struct proportional_mode : adaptive_mode<Partition> {
@@ -324,41 +327,32 @@ struct proportional_mode : adaptive_mode<Partition> {
     bool is_divisible() { // part of old should_execute_range()
         return self().my_divisor > my_partition::factor;
     }
-#if _MSC_VER && !defined(__INTEL_COMPILER)
-    // Suppress "conditional expression is constant" warning.
-    #pragma warning( push )
-    #pragma warning( disable: 4127 )
-#endif
     template <typename Range>
     proportional_split get_split() {
-        if (is_splittable_in_proportion<Range>::value) {
-            size_t size = self().my_divisor / my_partition::factor;
-#if __TBB_NONUNIFORM_TASK_CREATION
-            size_t right = (size + 2) / 3;
-#else
-            size_t right = size / 2;
-#endif
-            size_t left = size - right;
-            return proportional_split(left, right);
-        } else {
-            return proportional_split(1, 1);
-        }
+        // Create a proportion for the number of threads expected to handle "this" subrange
+        return proportion_helper<Range>::get_split( self().my_divisor / my_partition::factor );
     }
-#if _MSC_VER && !defined(__INTEL_COMPILER)
-    #pragma warning( pop )
-#endif // warning 4127 is back
 };
 
+static size_t get_initial_partition_head() {
+    int current_index = tbb::this_task_arena::current_thread_index();
+    if (current_index == tbb::task_arena::not_initialized)
+        current_index = 0;
+    return size_t(current_index);
+}
+
 //! Provides default linear indexing of partitioner's sequence
 template <typename Partition>
 struct linear_affinity_mode : proportional_mode<Partition> {
     size_t my_head;
+    size_t my_max_affinity;
     using proportional_mode<Partition>::self;
-    linear_affinity_mode() : proportional_mode<Partition>(), my_head(0) {}
+    linear_affinity_mode() : proportional_mode<Partition>(), my_head(get_initial_partition_head()),
+                             my_max_affinity(self().my_divisor) {}
     linear_affinity_mode(linear_affinity_mode &src, split) : proportional_mode<Partition>(src, split())
-        , my_head(src.my_head + src.my_divisor) {}
+        , my_head((src.my_head + src.my_divisor) % src.my_max_affinity), my_max_affinity(src.my_max_affinity) {}
     linear_affinity_mode(linear_affinity_mode &src, const proportional_split& split_obj) : proportional_mode<Partition>(src, split_obj)
-        , my_head(src.my_head + src.my_divisor) {}
+        , my_head((src.my_head + src.my_divisor) % src.my_max_affinity), my_max_affinity(src.my_max_affinity) {}
     void set_affinity( task &t ) {
         if( self().my_divisor )
             t.set_affinity( affinity_id(my_head) + 1 );
@@ -399,7 +393,7 @@ struct dynamic_grainsize_mode : Mode {
 #endif
         , my_delay(begin)
         , my_max_depth(p.my_max_depth) {}
-    bool check_being_stolen( task &t) { // part of old should_execute_range()
+    bool check_being_stolen(task &t) { // part of old should_execute_range()
         if( !(self().my_divisor / Mode::my_partition::factor) ) { // if not from the top P tasks of binary tree
             self().my_divisor = 1; // TODO: replace by on-stack flag (partition_state's member)?
             if( t.is_stolen_task() && t.parent()->ref_count() >= 2 ) { // runs concurrently with the left task
@@ -680,4 +674,8 @@ class affinity_partitioner: internal::affinity_partitioner_base_v3 {
 #undef __TBB_INITIAL_CHUNKS
 #undef __TBB_RANGE_POOL_CAPACITY
 #undef __TBB_INIT_DEPTH
+
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_partitioner_H_include_area
+
 #endif /* __TBB_partitioner_H */
diff --git a/src/tbb/include/tbb/pipeline.h b/src/tbb/include/tbb/pipeline.h
index 20a8ec9b..b8212ddb 100644
--- a/src/tbb/include/tbb/pipeline.h
+++ b/src/tbb/include/tbb/pipeline.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,21 +12,20 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_pipeline_H
 #define __TBB_pipeline_H
 
+#define __TBB_pipeline_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #include "atomic.h"
 #include "task.h"
 #include "tbb_allocator.h"
 #include <cstddef>
 
-#if __TBB_CPP11_TYPE_PROPERTIES_PRESENT || __TBB_TR1_TYPE_PROPERTIES_IN_STD_PRESENT
+#if __TBB_CPP11_TYPE_PROPERTIES_PRESENT
 #include <type_traits>
 #endif
 
@@ -65,7 +64,7 @@ namespace interface6 {
 class filter: internal::no_copy {
 private:
     //! Value used to mark "not in pipeline"
-    static filter* not_in_pipeline() {return reinterpret_cast<filter*>(intptr_t(-1));}
+    static filter* not_in_pipeline() { return reinterpret_cast<filter*>(intptr_t(-1)); }
 protected:
     //! The lowest bit 0 is for parallel vs. serial
     static const unsigned char filter_is_serial = 0x1;
@@ -157,7 +156,7 @@ class filter: internal::no_copy {
     //! Destroys item if pipeline was cancelled.
     /** Required to prevent memory leaks.
         Note it can be called concurrently even for serial filters.*/
-    virtual void finalize( void* /*item*/ ) {};
+    virtual void finalize( void* /*item*/ ) {}
 #endif
 
 private:
@@ -233,7 +232,7 @@ class thread_bound_filter: public filter {
 
 //! A processing pipeline that applies filters to items.
 /** @ingroup algorithms */
-class pipeline {
+class __TBB_DEPRECATED_MSG("tbb::pipeline is deprecated, use tbb::parallel_pipeline") pipeline {
 public:
     //! Construct empty pipeline.
     __TBB_EXPORTED_METHOD pipeline();
@@ -301,6 +300,12 @@ class pipeline {
 // Support for lambda-friendly parallel_pipeline interface
 //------------------------------------------------------------------------
 
+namespace flow {
+namespace interface11 {
+    template<typename Output> class input_node;
+}
+}
+
 namespace interface6 {
 
 namespace internal {
@@ -312,6 +317,7 @@ class flow_control {
     bool is_pipeline_stopped;
     flow_control() { is_pipeline_stopped = false; }
     template<typename T, typename U, typename Body> friend class internal::concrete_filter;
+    template<typename Output> friend class flow::interface11::input_node;
 public:
     void stop() { is_pipeline_stopped = true; }
 };
@@ -319,43 +325,58 @@ class flow_control {
 //! @cond INTERNAL
 namespace internal {
 
-template<typename T> struct tbb_large_object {enum { value = sizeof(T) > sizeof(void *) }; };
-
-// Obtain type properties in one or another way
+// Emulate std::is_trivially_copyable (false positives not allowed, false negatives suboptimal but safe).
 #if   __TBB_CPP11_TYPE_PROPERTIES_PRESENT
 template<typename T> struct tbb_trivially_copyable { enum { value = std::is_trivially_copyable<T>::value }; };
-#elif __TBB_TR1_TYPE_PROPERTIES_IN_STD_PRESENT
-template<typename T> struct tbb_trivially_copyable { enum { value = std::has_trivial_copy_constructor<T>::value }; };
 #else
-// Explicitly list the types we wish to be placed as-is in the pipeline input_buffers.
-template<typename T> struct tbb_trivially_copyable { enum { value = false }; };
-template<typename T> struct tbb_trivially_copyable <T*> { enum { value = true }; };
-template<> struct tbb_trivially_copyable <short> { enum { value = true }; };
-template<> struct tbb_trivially_copyable <unsigned short> { enum { value = true }; };
-template<> struct tbb_trivially_copyable <int> { enum { value = !tbb_large_object<int>::value }; };
-template<> struct tbb_trivially_copyable <unsigned int> { enum { value = !tbb_large_object<int>::value }; };
-template<> struct tbb_trivially_copyable <long> { enum { value = !tbb_large_object<long>::value }; };
-template<> struct tbb_trivially_copyable <unsigned long> { enum { value = !tbb_large_object<long>::value }; };
-template<> struct tbb_trivially_copyable <float> { enum { value = !tbb_large_object<float>::value }; };
-template<> struct tbb_trivially_copyable <double> { enum { value = !tbb_large_object<double>::value }; };
-#endif // Obtaining type properties
-
-template<typename T> struct is_large_object {enum { value = tbb_large_object<T>::value || !tbb_trivially_copyable<T>::value }; };
-
-template<typename T, bool> class token_helper;
-
-// large object helper (uses tbb_allocator)
+template<typename T> struct tbb_trivially_copyable                      { enum { value = false }; };
+template<typename T> struct tbb_trivially_copyable <         T*       > { enum { value = true  }; };
+template<>           struct tbb_trivially_copyable <         bool     > { enum { value = true  }; };
+template<>           struct tbb_trivially_copyable <         char     > { enum { value = true  }; };
+template<>           struct tbb_trivially_copyable <  signed char     > { enum { value = true  }; };
+template<>           struct tbb_trivially_copyable <unsigned char     > { enum { value = true  }; };
+template<>           struct tbb_trivially_copyable <         short    > { enum { value = true  }; };
+template<>           struct tbb_trivially_copyable <unsigned short    > { enum { value = true  }; };
+template<>           struct tbb_trivially_copyable <         int      > { enum { value = true  }; };
+template<>           struct tbb_trivially_copyable <unsigned int      > { enum { value = true  }; };
+template<>           struct tbb_trivially_copyable <         long     > { enum { value = true  }; };
+template<>           struct tbb_trivially_copyable <unsigned long     > { enum { value = true  }; };
+template<>           struct tbb_trivially_copyable <         long long> { enum { value = true  }; };
+template<>           struct tbb_trivially_copyable <unsigned long long> { enum { value = true  }; };
+template<>           struct tbb_trivially_copyable <         float    > { enum { value = true  }; };
+template<>           struct tbb_trivially_copyable <         double   > { enum { value = true  }; };
+template<>           struct tbb_trivially_copyable <    long double   > { enum { value = true  }; };
+#if !_MSC_VER || defined(_NATIVE_WCHAR_T_DEFINED)
+template<>           struct tbb_trivially_copyable <         wchar_t  > { enum { value = true  }; };
+#endif /* _MSC_VER||!defined(_NATIVE_WCHAR_T_DEFINED) */
+#endif // tbb_trivially_copyable
+
+template<typename T>
+struct use_allocator {
+    enum { value = sizeof(T) > sizeof(void *) || !tbb_trivially_copyable<T>::value };
+};
+
+// A helper class to customize how a type is passed between filters.
+// Usage: token_helper<T, use_allocator<T>::value>
+template<typename T, bool Allocate> class token_helper;
+
+// using tbb_allocator
 template<typename T>
 class token_helper<T, true> {
-    public:
+public:
     typedef typename tbb::tbb_allocator<T> allocator;
     typedef T* pointer;
     typedef T value_type;
-    static pointer create_token(const value_type & source) {
+#if __TBB_CPP11_RVALUE_REF_PRESENT
+    static pointer create_token(value_type && source)
+#else
+    static pointer create_token(const value_type & source)
+#endif
+    {
         pointer output_t = allocator().allocate(1);
-        return new (output_t) T(source);
+        return new (output_t) T(tbb::internal::move(source));
     }
-    static value_type & token(pointer & t) { return *t;}
+    static value_type & token(pointer & t) { return *t; }
     static void * cast_to_void_ptr(pointer ref) { return (void *) ref; }
     static pointer cast_from_void_ptr(void * ref) { return (pointer)ref; }
     static void destroy_token(pointer token) {
@@ -366,30 +387,29 @@ class token_helper<T, true> {
 
 // pointer specialization
 template<typename T>
-class token_helper<T*, false > {
-    public:
+class token_helper<T*, false> {
+public:
     typedef T* pointer;
     typedef T* value_type;
     static pointer create_token(const value_type & source) { return source; }
-    static value_type & token(pointer & t) { return t;}
+    static value_type & token(pointer & t) { return t; }
     static void * cast_to_void_ptr(pointer ref) { return (void *)ref; }
     static pointer cast_from_void_ptr(void * ref) { return (pointer)ref; }
     static void destroy_token( pointer /*token*/) {}
 };
 
-// small object specialization (converts void* to the correct type, passes objects directly.)
+// converting type to and from void*, passing objects directly
 template<typename T>
 class token_helper<T, false> {
     typedef union {
         T actual_value;
         void * void_overlay;
     } type_to_void_ptr_map;
-    public:
+public:
     typedef T pointer;  // not really a pointer in this case.
     typedef T value_type;
-    static pointer create_token(const value_type & source) {
-        return source; }
-    static value_type & token(pointer & t) { return t;}
+    static pointer create_token(const value_type & source) { return source; }
+    static value_type & token(pointer & t) { return t; }
     static void * cast_to_void_ptr(pointer ref) {
         type_to_void_ptr_map mymap;
         mymap.void_overlay = NULL;
@@ -404,17 +424,18 @@ class token_helper<T, false> {
     static void destroy_token( pointer /*token*/) {}
 };
 
+// intermediate
 template<typename T, typename U, typename Body>
 class concrete_filter: public tbb::filter {
     const Body& my_body;
-    typedef token_helper<T,is_large_object<T>::value > t_helper;
+    typedef token_helper<T,use_allocator<T>::value> t_helper;
     typedef typename t_helper::pointer t_pointer;
-    typedef token_helper<U,is_large_object<U>::value > u_helper;
+    typedef token_helper<U,use_allocator<U>::value> u_helper;
     typedef typename u_helper::pointer u_pointer;
 
     void* operator()(void* input) __TBB_override {
         t_pointer temp_input = t_helper::cast_from_void_ptr(input);
-        u_pointer output_u = u_helper::create_token(my_body(t_helper::token(temp_input)));
+        u_pointer output_u = u_helper::create_token(my_body(tbb::internal::move(t_helper::token(temp_input))));
         t_helper::destroy_token(temp_input);
         return u_helper::cast_to_void_ptr(output_u);
     }
@@ -432,7 +453,7 @@ class concrete_filter: public tbb::filter {
 template<typename U, typename Body>
 class concrete_filter<void,U,Body>: public filter {
     const Body& my_body;
-    typedef token_helper<U, is_large_object<U>::value > u_helper;
+    typedef token_helper<U, use_allocator<U>::value> u_helper;
     typedef typename u_helper::pointer u_pointer;
 
     void* operator()(void*) __TBB_override {
@@ -453,15 +474,16 @@ class concrete_filter<void,U,Body>: public filter {
     {}
 };
 
+// output
 template<typename T, typename Body>
 class concrete_filter<T,void,Body>: public filter {
     const Body& my_body;
-    typedef token_helper<T, is_large_object<T>::value > t_helper;
+    typedef token_helper<T, use_allocator<T>::value> t_helper;
     typedef typename t_helper::pointer t_pointer;
 
     void* operator()(void* input) __TBB_override {
         t_pointer temp_input = t_helper::cast_from_void_ptr(input);
-        my_body(t_helper::token(temp_input));
+        my_body(tbb::internal::move(t_helper::token(temp_input)));
         t_helper::destroy_token(temp_input);
         return NULL;
     }
@@ -478,7 +500,6 @@ template<typename Body>
 class concrete_filter<void,void,Body>: public filter {
     const Body& my_body;
 
-    /** Override privately because it is always called virtually */
     void* operator()(void*) __TBB_override {
         flow_control control;
         my_body(control);
@@ -518,7 +539,7 @@ class filter_node: tbb::internal::no_copy {
     //! Add concrete_filter to pipeline
     virtual void add_to( pipeline& ) = 0;
     //! Increment reference count
-    void add_ref() {++ref_count;}
+    void add_ref() { ++ref_count; }
     //! Decrement reference count and delete if it becomes zero.
     void remove_ref() {
         __TBB_ASSERT(ref_count>0,"ref_count underflow");
@@ -534,7 +555,7 @@ class filter_node: tbb::internal::no_copy {
 
 //! Node in parse tree representing result of make_filter.
 template<typename T, typename U, typename Body>
-class filter_node_leaf: public filter_node  {
+class filter_node_leaf: public filter_node {
     const tbb::filter::mode mode;
     const Body body;
     void add_to( pipeline& p ) __TBB_override {
@@ -662,4 +683,7 @@ using interface6::parallel_pipeline;
 
 } // tbb
 
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_pipeline_H_include_area
+
 #endif /* __TBB_pipeline_H */
diff --git a/src/tbb/include/tbb/queuing_mutex.h b/src/tbb/include/tbb/queuing_mutex.h
index 1dcc87c8..c5c64993 100644
--- a/src/tbb/include/tbb/queuing_mutex.h
+++ b/src/tbb/include/tbb/queuing_mutex.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,15 +12,14 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_queuing_mutex_H
 #define __TBB_queuing_mutex_H
 
+#define __TBB_queuing_mutex_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #include <cstring>
 #include "atomic.h"
 #include "tbb_profiling.h"
@@ -46,6 +45,7 @@ class queuing_mutex : internal::mutex_copy_deprecated_and_disabled {
         //! Initialize fields to mean "no lock held".
         void initialize() {
             mutex = NULL;
+            going = 0;
 #if TBB_USE_ASSERT
             internal::poison_pointer(next);
 #endif /* TBB_USE_ASSERT */
@@ -107,4 +107,7 @@ __TBB_DEFINE_PROFILING_SET_NAME(queuing_mutex)
 
 } // namespace tbb
 
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_queuing_mutex_H_include_area
+
 #endif /* __TBB_queuing_mutex_H */
diff --git a/src/tbb/include/tbb/queuing_rw_mutex.h b/src/tbb/include/tbb/queuing_rw_mutex.h
index 702cbe35..b264141c 100644
--- a/src/tbb/include/tbb/queuing_rw_mutex.h
+++ b/src/tbb/include/tbb/queuing_rw_mutex.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,15 +12,14 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_queuing_rw_mutex_H
 #define __TBB_queuing_rw_mutex_H
 
+#define __TBB_queuing_rw_mutex_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #include <cstring>
 #include "atomic.h"
 #include "tbb_profiling.h"
@@ -55,6 +54,8 @@ class queuing_rw_mutex : internal::mutex_copy_deprecated_and_disabled {
         //! Initialize fields to mean "no lock held".
         void initialize() {
             my_mutex = NULL;
+            my_internal_lock = 0;
+            my_going = 0;
 #if TBB_USE_ASSERT
             my_state = 0xFF; // Set to invalid state
             internal::poison_pointer(my_next);
@@ -147,4 +148,7 @@ __TBB_DEFINE_PROFILING_SET_NAME(queuing_rw_mutex)
 
 } // namespace tbb
 
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_queuing_rw_mutex_H_include_area
+
 #endif /* __TBB_queuing_rw_mutex_H */
diff --git a/src/tbb/include/tbb/reader_writer_lock.h b/src/tbb/include/tbb/reader_writer_lock.h
index 353beec5..509ff7b7 100644
--- a/src/tbb/include/tbb/reader_writer_lock.h
+++ b/src/tbb/include/tbb/reader_writer_lock.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,15 +12,25 @@
     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 "internal/_deprecated_header_message_guard.h"
 
+#if !defined(__TBB_show_deprecation_message_reader_writer_lock_H) && defined(__TBB_show_deprecated_header_message)
+#define  __TBB_show_deprecation_message_reader_writer_lock_H
+#pragma message("TBB Warning: tbb/reader_writer_lock.h is deprecated. For details, please see Deprecated Features appendix in the TBB reference manual.")
+#endif
 
-
-*/
+#if defined(__TBB_show_deprecated_header_message)
+#undef __TBB_show_deprecated_header_message
+#endif
 
 #ifndef __TBB_reader_writer_lock_H
 #define __TBB_reader_writer_lock_H
 
+#define __TBB_reader_writer_lock_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #include "tbb_thread.h"
 #include "tbb_allocator.h"
 #include "atomic.h"
@@ -31,7 +41,8 @@ namespace interface5 {
 /** Loosely adapted from Mellor-Crummey and Scott pseudocode at
     http://www.cs.rochester.edu/research/synchronization/pseudocode/rw.html#s_wp
     @ingroup synchronization */
-    class reader_writer_lock : tbb::internal::no_copy {
+    class __TBB_DEPRECATED_IN_VERBOSE_MODE_MSG("tbb::reader_writer_lock is deprecated, use std::shared_mutex")
+    reader_writer_lock : tbb::internal::no_copy {
  public:
     friend class scoped_lock;
     friend class scoped_lock_read;
@@ -229,4 +240,7 @@ using interface5::reader_writer_lock;
 
 } // namespace tbb
 
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_reader_writer_lock_H_include_area
+
 #endif /* __TBB_reader_writer_lock_H */
diff --git a/src/tbb/include/tbb/recursive_mutex.h b/src/tbb/include/tbb/recursive_mutex.h
index 5a23c097..d5be2c4f 100644
--- a/src/tbb/include/tbb/recursive_mutex.h
+++ b/src/tbb/include/tbb/recursive_mutex.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,15 +12,25 @@
     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 "internal/_deprecated_header_message_guard.h"
 
+#if !defined(__TBB_show_deprecation_message_recursive_mutex_H) && defined(__TBB_show_deprecated_header_message)
+#define  __TBB_show_deprecation_message_recursive_mutex_H
+#pragma message("TBB Warning: tbb/recursive_mutex.h is deprecated. For details, please see Deprecated Features appendix in the TBB reference manual.")
+#endif
 
-
-*/
+#if defined(__TBB_show_deprecated_header_message)
+#undef __TBB_show_deprecated_header_message
+#endif
 
 #ifndef __TBB_recursive_mutex_H
 #define __TBB_recursive_mutex_H
 
+#define __TBB_recursive_mutex_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #if _WIN32||_WIN64
 #include "machine/windows_api.h"
 #else
@@ -36,7 +46,8 @@ namespace tbb {
 //! Mutex that allows recursive mutex acquisition.
 /** Mutex that allows recursive mutex acquisition.
     @ingroup synchronization */
-class recursive_mutex : internal::mutex_copy_deprecated_and_disabled {
+class __TBB_DEPRECATED_IN_VERBOSE_MODE_MSG("tbb::recursive_mutex is deprecated, use std::recursive_mutex")
+recursive_mutex : internal::mutex_copy_deprecated_and_disabled {
 public:
     //! Construct unacquired recursive_mutex.
     recursive_mutex() {
@@ -231,4 +242,7 @@ __TBB_DEFINE_PROFILING_SET_NAME(recursive_mutex)
 
 } // namespace tbb
 
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_recursive_mutex_H_include_area
+
 #endif /* __TBB_recursive_mutex_H */
diff --git a/src/tbb/include/tbb/runtime_loader.h b/src/tbb/include/tbb/runtime_loader.h
index df284645..9aaeea5b 100644
--- a/src/tbb/include/tbb/runtime_loader.h
+++ b/src/tbb/include/tbb/runtime_loader.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,15 +12,25 @@
     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 "internal/_deprecated_header_message_guard.h"
 
+#if !defined(__TBB_show_deprecation_message_runtime_loader_H) && defined(__TBB_show_deprecated_header_message)
+#define  __TBB_show_deprecation_message_runtime_loader_H
+#pragma message("TBB Warning: tbb/runtime_loader.h is deprecated. For details, please see Deprecated Features appendix in the TBB reference manual.")
+#endif
 
-
-*/
+#if defined(__TBB_show_deprecated_header_message)
+#undef __TBB_show_deprecated_header_message
+#endif
 
 #ifndef __TBB_runtime_loader_H
 #define __TBB_runtime_loader_H
 
+#define __TBB_runtime_loader_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #if ! TBB_PREVIEW_RUNTIME_LOADER
     #error Set TBB_PREVIEW_RUNTIME_LOADER to include runtime_loader.h
 #endif
@@ -82,7 +92,7 @@ There are some implications:
 
 */
 
-class runtime_loader : tbb::internal::no_copy {
+class __TBB_DEPRECATED_IN_VERBOSE_MODE runtime_loader : tbb::internal::no_copy {
 
     public:
 
@@ -176,5 +186,8 @@ using interface6::runtime_loader;
 
 } // namespace tbb
 
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_runtime_loader_H_include_area
+
 #endif /* __TBB_runtime_loader_H */
 
diff --git a/src/tbb/include/tbb/scalable_allocator.h b/src/tbb/include/tbb/scalable_allocator.h
index 0bebe21e..f1fc98ed 100644
--- a/src/tbb/include/tbb/scalable_allocator.h
+++ b/src/tbb/include/tbb/scalable_allocator.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_scalable_allocator_H
@@ -95,9 +91,12 @@ typedef enum {
     TBBMALLOC_USE_HUGE_PAGES,  /* value turns using huge pages on and off */
     /* deprecated, kept for backward compatibility only */
     USE_HUGE_PAGES = TBBMALLOC_USE_HUGE_PAGES,
-    /* try to limit memory consumption value Bytes, clean internal buffers
+    /* try to limit memory consumption value (Bytes), clean internal buffers
        if limit is exceeded, but not prevents from requesting memory from OS */
-    TBBMALLOC_SET_SOFT_HEAP_LIMIT
+    TBBMALLOC_SET_SOFT_HEAP_LIMIT,
+    /* Lower bound for the size (Bytes), that is interpreted as huge
+     * and not released during regular cleanup operations. */
+    TBBMALLOC_SET_HUGE_SIZE_THRESHOLD
 } AllocationModeParam;
 
 /** Set TBB allocator-specific allocation modes.
@@ -193,6 +192,7 @@ void *pool_aligned_realloc(MemoryPool* mPool, void *ptr, size_t size, size_t ali
 bool  pool_reset(MemoryPool* memPool);
 bool  pool_free(MemoryPool *memPool, void *object);
 MemoryPool *pool_identify(void *object);
+size_t pool_msize(MemoryPool *memPool, void *object);
 
 } // namespace rml
 
@@ -208,7 +208,11 @@ MemoryPool *pool_identify(void *object);
 #endif
 
 #if __TBB_ALLOCATOR_CONSTRUCT_VARIADIC
- #include <utility> // std::forward
+#include <utility> // std::forward
+#endif
+
+#if __TBB_CPP17_MEMORY_RESOURCE_PRESENT
+#include <memory_resource>
 #endif
 
 namespace tbb {
@@ -315,6 +319,48 @@ inline bool operator==( const scalable_allocator<T>&, const scalable_allocator<U
 template<typename T, typename U>
 inline bool operator!=( const scalable_allocator<T>&, const scalable_allocator<U>& ) {return false;}
 
+#if __TBB_CPP17_MEMORY_RESOURCE_PRESENT
+
+namespace internal {
+
+//! C++17 memory resource implementation for scalable allocator
+//! ISO C++ Section 23.12.2
+class scalable_resource_impl : public std::pmr::memory_resource {
+private:
+    void* do_allocate(size_t bytes, size_t alignment) override {
+        void* ptr = scalable_aligned_malloc( bytes, alignment );
+        if (!ptr) {
+            throw_exception(std::bad_alloc());
+        }
+        return ptr;
+    }
+
+    void do_deallocate(void* ptr, size_t /*bytes*/, size_t /*alignment*/) override {
+        scalable_free(ptr);
+    }
+
+    //! Memory allocated by one instance of scalable_resource_impl could be deallocated by any
+    //! other instance of this class
+    bool do_is_equal(const std::pmr::memory_resource& other) const noexcept override {
+        return this == &other ||
+#if __TBB_USE_OPTIONAL_RTTI
+            dynamic_cast<const scalable_resource_impl*>(&other) != NULL;
+#else
+            false;
+#endif
+    }
+};
+
+} // namespace internal
+
+//! Global scalable allocator memory resource provider
+inline std::pmr::memory_resource* scalable_memory_resource() noexcept {
+    static tbb::internal::scalable_resource_impl scalable_res;
+    return &scalable_res;
+}
+
+#endif /* __TBB_CPP17_MEMORY_RESOURCE_PRESENT */
+
 } // namespace tbb
 
 #if _MSC_VER
diff --git a/src/tbb/include/tbb/spin_mutex.h b/src/tbb/include/tbb/spin_mutex.h
index 99ef15c2..56348c9d 100644
--- a/src/tbb/include/tbb/spin_mutex.h
+++ b/src/tbb/include/tbb/spin_mutex.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,15 +12,14 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_spin_mutex_H
 #define __TBB_spin_mutex_H
 
+#define __TBB_spin_mutex_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #include <cstddef>
 #include <new>
 #include "aligned_space.h"
@@ -209,4 +208,7 @@ __TBB_DEFINE_PROFILING_SET_NAME(speculative_spin_mutex)
 
 } // namespace tbb
 
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_spin_mutex_H_include_area
+
 #endif /* __TBB_spin_mutex_H */
diff --git a/src/tbb/include/tbb/spin_rw_mutex.h b/src/tbb/include/tbb/spin_rw_mutex.h
index b20f4ebd..57a4ce2f 100644
--- a/src/tbb/include/tbb/spin_rw_mutex.h
+++ b/src/tbb/include/tbb/spin_rw_mutex.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_spin_rw_mutex_H
@@ -90,9 +86,6 @@ class spin_rw_mutex_v3 : internal::mutex_copy_deprecated_and_disabled {
     class scoped_lock : internal::no_copy {
 #if __TBB_TSX_AVAILABLE
         friend class tbb::interface8::internal::x86_rtm_rw_mutex;
-        // helper methods for x86_rtm_rw_mutex
-        spin_rw_mutex *internal_get_mutex() const { return mutex; }
-        void internal_set_mutex(spin_rw_mutex* m) { mutex = m; }
 #endif
     public:
         //! Construct lock that has not acquired a mutex.
@@ -121,15 +114,15 @@ class spin_rw_mutex_v3 : internal::mutex_copy_deprecated_and_disabled {
         //! Upgrade reader to become a writer.
         /** Returns whether the upgrade happened without releasing and re-acquiring the lock */
         bool upgrade_to_writer() {
-            __TBB_ASSERT( mutex, "lock is not acquired" );
-            __TBB_ASSERT( !is_writer, "not a reader" );
+            __TBB_ASSERT( mutex, "mutex is not acquired" );
+            if (is_writer) return true; // Already a writer
             is_writer = true;
             return mutex->internal_upgrade();
         }
 
         //! Release lock.
         void release() {
-            __TBB_ASSERT( mutex, "lock is not acquired" );
+            __TBB_ASSERT( mutex, "mutex is not acquired" );
             spin_rw_mutex *m = mutex;
             mutex = NULL;
 #if TBB_USE_THREADING_TOOLS||TBB_USE_ASSERT
@@ -143,8 +136,8 @@ class spin_rw_mutex_v3 : internal::mutex_copy_deprecated_and_disabled {
 
         //! Downgrade writer to become a reader.
         bool downgrade_to_reader() {
-            __TBB_ASSERT( mutex, "lock is not acquired" );
-            __TBB_ASSERT( is_writer, "not a writer" );
+            __TBB_ASSERT( mutex, "mutex is not acquired" );
+            if (!is_writer) return true; // Already a reader
 #if TBB_USE_THREADING_TOOLS||TBB_USE_ASSERT
             mutex->internal_downgrade();
 #else
diff --git a/src/tbb/include/tbb/task.h b/src/tbb/include/tbb/task.h
index 0b04c6b9..5e137c69 100644
--- a/src/tbb/include/tbb/task.h
+++ b/src/tbb/include/tbb/task.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,15 +12,25 @@
     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 "internal/_deprecated_header_message_guard.h"
 
+#if !defined(__TBB_show_deprecation_message_task_H) && defined(__TBB_show_deprecated_header_message)
+#define  __TBB_show_deprecation_message_task_H
+#pragma message("TBB Warning: tbb/task.h is deprecated. For details, please see Deprecated Features appendix in the TBB reference manual.")
+#endif
 
-
-*/
+#if defined(__TBB_show_deprecated_header_message)
+#undef __TBB_show_deprecated_header_message
+#endif
 
 #ifndef __TBB_task_H
 #define __TBB_task_H
 
+#define __TBB_task_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #include "tbb_stddef.h"
 #include "tbb_machine.h"
 #include "tbb_profiling.h"
@@ -49,7 +59,9 @@ namespace internal { //< @cond INTERNAL
         task* self;
         task& parent;
     public:
-        explicit allocate_additional_child_of_proxy( task& parent_ ) : self(NULL), parent(parent_) {}
+        explicit allocate_additional_child_of_proxy( task& parent_ ) : self(NULL), parent(parent_) {
+            suppress_unused_warning( self );
+        }
         task& __TBB_EXPORTED_METHOD allocate( size_t size ) const;
         void __TBB_EXPORTED_METHOD free( task& ) const;
     };
@@ -118,6 +130,11 @@ namespace internal {
     /** Should always be non-negative.  A signed type is used so that underflow can be detected. */
     typedef intptr_t reference_count;
 
+#if __TBB_PREVIEW_RESUMABLE_TASKS
+    //! The flag to indicate that the wait task has been abandoned.
+    static const reference_count abandon_flag = reference_count(1) << (sizeof(reference_count)*CHAR_BIT - 2);
+#endif
+
     //! An id as used for specifying affinity.
     typedef unsigned short affinity_id;
 
@@ -162,6 +179,12 @@ namespace internal {
         void __TBB_EXPORTED_METHOD free( task& ) const;
     };
 
+#if __TBB_PREVIEW_CRITICAL_TASKS
+    // TODO: move to class methods when critical task API becomes public
+    void make_critical( task& t );
+    bool is_critical( task& t );
+#endif
+
     //! Memory prefix to a task object.
     /** This class is internal to the library.
         Do not reference it directly, except within the library itself.
@@ -187,6 +210,10 @@ namespace internal {
         friend class internal::allocate_child_proxy;
         friend class internal::allocate_continuation_proxy;
         friend class internal::allocate_additional_child_of_proxy;
+#if __TBB_PREVIEW_CRITICAL_TASKS
+        friend void make_critical( task& );
+        friend bool is_critical( task& );
+#endif
 
 #if __TBB_TASK_ISOLATION
         //! The tag used for task isolation.
@@ -211,7 +238,7 @@ namespace internal {
             thread-specific pools. */
         scheduler* origin;
 
-#if __TBB_TASK_PRIORITY
+#if __TBB_TASK_PRIORITY || __TBB_PREVIEW_RESUMABLE_TASKS
         union {
 #endif /* __TBB_TASK_PRIORITY */
         //! Obsolete. The scheduler that owns the task.
@@ -223,8 +250,15 @@ namespace internal {
         //! Pointer to the next offloaded lower priority task.
         /** Used to maintain a list of offloaded tasks inside the scheduler. **/
         task* next_offloaded;
+#endif
+
+#if __TBB_PREVIEW_RESUMABLE_TASKS
+        //! Pointer to the abandoned scheduler where the current task is waited for.
+        scheduler* abandoned_scheduler;
+#endif
+#if __TBB_TASK_PRIORITY || __TBB_PREVIEW_RESUMABLE_TASKS
         };
-#endif /* __TBB_TASK_PRIORITY */
+#endif /* __TBB_TASK_PRIORITY || __TBB_PREVIEW_RESUMABLE_TASKS */
 
         //! The task whose reference count includes me.
         /** In the "blocking style" of programming, this field points to the parent task.
@@ -274,6 +308,10 @@ namespace internal {
 #if __TBB_TASK_PRIORITY
 namespace internal {
     static const int priority_stride_v4 = INT_MAX / 4;
+#if __TBB_PREVIEW_CRITICAL_TASKS
+    // TODO: move into priority_t enum when critical tasks become public feature
+    static const int priority_critical = priority_stride_v4 * 3 + priority_stride_v4 / 3 * 2;
+#endif
 }
 
 enum priority_t {
@@ -294,6 +332,7 @@ enum priority_t {
 
 class task_scheduler_init;
 namespace interface7 { class task_arena; }
+using interface7::task_arena;
 
 //! Used to form groups of tasks
 /** @ingroup task_scheduling
@@ -320,7 +359,7 @@ class task_group_context : internal::no_copy {
 private:
     friend class internal::generic_scheduler;
     friend class task_scheduler_init;
-    friend class interface7::task_arena;
+    friend class task_arena;
 
 #if TBB_USE_CAPTURED_EXCEPTION
     typedef tbb_exception exception_container_type;
@@ -420,12 +459,16 @@ class task_group_context : internal::no_copy {
     intptr_t my_priority;
 #endif /* __TBB_TASK_PRIORITY */
 
+    //! Description of algorithm for scheduler based instrumentation.
+    internal::string_index my_name;
+
     //! Trailing padding protecting accesses to frequently used members from false sharing
     /** \sa _leading_padding **/
     char _trailing_padding[internal::NFS_MaxLineSize - 2 * sizeof(uintptr_t) - 2 * sizeof(void*)
 #if __TBB_TASK_PRIORITY
-                            - sizeof(intptr_t)
+                           - sizeof(intptr_t)
 #endif /* __TBB_TASK_PRIORITY */
+                           - sizeof(internal::string_index)
                           ];
 
 public:
@@ -461,7 +504,17 @@ class task_group_context : internal::no_copy {
     task_group_context ( kind_type relation_with_parent = bound,
                          uintptr_t t = default_traits )
         : my_kind(relation_with_parent)
-        , my_version_and_traits(2 | t)
+        , my_version_and_traits(3 | t)
+        , my_name(internal::CUSTOM_CTX)
+    {
+        init();
+    }
+
+    // Custom constructor for instrumentation of TBB algorithm
+    task_group_context ( internal::string_index name )
+        : my_kind(bound)
+        , my_version_and_traits(3 | default_traits)
+        , my_name(name)
     {
         init();
     }
@@ -515,10 +568,10 @@ class task_group_context : internal::no_copy {
 
 #if __TBB_TASK_PRIORITY
     //! Changes priority of the task group
-    void set_priority ( priority_t );
+    __TBB_DEPRECATED_IN_VERBOSE_MODE void set_priority ( priority_t );
 
     //! Retrieves current priority of the current task group
-    priority_t priority () const;
+    __TBB_DEPRECATED_IN_VERBOSE_MODE priority_t priority () const;
 #endif /* __TBB_TASK_PRIORITY */
 
     //! Returns the context's trait
@@ -559,7 +612,7 @@ class task_group_context : internal::no_copy {
 
 //! Base class for user-defined tasks.
 /** @ingroup task_scheduling */
-class task: __TBB_TASK_BASE_ACCESS interface5::internal::task_base {
+class __TBB_DEPRECATED_IN_VERBOSE_MODE task: __TBB_TASK_BASE_ACCESS interface5::internal::task_base {
 
     //! Set reference count
     void __TBB_EXPORTED_METHOD internal_set_ref_count( int count );
@@ -595,6 +648,10 @@ class task: __TBB_TASK_BASE_ACCESS interface5::internal::task_base {
 #if __TBB_RECYCLE_TO_ENQUEUE
         //! task to be scheduled for starvation-resistant execution
         ,to_enqueue
+#endif
+#if __TBB_PREVIEW_RESUMABLE_TASKS
+        //! a special task used to resume a scheduler.
+        ,to_resume
 #endif
     };
 
@@ -783,11 +840,24 @@ class task: __TBB_TASK_BASE_ACCESS interface5::internal::task_base {
 #if __TBB_TASK_PRIORITY
     //! Enqueue task for starvation-resistant execution on the specified priority level.
     static void enqueue( task& t, priority_t p ) {
-        __TBB_ASSERT( p == priority_low || p == priority_normal || p == priority_high, "Invalid priority level value" );
+#if __TBB_PREVIEW_CRITICAL_TASKS
+        __TBB_ASSERT(p == priority_low || p == priority_normal || p == priority_high
+                     || p == internal::priority_critical, "Invalid priority level value");
+#else
+        __TBB_ASSERT(p == priority_low || p == priority_normal || p == priority_high, "Invalid priority level value");
+#endif
         t.prefix().owner->enqueue( t, (void*)p );
     }
 #endif /* __TBB_TASK_PRIORITY */
 
+    //! Enqueue task in task_arena
+    //! The implementation is in task_arena.h
+#if __TBB_TASK_PRIORITY
+    inline static void enqueue( task& t, task_arena& arena, priority_t p = priority_t(0) );
+#else
+    inline static void enqueue( task& t, task_arena& arena);
+#endif
+
     //! The innermost task being executed or destroyed by the current thread at the moment.
     static task& __TBB_EXPORTED_FUNC self();
 
@@ -816,6 +886,24 @@ class task: __TBB_TASK_BASE_ACCESS interface5::internal::task_base {
         return (prefix().extra_state & 0x80)!=0;
     }
 
+    //! True if the task was enqueued
+    bool is_enqueued_task() const {
+        // es_task_enqueued = 0x10
+        return (prefix().extra_state & 0x10)!=0;
+    }
+
+#if __TBB_PREVIEW_RESUMABLE_TASKS
+    //! Type that defines suspension point
+    typedef void* suspend_point;
+
+    //! Suspend current task execution
+    template <typename F>
+    static void suspend(F f);
+
+    //! Resume specific suspend point
+    static void resume(suspend_point tag);
+#endif
+
     //------------------------------------------------------------------------
     // Debugging
     //------------------------------------------------------------------------
@@ -826,10 +914,18 @@ class task: __TBB_TASK_BASE_ACCESS interface5::internal::task_base {
     //! The internal reference count.
     int ref_count() const {
 #if TBB_USE_ASSERT
+#if __TBB_PREVIEW_RESUMABLE_TASKS
+        internal::reference_count ref_count_ = prefix().ref_count & ~internal::abandon_flag;
+#else
         internal::reference_count ref_count_ = prefix().ref_count;
+#endif
         __TBB_ASSERT( ref_count_==int(ref_count_), "integer overflow error");
 #endif
+#if __TBB_PREVIEW_RESUMABLE_TASKS
+        return int(prefix().ref_count & ~internal::abandon_flag);
+#else
         return int(prefix().ref_count);
+#endif
     }
 
     //! Obsolete, and only retained for the sake of backward compatibility. Always returns true.
@@ -882,10 +978,10 @@ class task: __TBB_TASK_BASE_ACCESS interface5::internal::task_base {
 
 #if __TBB_TASK_PRIORITY
     //! Changes priority of the task group this task belongs to.
-    void set_group_priority ( priority_t p ) {  prefix().context->set_priority(p); }
+    __TBB_DEPRECATED void set_group_priority ( priority_t p ) {  prefix().context->set_priority(p); }
 
     //! Retrieves current priority of the task group this task belongs to.
-    priority_t group_priority () const { return prefix().context->priority(); }
+    __TBB_DEPRECATED priority_t group_priority () const { return prefix().context->priority(); }
 
 #endif /* __TBB_TASK_PRIORITY */
 
@@ -906,11 +1002,44 @@ class task: __TBB_TASK_BASE_ACCESS interface5::internal::task_base {
     internal::task_prefix& prefix( internal::version_tag* = NULL ) const {
         return reinterpret_cast<internal::task_prefix*>(const_cast<task*>(this))[-1];
     }
+#if __TBB_PREVIEW_CRITICAL_TASKS
+    friend void internal::make_critical( task& );
+    friend bool internal::is_critical( task& );
+#endif
 }; // class task
 
+#if __TBB_PREVIEW_CRITICAL_TASKS
+namespace internal {
+inline void make_critical( task& t ) { t.prefix().extra_state |= 0x8; }
+inline bool is_critical( task& t ) { return bool((t.prefix().extra_state & 0x8) != 0); }
+} // namespace internal
+#endif /* __TBB_PREVIEW_CRITICAL_TASKS */
+
+#if __TBB_PREVIEW_RESUMABLE_TASKS
+namespace internal {
+    template <typename F>
+    static void suspend_callback(void* user_callback, task::suspend_point tag) {
+        // Copy user function to a new stack to avoid a race when the previous scheduler is resumed.
+        F user_callback_copy = *static_cast<F*>(user_callback);
+        user_callback_copy(tag);
+    }
+    void __TBB_EXPORTED_FUNC internal_suspend(void* suspend_callback, void* user_callback);
+    void __TBB_EXPORTED_FUNC internal_resume(task::suspend_point);
+    task::suspend_point __TBB_EXPORTED_FUNC internal_current_suspend_point();
+}
+
+template <typename F>
+inline void task::suspend(F f) {
+    internal::internal_suspend((void*)internal::suspend_callback<F>, &f);
+}
+inline void task::resume(suspend_point tag) {
+    internal::internal_resume(tag);
+}
+#endif
+
 //! task that does nothing.  Useful for synchronization.
 /** @ingroup task_scheduling */
-class empty_task: public task {
+class __TBB_DEPRECATED_IN_VERBOSE_MODE empty_task: public task {
     task* execute() __TBB_override {
         return NULL;
     }
@@ -921,6 +1050,7 @@ namespace internal {
     template<typename F>
     class function_task : public task {
 #if __TBB_ALLOW_MUTABLE_FUNCTORS
+        // TODO: deprecated behavior, remove
         F my_func;
 #else
         const F my_func;
@@ -941,7 +1071,7 @@ namespace internal {
 //! A list of children.
 /** Used for method task::spawn_children
     @ingroup task_scheduling */
-class task_list: internal::no_copy {
+class __TBB_DEPRECATED_IN_VERBOSE_MODE task_list: internal::no_copy {
 private:
     task* first;
     task** next_ptr;
@@ -954,7 +1084,7 @@ class task_list: internal::no_copy {
     //! Destroys the list, but does not destroy the task objects.
     ~task_list() {}
 
-    //! True if list if empty; false otherwise.
+    //! True if list is empty; false otherwise.
     bool empty() const {return !first;}
 
     //! Push task onto back of list.
@@ -1053,4 +1183,7 @@ inline void operator delete( void* task, const tbb::internal::allocate_additiona
     p.free( *static_cast<tbb::task*>(task) );
 }
 
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_task_H_include_area
+
 #endif /* __TBB_task_H */
diff --git a/src/tbb/include/tbb/task_arena.h b/src/tbb/include/tbb/task_arena.h
index 94977aeb..46eb4959 100644
--- a/src/tbb/include/tbb/task_arena.h
+++ b/src/tbb/include/tbb/task_arena.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,18 +12,20 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_task_arena_H
 #define __TBB_task_arena_H
 
+#define __TBB_task_arena_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #include "task.h"
 #include "tbb_exception.h"
 #include "internal/_template_helpers.h"
+#if __TBB_NUMA_SUPPORT
+#include "info.h"
+#endif /*__TBB_NUMA_SUPPORT*/
 #if TBB_USE_THREADING_TOOLS
 #include "atomic.h" // for as_atomic
 #endif
@@ -57,7 +59,7 @@ class delegate_base : no_assign {
     virtual ~delegate_base() {}
 };
 
-// If decltype is availabe, the helper detects the return type of functor of specified type,
+// If decltype is available, the helper detects the return type of functor of specified type,
 // otherwise it defines the void type.
 template <typename F>
 struct return_type_or_void {
@@ -96,11 +98,23 @@ class delegated_function<F,void> : public delegate_base {
 public:
     delegated_function(F& f) : my_func(f) {}
     void consume_result() const {}
-    
+
     friend class task_arena_base;
 };
 
 class task_arena_base {
+#if __TBB_NUMA_SUPPORT
+public:
+    // TODO: consider version approach to resolve backward compatibility potential issues.
+    struct constraints {
+        constraints(numa_node_id id = automatic, int maximal_concurrency = automatic)
+            : numa_id(id)
+            , max_concurrency(maximal_concurrency)
+        {}
+        numa_node_id numa_id;
+        int max_concurrency;
+    };
+#endif /*__TBB_NUMA_SUPPORT*/
 protected:
     //! NULL if not currently initialized.
     internal::arena* my_arena;
@@ -119,11 +133,30 @@ class task_arena_base {
     //! Special settings
     intptr_t my_version_and_traits;
 
+    bool my_initialized;
+
+#if __TBB_NUMA_SUPPORT
+    //! The NUMA node index to which the arena will be attached
+    numa_node_id my_numa_id;
+
+    // Do not access my_numa_id without the following runtime check.
+    // Despite my_numa_id is accesible, it does not exist in task_arena_base on user side
+    // if TBB_PREVIEW_NUMA_SUPPORT macro is not defined by the user. To be sure that
+    // my_numa_id exists in task_arena_base layout we check the traits.
+    // TODO: Consider increasing interface version for task_arena_base instead of this runtime check.
+    numa_node_id numa_id() {
+        return (my_version_and_traits & numa_support_flag) == numa_support_flag ? my_numa_id : automatic;
+    }
+#endif
+
     enum {
         default_flags = 0
 #if __TBB_TASK_GROUP_CONTEXT
         | (task_group_context::default_traits & task_group_context::exact_exception)  // 0 or 1 << 16
         , exact_exception_flag = task_group_context::exact_exception // used to specify flag for context directly
+#endif
+#if __TBB_NUMA_SUPPORT
+        , numa_support_flag = 1
 #endif
     };
 
@@ -134,8 +167,30 @@ class task_arena_base {
 #endif
         , my_max_concurrency(max_concurrency)
         , my_master_slots(reserved_for_masters)
+#if __TBB_NUMA_SUPPORT
+        , my_version_and_traits(default_flags | numa_support_flag)
+#else
         , my_version_and_traits(default_flags)
+#endif
+        , my_initialized(false)
+#if __TBB_NUMA_SUPPORT
+        , my_numa_id(automatic)
+#endif
+        {}
+
+#if __TBB_NUMA_SUPPORT
+    task_arena_base(const constraints& constraints_, unsigned reserved_for_masters)
+        : my_arena(0)
+#if __TBB_TASK_GROUP_CONTEXT
+        , my_context(0)
+#endif
+        , my_max_concurrency(constraints_.max_concurrency)
+        , my_master_slots(reserved_for_masters)
+        , my_version_and_traits(default_flags | numa_support_flag)
+        , my_initialized(false)
+        , my_numa_id(constraints_.numa_id )
         {}
+#endif /*__TBB_NUMA_SUPPORT*/
 
     void __TBB_EXPORTED_METHOD internal_initialize();
     void __TBB_EXPORTED_METHOD internal_terminate();
@@ -153,7 +208,7 @@ class task_arena_base {
 };
 
 #if __TBB_TASK_ISOLATION
-void __TBB_EXPORTED_FUNC isolate_within_arena( delegate_base& d, intptr_t reserved = 0 );
+void __TBB_EXPORTED_FUNC isolate_within_arena( delegate_base& d, intptr_t isolation = 0 );
 
 template<typename R, typename F>
 R isolate_impl(F& f) {
@@ -172,8 +227,12 @@ R isolate_impl(F& f) {
  */
 class task_arena : public internal::task_arena_base {
     friend class tbb::internal::task_scheduler_observer_v3;
+    friend void task::enqueue(task&, task_arena&
+#if __TBB_TASK_PRIORITY
+        , priority_t
+#endif
+    );
     friend int tbb::this_task_arena::max_concurrency();
-    bool my_initialized;
     void mark_initialized() {
         __TBB_ASSERT( my_arena, "task_arena initialization is incomplete" );
 #if __TBB_TASK_GROUP_CONTEXT
@@ -222,14 +281,24 @@ class task_arena : public internal::task_arena_base {
      **/
     task_arena(int max_concurrency_ = automatic, unsigned reserved_for_masters = 1)
         : task_arena_base(max_concurrency_, reserved_for_masters)
-        , my_initialized(false)
+    {}
+
+#if __TBB_NUMA_SUPPORT
+    //! Creates task arena pinned to certain NUMA node
+    task_arena(const constraints& constraints_, unsigned reserved_for_masters = 1)
+        : task_arena_base(constraints_, reserved_for_masters)
     {}
 
+    //! Copies settings from another task_arena
+    task_arena(const task_arena &s) // copy settings but not the reference or instance
+        : task_arena_base(constraints(s.my_numa_id, s.my_max_concurrency), s.my_master_slots)
+    {}
+#else
     //! Copies settings from another task_arena
     task_arena(const task_arena &s) // copy settings but not the reference or instance
         : task_arena_base(s.my_max_concurrency, s.my_master_slots)
-        , my_initialized(false)
     {}
+#endif /*__TBB_NUMA_SUPPORT*/
 
     //! Tag class used to indicate the "attaching" constructor
     struct attach {};
@@ -237,7 +306,6 @@ class task_arena : public internal::task_arena_base {
     //! Creates an instance of task_arena attached to the current arena of the thread
     explicit task_arena( attach )
         : task_arena_base(automatic, 1) // use default settings if attach fails
-        , my_initialized(false)
     {
         internal_attach();
         if( my_arena ) my_initialized = true;
@@ -262,6 +330,19 @@ class task_arena : public internal::task_arena_base {
         }
     }
 
+#if __TBB_NUMA_SUPPORT
+    inline void initialize(constraints constraints_, unsigned reserved_for_masters = 1) {
+        // TODO: decide if this call must be thread-safe
+        __TBB_ASSERT(!my_arena, "Impossible to modify settings of an already initialized task_arena");
+        if( !my_initialized ) {
+            my_numa_id = constraints_.numa_id;
+            my_max_concurrency = constraints_.max_concurrency;
+            my_master_slots = reserved_for_masters;
+            initialize();
+        }
+    }
+#endif /*__TBB_NUMA_SUPPORT*/
+
     //! Attaches this instance to the current arena of the thread
     inline void initialize(attach) {
         // TODO: decide if this call must be thread-safe
@@ -312,13 +393,23 @@ class task_arena : public internal::task_arena_base {
     //! Does not require the calling thread to join the arena
     template<typename F>
 #if __TBB_CPP11_RVALUE_REF_PRESENT
-    void enqueue( F&& f, priority_t p ) {
+    __TBB_DEPRECATED void enqueue( F&& f, priority_t p ) {
+#if __TBB_PREVIEW_CRITICAL_TASKS
+        __TBB_ASSERT(p == priority_low || p == priority_normal || p == priority_high
+                     || p == internal::priority_critical, "Invalid priority level value");
+#else
         __TBB_ASSERT(p == priority_low || p == priority_normal || p == priority_high, "Invalid priority level value");
+#endif
         enqueue_impl(std::forward<F>(f), p);
     }
 #else
-    void enqueue( const F& f, priority_t p ) {
+    __TBB_DEPRECATED void enqueue( const F& f, priority_t p ) {
+#if __TBB_PREVIEW_CRITICAL_TASKS
+        __TBB_ASSERT(p == priority_low || p == priority_normal || p == priority_high
+                     || p == internal::priority_critical, "Invalid priority level value");
+#else
         __TBB_ASSERT(p == priority_low || p == priority_normal || p == priority_high, "Invalid priority level value");
+#endif
         enqueue_impl(f,p);
     }
 #endif
@@ -365,8 +456,8 @@ class task_arena : public internal::task_arena_base {
     }
 };
 
-#if __TBB_TASK_ISOLATION
 namespace this_task_arena {
+#if __TBB_TASK_ISOLATION
     //! Executes a mutable functor in isolation within the current task arena.
     //! Since C++11, the method returns the value returned by functor (prior to C++11 it returns void).
     template<typename F>
@@ -380,18 +471,15 @@ namespace this_task_arena {
     typename internal::return_type_or_void<F>::type isolate(const F& f) {
         return internal::isolate_impl<typename internal::return_type_or_void<F>::type>(f);
     }
-}
 #endif /* __TBB_TASK_ISOLATION */
+} // namespace this_task_arena
 } // namespace interfaceX
 
 using interface7::task_arena;
-#if __TBB_TASK_ISOLATION
+
 namespace this_task_arena {
     using namespace interface7::this_task_arena;
-}
-#endif /* __TBB_TASK_ISOLATION */
 
-namespace this_task_arena {
     //! Returns the index, aka slot number, of the calling thread in its current arena
     inline int current_thread_index() {
         int idx = tbb::task_arena::current_thread_index();
@@ -404,6 +492,20 @@ namespace this_task_arena {
     }
 } // namespace this_task_arena
 
+//! Enqueue task in task_arena
+#if __TBB_TASK_PRIORITY
+void task::enqueue( task& t, task_arena& arena, priority_t p ) {
+#else
+void task::enqueue( task& t, task_arena& arena ) {
+    intptr_t p = 0;
+#endif
+    arena.initialize();
+    //! Note: the context of the task may differ from the context instantiated by task_arena
+    arena.internal_enqueue(t, p);
+}
 } // namespace tbb
 
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_task_arena_H_include_area
+
 #endif /* __TBB_task_arena_H */
diff --git a/src/tbb/include/tbb/task_group.h b/src/tbb/include/tbb/task_group.h
index b30addc8..f090d3a2 100644
--- a/src/tbb/include/tbb/task_group.h
+++ b/src/tbb/include/tbb/task_group.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,18 +12,20 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_task_group_H
 #define __TBB_task_group_H
 
+#define __TBB_task_group_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #include "task.h"
 #include "tbb_exception.h"
 #include "internal/_template_helpers.h"
+#if TBB_PREVIEW_ISOLATED_TASK_GROUP && __TBB_TASK_ISOLATION
+#include "task_arena.h"
+#endif
 
 #if __TBB_TASK_GROUP_CONTEXT
 
@@ -35,12 +37,18 @@ namespace internal {
 
 class task_group;
 class structured_task_group;
+#if TBB_PREVIEW_ISOLATED_TASK_GROUP && __TBB_TASK_ISOLATION
+class isolated_task_group;
+#endif
 
 template<typename F>
 class task_handle : internal::no_assign {
     template<typename _F> friend class internal::task_handle_task;
     friend class task_group;
     friend class structured_task_group;
+#if TBB_PREVIEW_ISOLATED_TASK_GROUP && __TBB_TASK_ISOLATION
+    friend class isolated_task_group;
+#endif
 
     static const intptr_t scheduled = 0x1;
 
@@ -82,17 +90,29 @@ class task_handle_task : public task {
 };
 
 class task_group_base : internal::no_copy {
+    class ref_count_guard : internal::no_copy {
+        task& my_task;
+    public:
+        ref_count_guard(task& t) : my_task(t) {
+            my_task.increment_ref_count();
+        }
+        ~ref_count_guard() {
+            my_task.decrement_ref_count();
+        }
+    };
 protected:
     empty_task* my_root;
     task_group_context my_context;
 
-    task& owner () { return *my_root; }
-
     template<typename F>
     task_group_status internal_run_and_wait( F& f ) {
         __TBB_TRY {
-            if ( !my_context.is_group_execution_cancelled() )
+            if ( !my_context.is_group_execution_cancelled() ) {
+                // We need to increase the reference count of the root task to notify waiters that
+                // this task group has some work in progress.
+                ref_count_guard guard(*my_root);
                 f();
+            }
         } __TBB_CATCH( ... ) {
             my_context.register_pending_exception();
         }
@@ -100,8 +120,8 @@ class task_group_base : internal::no_copy {
     }
 
     template<typename Task, typename F>
-    void internal_run( __TBB_FORWARDING_REF(F) f ) {
-        owner().spawn( *new( owner().allocate_additional_child_of(*my_root) ) Task( internal::forward<F>(f) ));
+    task* prepare_task( __TBB_FORWARDING_REF(F) f ) {
+        return new( task::allocate_additional_child_of(*my_root) ) Task( internal::forward<F>(f) );
     }
 
 public:
@@ -114,7 +134,11 @@ class task_group_base : internal::no_copy {
 
     ~task_group_base() __TBB_NOEXCEPT(false) {
         if( my_root->ref_count() > 1 ) {
+#if __TBB_CPP17_UNCAUGHT_EXCEPTIONS_PRESENT
+            bool stack_unwinding_in_progress = std::uncaught_exceptions() > 0;
+#else
             bool stack_unwinding_in_progress = std::uncaught_exception();
+#endif
             // Always attempt to do proper cleanup to avoid inevitable memory corruption
             // in case of missing wait (for the sake of better testability & debuggability)
             if ( !is_canceling() )
@@ -136,7 +160,7 @@ class task_group_base : internal::no_copy {
 
     template<typename F>
     void run( task_handle<F>& h ) {
-        internal_run< internal::task_handle_task<F> >( h );
+        task::spawn( *prepare_task< internal::task_handle_task<F> >(h) );
     }
 
     task_group_status wait() {
@@ -181,12 +205,12 @@ class task_group : public internal::task_group_base {
 #if __TBB_CPP11_RVALUE_REF_PRESENT
     template<typename F>
     void run( F&& f ) {
-        internal_run< internal::function_task< typename internal::strip<F>::type > >( std::forward< F >(f) );
+        task::spawn( *prepare_task< internal::function_task< typename internal::strip<F>::type > >(std::forward<F>(f)) );
     }
 #else
     template<typename F>
     void run(const F& f) {
-        internal_run<internal::function_task<F> >(f);
+        task::spawn( *prepare_task< internal::function_task<F> >(f) );
     }
 #endif
 
@@ -198,12 +222,12 @@ class task_group : public internal::task_group_base {
     // TODO: add task_handle rvalues support
     template<typename F>
     task_group_status run_and_wait( task_handle<F>& h ) {
-      h.mark_scheduled();
-      return internal_run_and_wait< task_handle<F> >( h );
+        h.mark_scheduled();
+        return internal_run_and_wait< task_handle<F> >( h );
     }
 }; // class task_group
 
-class structured_task_group : public internal::task_group_base {
+class __TBB_DEPRECATED structured_task_group : public internal::task_group_base {
 public:
     // TODO: add task_handle rvalues support
     template<typename F>
@@ -219,6 +243,102 @@ class structured_task_group : public internal::task_group_base {
     }
 }; // class structured_task_group
 
+#if TBB_PREVIEW_ISOLATED_TASK_GROUP && __TBB_TASK_ISOLATION
+namespace internal {
+    using interface7::internal::delegate_base;
+    using interface7::internal::isolate_within_arena;
+
+    class spawn_delegate : public delegate_base {
+        task* task_to_spawn;
+        void operator()() const __TBB_override {
+            task::spawn(*task_to_spawn);
+        }
+    public:
+        spawn_delegate(task* a_task) : task_to_spawn(a_task) {}
+    };
+
+    class wait_delegate : public delegate_base {
+        void operator()() const __TBB_override {
+            status = tg.wait();
+        }
+    protected:
+        task_group& tg;
+        task_group_status& status;
+    public:
+        wait_delegate(task_group& a_group, task_group_status& tgs)
+            : tg(a_group), status(tgs) {}
+    };
+
+    template<typename F>
+    class run_wait_delegate : public wait_delegate {
+        F& func;
+        void operator()() const __TBB_override {
+            status = tg.run_and_wait( func );
+        }
+    public:
+        run_wait_delegate(task_group& a_group, F& a_func, task_group_status& tgs)
+            : wait_delegate(a_group, tgs), func(a_func) {}
+    };
+} // namespace internal
+
+class isolated_task_group : public task_group {
+    intptr_t this_isolation() {
+        return reinterpret_cast<intptr_t>(this);
+    }
+public:
+    isolated_task_group () : task_group() {}
+
+#if __TBB_CPP11_RVALUE_REF_PRESENT
+    template<typename F>
+    void run( F&& f ) {
+        internal::spawn_delegate sd(
+            prepare_task< internal::function_task< typename internal::strip<F>::type > >(std::forward<F>(f))
+        );
+        internal::isolate_within_arena( sd, this_isolation() );
+    }
+#else
+    template<typename F>
+    void run(const F& f) {
+        internal::spawn_delegate sd( prepare_task< internal::function_task<F> >(f) );
+        internal::isolate_within_arena( sd, this_isolation() );
+    }
+#endif
+
+    template<typename F>
+    task_group_status run_and_wait( const F& f ) {
+        task_group_status result = not_complete;
+        internal::run_wait_delegate< const F > rwd( *this, f, result );
+        internal::isolate_within_arena( rwd, this_isolation() );
+        __TBB_ASSERT( result!=not_complete, "premature exit from wait?" );
+        return result;
+    }
+
+    // TODO: add task_handle rvalues support
+    template<typename F>
+    void run( task_handle<F>& h ) {
+        internal::spawn_delegate sd( prepare_task< internal::task_handle_task<F> >(h) );
+        internal::isolate_within_arena( sd, this_isolation() );
+    }
+
+    template<typename F>
+    task_group_status run_and_wait ( task_handle<F>& h ) {
+        task_group_status result = not_complete;
+        internal::run_wait_delegate< task_handle<F> > rwd( *this, h, result );
+        internal::isolate_within_arena( rwd, this_isolation() );
+        __TBB_ASSERT( result!=not_complete, "premature exit from wait?" );
+        return result;
+    }
+
+    task_group_status wait() {
+        task_group_status result = not_complete;
+        internal::wait_delegate wd( *this, result );
+        internal::isolate_within_arena( wd, this_isolation() );
+        __TBB_ASSERT( result!=not_complete, "premature exit from wait?" );
+        return result;
+    }
+}; // class isolated_task_group
+#endif // TBB_PREVIEW_ISOLATED_TASK_GROUP && __TBB_TASK_ISOLATION
+
 inline
 bool is_current_task_group_canceling() {
     return task::self().is_cancelled();
@@ -240,4 +360,7 @@ task_handle<F> make_task( const F& f ) {
 
 #endif /* __TBB_TASK_GROUP_CONTEXT */
 
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_task_group_H_include_area
+
 #endif /* __TBB_task_group_H */
diff --git a/src/tbb/include/tbb/task_scheduler_init.h b/src/tbb/include/tbb/task_scheduler_init.h
index 928e7a4e..687bba1d 100644
--- a/src/tbb/include/tbb/task_scheduler_init.h
+++ b/src/tbb/include/tbb/task_scheduler_init.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,15 +12,25 @@
     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 "internal/_deprecated_header_message_guard.h"
 
+#if !defined(__TBB_show_deprecation_message_task_scheduler_init_H) && defined(__TBB_show_deprecated_header_message)
+#define  __TBB_show_deprecation_message_task_scheduler_init_H
+#pragma message("TBB Warning: tbb/task_scheduler_init.h is deprecated. For details, please see Deprecated Features appendix in the TBB reference manual.")
+#endif
 
-
-*/
+#if defined(__TBB_show_deprecated_header_message)
+#undef __TBB_show_deprecated_header_message
+#endif
 
 #ifndef __TBB_task_scheduler_init_H
 #define __TBB_task_scheduler_init_H
 
+#define __TBB_task_scheduler_init_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #include "tbb_stddef.h"
 #include "limits.h"
 #if __TBB_SUPPORTS_WORKERS_WAITING_IN_TERMINATE
@@ -53,7 +63,7 @@ namespace internal {
     and will persist until this thread exits. Default concurrency level is defined
     as described in task_scheduler_init::initialize().
     @ingroup task_scheduling */
-class task_scheduler_init: internal::no_copy {
+class __TBB_DEPRECATED_IN_VERBOSE_MODE task_scheduler_init: internal::no_copy {
     enum ExceptionPropagationMode {
         propagation_mode_exact = 1u,
         propagation_mode_captured = 2u,
@@ -136,8 +146,8 @@ class task_scheduler_init: internal::no_copy {
     /** Result returned by this method does not depend on whether the scheduler
         has already been initialized.
 
-        Because tbb 2.0 does not support blocking tasks yet, you may use this method
-        to boost the number of threads in the tbb's internal pool, if your tasks are
+        Because TBB 2.0 does not support blocking tasks yet, you may use this method
+        to boost the number of threads in the TBB's internal pool, if your tasks are
         doing I/O operations. The optimal number of additional threads depends on how
         much time your tasks spend in the blocked state.
 
@@ -158,4 +168,7 @@ class task_scheduler_init: internal::no_copy {
 
 } // namespace tbb
 
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_task_scheduler_init_H_include_area
+
 #endif /* __TBB_task_scheduler_init_H */
diff --git a/src/tbb/include/tbb/task_scheduler_observer.h b/src/tbb/include/tbb/task_scheduler_observer.h
index 5586ad4f..1bb93636 100644
--- a/src/tbb/include/tbb/task_scheduler_observer.h
+++ b/src/tbb/include/tbb/task_scheduler_observer.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,17 +12,16 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_task_scheduler_observer_H
 #define __TBB_task_scheduler_observer_H
 
+#define __TBB_task_scheduler_observer_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #include "atomic.h"
-#if __TBB_ARENA_OBSERVER || __TBB_SLEEP_PERMISSION
+#if __TBB_ARENA_OBSERVER
 #include "task_arena.h"
 #endif
 
@@ -88,7 +87,7 @@ class task_scheduler_observer_v3 {
 
 } // namespace internal
 
-#if __TBB_ARENA_OBSERVER || __TBB_SLEEP_PERMISSION
+#if __TBB_ARENA_OBSERVER
 namespace interface6 {
 class task_scheduler_observer : public internal::task_scheduler_observer_v3 {
     friend class internal::task_scheduler_observer_v3;
@@ -149,26 +148,19 @@ class task_scheduler_observer : public internal::task_scheduler_observer_v3 {
         }
         internal::task_scheduler_observer_v3::observe(state);
     }
-
-#if  __TBB_SLEEP_PERMISSION
-    //! Return commands for may_sleep()
-    enum { keep_awake = false, allow_sleep = true };
-
-    //! The callback can be invoked by a worker thread before it goes to sleep.
-    /** If it returns false ('keep_awake'), the thread will keep spinning and looking for work.
-        It will not be called for master threads. **/
-    virtual bool may_sleep() { return allow_sleep; }
-#endif /*__TBB_SLEEP_PERMISSION*/
 };
 
 } //namespace interface6
 using interface6::task_scheduler_observer;
-#else /*__TBB_ARENA_OBSERVER || __TBB_SLEEP_PERMISSION*/
+#else /*__TBB_ARENA_OBSERVER*/
 typedef tbb::internal::task_scheduler_observer_v3 task_scheduler_observer;
-#endif /*__TBB_ARENA_OBSERVER || __TBB_SLEEP_PERMISSION*/
+#endif /*__TBB_ARENA_OBSERVER*/
 
 } // namespace tbb
 
 #endif /* __TBB_SCHEDULER_OBSERVER */
 
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_task_scheduler_observer_H_include_area
+
 #endif /* __TBB_task_scheduler_observer_H */
diff --git a/src/tbb/include/tbb/tbb.h b/src/tbb/include/tbb/tbb.h
index 5e385ea2..f06ec5a3 100644
--- a/src/tbb/include/tbb/tbb.h
+++ b/src/tbb/include/tbb/tbb.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,18 +12,21 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_tbb_H
 #define __TBB_tbb_H
 
+#if (!defined(TBB_SUPPRESS_DEPRECATED_MESSAGES) || (TBB_SUPPRESS_DEPRECATED_MESSAGES == 0)) && !defined(__TBB_INTERNAL_INCLUDES_DEPRECATION_MESSAGE)
+#pragma message("TBB Warning: tbb.h contains deprecated functionality. For details, please see Deprecated Features appendix in the TBB reference manual.")
+#endif
+
+#define __TBB_tbb_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 /**
     This header bulk-includes declarations or definitions of all the functionality
-    provided by TBB (save for malloc dependent headers).
+    provided by TBB (save for tbbmalloc and 3rd party dependent headers).
 
     If you use only a few TBB constructs, consider including specific headers only.
     Any header listed below can be included independently of others.
@@ -37,6 +40,9 @@
 #include "blocked_range.h"
 #include "blocked_range2d.h"
 #include "blocked_range3d.h"
+#if TBB_PREVIEW_BLOCKED_RANGE_ND
+#include "blocked_rangeNd.h"
+#endif
 #include "cache_aligned_allocator.h"
 #include "combinable.h"
 #include "concurrent_hash_map.h"
@@ -47,13 +53,16 @@
 #include "concurrent_queue.h"
 #include "concurrent_unordered_map.h"
 #include "concurrent_unordered_set.h"
+#if TBB_PREVIEW_CONCURRENT_ORDERED_CONTAINERS
+#include "concurrent_map.h"
+#include "concurrent_set.h"
+#endif
 #include "concurrent_vector.h"
 #include "critical_section.h"
 #include "enumerable_thread_specific.h"
 #include "flow_graph.h"
-#if TBB_PREVIEW_GLOBAL_CONTROL
 #include "global_control.h"
-#endif
+#include "iterators.h"
 #include "mutex.h"
 #include "null_mutex.h"
 #include "null_rw_mutex.h"
@@ -82,4 +91,7 @@
 #include "tbb_thread.h"
 #include "tick_count.h"
 
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_tbb_H_include_area
+
 #endif /* __TBB_tbb_H */
diff --git a/src/tbb/include/tbb/tbb_allocator.h b/src/tbb/include/tbb/tbb_allocator.h
index 047344e7..ac0d1a6b 100644
--- a/src/tbb/include/tbb/tbb_allocator.h
+++ b/src/tbb/include/tbb/tbb_allocator.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_tbb_allocator_H
@@ -174,7 +170,7 @@ class zero_allocator : public Allocator<T>
 
     pointer allocate(const size_type n, const void *hint = 0 ) {
         pointer ptr = base_allocator_type::allocate( n, hint );
-        std::memset( (void*) ptr, 0, n * sizeof(value_type) );
+        std::memset( static_cast<void*>(ptr), 0, n * sizeof(value_type) );
         return ptr;
     }
 };
diff --git a/src/tbb/include/tbb/tbb_config.h b/src/tbb/include/tbb/tbb_config.h
index 3ac2b3e0..7a8d06a0 100644
--- a/src/tbb/include/tbb/tbb_config.h
+++ b/src/tbb/include/tbb/tbb_config.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_tbb_config_H
@@ -40,23 +36,26 @@
     #include <cstddef>
 #endif
 
-// note that when ICC or Clang is in use, __TBB_GCC_VERSION might not fully match
+// Note that when ICC or Clang is in use, __TBB_GCC_VERSION might not fully match
 // the actual GCC version on the system.
 #define __TBB_GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
 
-// Since GNU libstdc++ does not have a convenient macro for its version,
-// we rely on the version of GCC or the user-specified macro below.
-// The format of TBB_USE_GLIBCXX_VERSION should match the __TBB_GCC_VERSION above,
-// e.g. it should be set to 40902 for libstdc++ coming with GCC 4.9.2.
-#ifdef TBB_USE_GLIBCXX_VERSION
+// Prior to GCC 7, GNU libstdc++ did not have a convenient version macro.
+// Therefore we use different ways to detect its version.
+#if defined(TBB_USE_GLIBCXX_VERSION) && !defined(_GLIBCXX_RELEASE)
+// The version is explicitly specified in our public TBB_USE_GLIBCXX_VERSION macro.
+// Its format should match the __TBB_GCC_VERSION above, e.g. 70301 for libstdc++ coming with GCC 7.3.1.
 #define __TBB_GLIBCXX_VERSION TBB_USE_GLIBCXX_VERSION
+#elif _GLIBCXX_RELEASE && _GLIBCXX_RELEASE != __GNUC__
+// Reported versions of GCC and libstdc++ do not match; trust the latter
+#define __TBB_GLIBCXX_VERSION (_GLIBCXX_RELEASE*10000)
 #elif __GLIBCPP__ || __GLIBCXX__
+// The version macro is not defined or matches the GCC version; use __TBB_GCC_VERSION
 #define __TBB_GLIBCXX_VERSION __TBB_GCC_VERSION
-//TODO: analyze __GLIBCXX__ instead of __TBB_GCC_VERSION ?
 #endif
 
 #if __clang__
-    /** according to clang documentation, version can be vendor specific **/
+    // according to clang documentation, version can be vendor specific
     #define __TBB_CLANG_VERSION (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__)
 #endif
 
@@ -65,6 +64,16 @@
     #define __TBB_IOS 1
 #endif
 
+#if __APPLE__
+    #if __INTEL_COMPILER && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ > 1099 \
+                         && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 101000
+        // ICC does not correctly set the macro if -mmacosx-min-version is not specified
+        #define __TBB_MACOS_TARGET_VERSION  (100000 + 10*(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ - 1000))
+    #else
+        #define __TBB_MACOS_TARGET_VERSION  __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__
+    #endif
+#endif
+
 /** Preprocessor symbols to determine HW architecture **/
 
 #if _WIN32||_WIN64
@@ -132,6 +141,16 @@
    support added.
  */
 
+/**
+    __TBB_CPP11_PRESENT macro indicates that the compiler supports vast majority of C++11 features.
+    Depending on the compiler, some features might still be unsupported or work incorrectly.
+    Use it when enabling C++11 features individually is not practical, and be aware that
+    some "good enough" compilers might be excluded. **/
+#define __TBB_CPP11_PRESENT (__cplusplus >= 201103L || _MSC_VER >= 1900)
+
+#define __TBB_CPP17_FALLTHROUGH_PRESENT (__cplusplus >= 201703L)
+#define __TBB_FALLTHROUGH_PRESENT       (__TBB_GCC_VERSION >= 70000 && !__INTEL_COMPILER)
+
 /** C++11 mode detection macros for Intel(R) C++ Compiler (enabled by -std=c++XY option):
     __INTEL_CXX11_MODE__ for version >=13.0 (not available for ICC 15.0 if -std=c++14 is used),
     __STDC_HOSTED__ for version >=12.0 (useful only on Windows),
@@ -141,16 +160,9 @@
     #define __INTEL_CXX11_MODE__ (__GXX_EXPERIMENTAL_CXX0X__ || (_MSC_VER && __STDC_HOSTED__))
 #endif
 
-// Intel(R) C++ Compiler offloading API to the Intel(R) Graphics Technology presence macro
-// TODO: add support for ICC 15.00 _GFX_enqueue API and then decrease Intel C++ Compiler supported version
-// TODO: add linux support and restict it with (__linux__ && __TBB_x86_64 && !__ANDROID__) macro
-#if __INTEL_COMPILER >= 1600 && _WIN32
-#define __TBB_GFX_PRESENT 1
-#endif
-
 #if __INTEL_COMPILER && (!_MSC_VER || __INTEL_CXX11_MODE__)
     //  On Windows, C++11 features supported by Visual Studio 2010 and higher are enabled by default,
-    //  so in absence of /Qstd= use MSVC branch for __TBB_CPP11_* detection.
+    //  so in absence of /Qstd= use MSVC branch for feature detection.
     //  On other platforms, no -std= means C++03.
 
     #define __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT          (__INTEL_CXX11_MODE__ && __VARIADIC_TEMPLATES)
@@ -177,14 +189,7 @@
     #endif
     #define __TBB_STATIC_ASSERT_PRESENT                     (__INTEL_CXX11_MODE__ || _MSC_VER >= 1600)
     #define __TBB_CPP11_TUPLE_PRESENT                       (_MSC_VER >= 1600 || __GXX_EXPERIMENTAL_CXX0X__ && (__TBB_GLIBCXX_VERSION >= 40300 || _LIBCPP_VERSION))
-    #if (__clang__ && __INTEL_COMPILER > 1400)
-        /* Older versions of Intel C++ Compiler do not have __has_include */
-        #if (__has_feature(__cxx_generalized_initializers__) && __has_include(<initializer_list>))
-            #define __TBB_INITIALIZER_LISTS_PRESENT         1
-        #endif
-    #else
-        #define __TBB_INITIALIZER_LISTS_PRESENT             (__INTEL_CXX11_MODE__ && __INTEL_COMPILER >= 1400 && (_MSC_VER >= 1800 || __TBB_GLIBCXX_VERSION >= 40400 || _LIBCPP_VERSION))
-    #endif
+    #define __TBB_INITIALIZER_LISTS_PRESENT                 (__INTEL_CXX11_MODE__ && __INTEL_COMPILER >= 1400 && (_MSC_VER >= 1800 || __TBB_GLIBCXX_VERSION >= 40400 || _LIBCPP_VERSION))
     #define __TBB_CONSTEXPR_PRESENT                         (__INTEL_CXX11_MODE__ && __INTEL_COMPILER >= 1400)
     #define __TBB_DEFAULTED_AND_DELETED_FUNC_PRESENT        (__INTEL_CXX11_MODE__ && __INTEL_COMPILER >= 1200)
     /** ICC seems to disable support of noexcept event in c++11 when compiling in compatibility mode for gcc <4.6 **/
@@ -197,19 +202,19 @@
     #define __TBB_OVERRIDE_PRESENT                          (__INTEL_CXX11_MODE__ && __INTEL_COMPILER >= 1400)
     #define __TBB_ALIGNAS_PRESENT                           (__INTEL_CXX11_MODE__ && __INTEL_COMPILER >= 1500)
     #define __TBB_CPP11_TEMPLATE_ALIASES_PRESENT            (__INTEL_CXX11_MODE__ && __INTEL_COMPILER >= 1210)
+    #define __TBB_CPP14_INTEGER_SEQUENCE_PRESENT            (__cplusplus >= 201402L)
+    #define __TBB_CPP14_VARIABLE_TEMPLATES_PRESENT          (__cplusplus >= 201402L)
+    #define __TBB_CPP17_DEDUCTION_GUIDES_PRESENT            (__INTEL_COMPILER > 1910) // a future version
+    #define __TBB_CPP17_INVOKE_RESULT_PRESENT               (__cplusplus >= 201703L)
 #elif __clang__
 /** TODO: these options need to be rechecked **/
-/** on macOS the only way to get C++11 is to use clang. For library features (e.g. exception_ptr) libc++ is also
- *  required. So there is no need to check GCC version for clang**/
     #define __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT          __has_feature(__cxx_variadic_templates__)
     #define __TBB_CPP11_RVALUE_REF_PRESENT                  (__has_feature(__cxx_rvalue_references__) && (_LIBCPP_VERSION || __TBB_GLIBCXX_VERSION >= 40500))
     #define __TBB_IMPLICIT_MOVE_PRESENT                     __has_feature(cxx_implicit_moves)
 /** TODO: extend exception_ptr related conditions to cover libstdc++ **/
     #define __TBB_EXCEPTION_PTR_PRESENT                     (__cplusplus >= 201103L && (_LIBCPP_VERSION || __TBB_GLIBCXX_VERSION >= 40600))
     #define __TBB_STATIC_ASSERT_PRESENT                     __has_feature(__cxx_static_assert__)
-    /**Clang (preprocessor) has problems with dealing with expression having __has_include in #ifs
-     * used inside C++ code. (At least version that comes with OS X 10.8 : Apple LLVM version 4.2 (clang-425.0.28) (based on LLVM 3.2svn)) **/
-    #if (__GXX_EXPERIMENTAL_CXX0X__ && __has_include(<tuple>))
+    #if (__cplusplus >= 201103L && __has_include(<tuple>))
         #define __TBB_CPP11_TUPLE_PRESENT                   1
     #endif
     #if (__has_feature(__cxx_generalized_initializers__) && __has_include(<initializer_list>))
@@ -227,6 +232,10 @@
     #define __TBB_OVERRIDE_PRESENT                          __has_feature(cxx_override_control)
     #define __TBB_ALIGNAS_PRESENT                           __has_feature(cxx_alignas)
     #define __TBB_CPP11_TEMPLATE_ALIASES_PRESENT            __has_feature(cxx_alias_templates)
+    #define __TBB_CPP14_INTEGER_SEQUENCE_PRESENT            (__cplusplus >= 201402L)
+    #define __TBB_CPP14_VARIABLE_TEMPLATES_PRESENT          (__has_feature(cxx_variable_templates))
+    #define __TBB_CPP17_DEDUCTION_GUIDES_PRESENT            (__has_feature(__cpp_deduction_guides))
+    #define __TBB_CPP17_INVOKE_RESULT_PRESENT               (__has_feature(__cpp_lib_is_invocable))
 #elif __GNUC__
     #define __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT          __GXX_EXPERIMENTAL_CXX0X__
     #define __TBB_CPP11_VARIADIC_FIXED_LENGTH_EXP_PRESENT   (__GXX_EXPERIMENTAL_CXX0X__ && __TBB_GCC_VERSION >= 40700)
@@ -251,8 +260,13 @@
     #define __TBB_OVERRIDE_PRESENT                          (__GXX_EXPERIMENTAL_CXX0X__ && __TBB_GCC_VERSION >= 40700)
     #define __TBB_ALIGNAS_PRESENT                           (__GXX_EXPERIMENTAL_CXX0X__ && __TBB_GCC_VERSION >= 40800)
     #define __TBB_CPP11_TEMPLATE_ALIASES_PRESENT            (__GXX_EXPERIMENTAL_CXX0X__ && __TBB_GCC_VERSION >= 40700)
+    #define __TBB_CPP14_INTEGER_SEQUENCE_PRESENT            (__cplusplus >= 201402L     && __TBB_GCC_VERSION >= 50000)
+    #define __TBB_CPP14_VARIABLE_TEMPLATES_PRESENT          (__cplusplus >= 201402L     && __TBB_GCC_VERSION >= 50000)
+    #define __TBB_CPP17_DEDUCTION_GUIDES_PRESENT            (__cpp_deduction_guides >= 201606L)
+    #define __TBB_CPP17_INVOKE_RESULT_PRESENT               (__cplusplus >= 201703L     && __TBB_GCC_VERSION >= 70000)
 #elif _MSC_VER
-    // These definitions are also used with Intel C++ Compiler in "default" mode; see a comment above.
+    // These definitions are also used with Intel C++ Compiler in "default" mode (__INTEL_CXX11_MODE__ == 0);
+    // see a comment in "__INTEL_COMPILER" section above.
 
     #define __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT          (_MSC_VER >= 1800)
     // Contains a workaround for ICC 13
@@ -273,50 +287,71 @@
     #define __TBB_OVERRIDE_PRESENT                          (_MSC_VER >= 1700)
     #define __TBB_ALIGNAS_PRESENT                           (_MSC_VER >= 1900)
     #define __TBB_CPP11_TEMPLATE_ALIASES_PRESENT            (_MSC_VER >= 1800)
+    #define __TBB_CPP14_INTEGER_SEQUENCE_PRESENT            (_MSC_VER >= 1900)
+    /* Variable templates are supported in VS2015 Update 2 or later */
+    #define __TBB_CPP14_VARIABLE_TEMPLATES_PRESENT          (_MSC_FULL_VER >= 190023918 && (!__INTEL_COMPILER || __INTEL_COMPILER >= 1700))
+    #define __TBB_CPP17_DEDUCTION_GUIDES_PRESENT            (_MSVC_LANG >= 201703L && _MSC_VER >= 1914)
+    #define __TBB_CPP17_INVOKE_RESULT_PRESENT               (_MSVC_LANG >= 201703L && _MSC_VER >= 1911)
 #else
-    #define __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT          0
-    #define __TBB_CPP11_RVALUE_REF_PRESENT                  0
-    #define __TBB_IMPLICIT_MOVE_PRESENT                     0
-    #define __TBB_EXCEPTION_PTR_PRESENT                     0
-    #define __TBB_STATIC_ASSERT_PRESENT                     0
-    #define __TBB_CPP11_TUPLE_PRESENT                       0
-    #define __TBB_INITIALIZER_LISTS_PRESENT                 0
-    #define __TBB_CONSTEXPR_PRESENT                         0
-    #define __TBB_DEFAULTED_AND_DELETED_FUNC_PRESENT        0
-    #define __TBB_NOEXCEPT_PRESENT                          0
-    #define __TBB_CPP11_STD_BEGIN_END_PRESENT               0
-    #define __TBB_CPP11_AUTO_PRESENT                        0
-    #define __TBB_CPP11_DECLTYPE_PRESENT                    0
-    #define __TBB_CPP11_LAMBDAS_PRESENT                     0
-    #define __TBB_CPP11_DEFAULT_FUNC_TEMPLATE_ARGS_PRESENT  0
-    #define __TBB_OVERRIDE_PRESENT                          0
-    #define __TBB_ALIGNAS_PRESENT                           0
-    #define __TBB_CPP11_TEMPLATE_ALIASES_PRESENT            0
+    #define __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT          __TBB_CPP11_PRESENT
+    #define __TBB_CPP11_RVALUE_REF_PRESENT                  __TBB_CPP11_PRESENT
+    #define __TBB_IMPLICIT_MOVE_PRESENT                     __TBB_CPP11_PRESENT
+    #define __TBB_EXCEPTION_PTR_PRESENT                     __TBB_CPP11_PRESENT
+    #define __TBB_STATIC_ASSERT_PRESENT                     __TBB_CPP11_PRESENT
+    #define __TBB_CPP11_TUPLE_PRESENT                       __TBB_CPP11_PRESENT
+    #define __TBB_INITIALIZER_LISTS_PRESENT                 __TBB_CPP11_PRESENT
+    #define __TBB_CONSTEXPR_PRESENT                         __TBB_CPP11_PRESENT
+    #define __TBB_DEFAULTED_AND_DELETED_FUNC_PRESENT        __TBB_CPP11_PRESENT
+    #define __TBB_NOEXCEPT_PRESENT                          __TBB_CPP11_PRESENT
+    #define __TBB_CPP11_STD_BEGIN_END_PRESENT               __TBB_CPP11_PRESENT
+    #define __TBB_CPP11_AUTO_PRESENT                        __TBB_CPP11_PRESENT
+    #define __TBB_CPP11_DECLTYPE_PRESENT                    __TBB_CPP11_PRESENT
+    #define __TBB_CPP11_LAMBDAS_PRESENT                     __TBB_CPP11_PRESENT
+    #define __TBB_CPP11_DEFAULT_FUNC_TEMPLATE_ARGS_PRESENT  __TBB_CPP11_PRESENT
+    #define __TBB_OVERRIDE_PRESENT                          __TBB_CPP11_PRESENT
+    #define __TBB_ALIGNAS_PRESENT                           __TBB_CPP11_PRESENT
+    #define __TBB_CPP11_TEMPLATE_ALIASES_PRESENT            __TBB_CPP11_PRESENT
+    #define __TBB_CPP14_INTEGER_SEQUENCE_PRESENT            (__cplusplus >= 201402L)
+    #define __TBB_CPP14_VARIABLE_TEMPLATES_PRESENT          (__cplusplus >= 201402L)
+    #define __TBB_CPP17_DEDUCTION_GUIDES_PRESENT            (__cplusplus >= 201703L)
+    #define __TBB_CPP17_INVOKE_RESULT_PRESENT               (__cplusplus >= 201703L)
 #endif
 
 // C++11 standard library features
 
+#define __TBB_CPP11_ARRAY_PRESENT                           (_MSC_VER >= 1700 || _LIBCPP_VERSION || __GXX_EXPERIMENTAL_CXX0X__ && __TBB_GLIBCXX_VERSION >= 40300)
+
 #ifndef __TBB_CPP11_VARIADIC_FIXED_LENGTH_EXP_PRESENT
 #define __TBB_CPP11_VARIADIC_FIXED_LENGTH_EXP_PRESENT       __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT
 #endif
-#define __TBB_CPP11_VARIADIC_TUPLE_PRESENT          (!_MSC_VER || _MSC_VER >=1800)
+#define __TBB_CPP11_VARIADIC_TUPLE_PRESENT                  (!_MSC_VER || _MSC_VER >= 1800)
 
-#define __TBB_CPP11_TYPE_PROPERTIES_PRESENT         (_LIBCPP_VERSION || _MSC_VER >= 1700 || (__TBB_GLIBCXX_VERSION >= 50000 && __GXX_EXPERIMENTAL_CXX0X__))
-#define __TBB_TR1_TYPE_PROPERTIES_IN_STD_PRESENT    (__GXX_EXPERIMENTAL_CXX0X__ && __TBB_GLIBCXX_VERSION >= 40300 || _MSC_VER >= 1600)
+#define __TBB_CPP11_TYPE_PROPERTIES_PRESENT                 (_LIBCPP_VERSION || _MSC_VER >= 1700 || (__TBB_GLIBCXX_VERSION >= 50000 && __GXX_EXPERIMENTAL_CXX0X__))
 // GCC supported some of type properties since 4.7
-#define __TBB_CPP11_IS_COPY_CONSTRUCTIBLE_PRESENT   (__GXX_EXPERIMENTAL_CXX0X__ && __TBB_GLIBCXX_VERSION >= 40700 || __TBB_CPP11_TYPE_PROPERTIES_PRESENT)
+#define __TBB_CPP11_IS_COPY_CONSTRUCTIBLE_PRESENT           (__GXX_EXPERIMENTAL_CXX0X__ && __TBB_GLIBCXX_VERSION >= 40700 || __TBB_CPP11_TYPE_PROPERTIES_PRESENT)
 
 // In GCC, std::move_if_noexcept appeared later than noexcept
-#define __TBB_MOVE_IF_NOEXCEPT_PRESENT     (__TBB_NOEXCEPT_PRESENT && (__TBB_GLIBCXX_VERSION >= 40700 || _MSC_VER >= 1900 || _LIBCPP_VERSION))
-#define __TBB_ALLOCATOR_TRAITS_PRESENT     (__cplusplus >= 201103L && _LIBCPP_VERSION  || _MSC_VER >= 1700 ||  \
-                                            __GXX_EXPERIMENTAL_CXX0X__ && __TBB_GLIBCXX_VERSION >= 40700 && !(__TBB_GLIBCXX_VERSION == 40700 && __TBB_DEFINE_MIC))
-#define __TBB_MAKE_EXCEPTION_PTR_PRESENT   (__TBB_EXCEPTION_PTR_PRESENT && (_MSC_VER >= 1700 || __TBB_GLIBCXX_VERSION >= 40600 || _LIBCPP_VERSION))
+#define __TBB_MOVE_IF_NOEXCEPT_PRESENT                      (__TBB_NOEXCEPT_PRESENT && (__TBB_GLIBCXX_VERSION >= 40700 || _MSC_VER >= 1900 || _LIBCPP_VERSION))
+#define __TBB_ALLOCATOR_TRAITS_PRESENT                      (__cplusplus >= 201103L && _LIBCPP_VERSION  || _MSC_VER >= 1800 ||  \
+                                                            __GXX_EXPERIMENTAL_CXX0X__ && __TBB_GLIBCXX_VERSION >= 40700 && !(__TBB_GLIBCXX_VERSION == 40700 && __TBB_DEFINE_MIC))
+#define __TBB_MAKE_EXCEPTION_PTR_PRESENT                    (__TBB_EXCEPTION_PTR_PRESENT && (_MSC_VER >= 1700 || __TBB_GLIBCXX_VERSION >= 40600 || _LIBCPP_VERSION || __SUNPRO_CC))
 
 // Due to libc++ limitations in C++03 mode, do not pass rvalues to std::make_shared()
-#define __TBB_CPP11_SMART_POINTERS_PRESENT ( _MSC_VER >= 1600 || _LIBCPP_VERSION || ((__cplusplus >= 201103L || __GXX_EXPERIMENTAL_CXX0X__) && (__TBB_GLIBCXX_VERSION>=40500 || __TBB_GLIBCXX_VERSION>=40400 && __TBB_USE_OPTIONAL_RTTI)) )
+#define __TBB_CPP11_SMART_POINTERS_PRESENT                  ( _MSC_VER >= 1600 || _LIBCPP_VERSION   \
+                                                            || ((__cplusplus >= 201103L || __GXX_EXPERIMENTAL_CXX0X__)  \
+                                                            && (__TBB_GLIBCXX_VERSION >= 40500 || __TBB_GLIBCXX_VERSION >= 40400 && __TBB_USE_OPTIONAL_RTTI)) )
 
-#define __TBB_CPP11_FUTURE_PRESENT (_MSC_VER >= 1700 || __TBB_GLIBCXX_VERSION >= 40600 && _GXX_EXPERIMENTAL_CXX0X__ || _LIBCPP_VERSION)
+#define __TBB_CPP11_FUTURE_PRESENT                          (_MSC_VER >= 1700 || __TBB_GLIBCXX_VERSION >= 40600 && __GXX_EXPERIMENTAL_CXX0X__ || _LIBCPP_VERSION)
 
+#define __TBB_CPP11_GET_NEW_HANDLER_PRESENT                 (_MSC_VER >= 1900 || __TBB_GLIBCXX_VERSION >= 40900 && __GXX_EXPERIMENTAL_CXX0X__ || _LIBCPP_VERSION)
+
+#define __TBB_CPP17_UNCAUGHT_EXCEPTIONS_PRESENT             (_MSC_VER >= 1900 || __GLIBCXX__ && __cpp_lib_uncaught_exceptions \
+                                                            || _LIBCPP_VERSION >= 3700 && (!__TBB_MACOS_TARGET_VERSION || __TBB_MACOS_TARGET_VERSION >= 101200))
+// TODO: wait when memory_resource will be fully supported in clang and define the right macro
+// Currently it is in experimental stage since 6 version.
+#define __TBB_CPP17_MEMORY_RESOURCE_PRESENT                 (_MSC_VER >= 1913 && (_MSVC_LANG > 201402L || __cplusplus > 201402L) || \
+                                                            __GLIBCXX__ && __cpp_lib_memory_resource >= 201603)
+#define __TBB_CPP17_HW_INTERFERENCE_SIZE_PRESENT            (_MSC_VER >= 1911)
 // std::swap is in <utility> only since C++11, though MSVC had it at least since VS2005
 #if _MSC_VER>=1400 || _LIBCPP_VERSION || __GXX_EXPERIMENTAL_CXX0X__
 #define __TBB_STD_SWAP_HEADER <utility>
@@ -351,11 +386,21 @@
     #define __TBB_GCC_BUILTIN_ATOMICS_PRESENT 1
 #endif
 
+#if __TBB_GCC_VERSION >= 70000 && !__INTEL_COMPILER && !__clang__
+    // After GCC7 there was possible reordering problem in generic atomic load/store operations.
+    // So always using builtins.
+    #define TBB_USE_GCC_BUILTINS 1
+#endif
+
 #if __INTEL_COMPILER >= 1200
     /** built-in C++11 style atomics available in ICC since 12.0 **/
     #define __TBB_ICC_BUILTIN_ATOMICS_PRESENT 1
 #endif
 
+#if _MSC_VER>=1600 && (!__INTEL_COMPILER || __INTEL_COMPILER>=1310)
+    #define __TBB_MSVC_PART_WORD_INTERLOCKED_INTRINSICS_PRESENT 1
+#endif
+
 #define __TBB_TSX_INTRINSICS_PRESENT ((__RTM__ || _MSC_VER>=1700 || __INTEL_COMPILER>=1300) && !__TBB_DEFINE_MIC && !__ANDROID__)
 
 /** Macro helpers **/
@@ -461,6 +506,15 @@ There are four cases that are supported:
 
 /** Internal TBB features & modes **/
 
+/** __TBB_CONCURRENT_ORDERED_CONTAINERS indicates that all conditions of use
+ * concurrent_map and concurrent_set are met. **/
+// TODO: Add cpp11 random generation macro
+#ifndef __TBB_CONCURRENT_ORDERED_CONTAINERS_PRESENT
+    #define __TBB_CONCURRENT_ORDERED_CONTAINERS_PRESENT ( __TBB_CPP11_RVALUE_REF_PRESENT && __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT \
+     && __TBB_IMPLICIT_MOVE_PRESENT  && __TBB_CPP11_AUTO_PRESENT && __TBB_CPP11_LAMBDAS_PRESENT && __TBB_CPP11_ARRAY_PRESENT \
+     && __TBB_INITIALIZER_LISTS_PRESENT )
+#endif
+
 /** __TBB_WEAK_SYMBOLS_PRESENT denotes that the system supports the weak symbol mechanism **/
 #ifndef __TBB_WEAK_SYMBOLS_PRESENT
 #define __TBB_WEAK_SYMBOLS_PRESENT ( !_WIN32 && !__APPLE__ && !__sun && (__TBB_GCC_VERSION >= 40000 || __INTEL_COMPILER ) )
@@ -502,29 +556,13 @@ There are four cases that are supported:
 #define __TBB_RECYCLE_TO_ENQUEUE __TBB_BUILD // keep non-official
 
 #ifndef __TBB_ARENA_OBSERVER
-    #define __TBB_ARENA_OBSERVER ((__TBB_BUILD||TBB_PREVIEW_LOCAL_OBSERVER)&& __TBB_SCHEDULER_OBSERVER)
+    #define __TBB_ARENA_OBSERVER __TBB_SCHEDULER_OBSERVER
 #endif /* __TBB_ARENA_OBSERVER */
 
-#ifndef __TBB_SLEEP_PERMISSION
-    #define __TBB_SLEEP_PERMISSION ((__TBB_CPF_BUILD||TBB_PREVIEW_LOCAL_OBSERVER)&& __TBB_SCHEDULER_OBSERVER)
-#endif /* __TBB_SLEEP_PERMISSION */
-
 #ifndef __TBB_TASK_ISOLATION
     #define __TBB_TASK_ISOLATION 1
 #endif /* __TBB_TASK_ISOLATION */
 
-#if TBB_PREVIEW_FLOW_GRAPH_TRACE || TBB_PREVIEW_ALGORITHM_TRACE
-// Users of flow-graph and algorithm trace need to explicitly link against the preview 
-// library. This prevents the linker from implicitly linking an application with a preview 
-// version of TBB and unexpectedly bringing in other community preview features, which 
-// might change the behavior of the application.
-#define __TBB_NO_IMPLICIT_LINKAGE 1
-#endif /* TBB_PREVIEW_FLOW_GRAPH_TRACE */
-
-#ifndef __TBB_ITT_STRUCTURE_API
-#define __TBB_ITT_STRUCTURE_API ( !__TBB_DEFINE_MIC && (__TBB_CPF_BUILD || TBB_PREVIEW_FLOW_GRAPH_TRACE || TBB_PREVIEW_ALGORITHM_TRACE) )
-#endif
-
 #if TBB_USE_EXCEPTIONS && !__TBB_TASK_GROUP_CONTEXT
     #error TBB_USE_EXCEPTIONS requires __TBB_TASK_GROUP_CONTEXT to be enabled
 #endif
@@ -537,6 +575,10 @@ There are four cases that are supported:
     #error __TBB_TASK_PRIORITY requires __TBB_TASK_GROUP_CONTEXT to be enabled
 #endif
 
+#if TBB_PREVIEW_NUMA_SUPPORT || __TBB_BUILD
+    #define __TBB_NUMA_SUPPORT 1
+#endif
+
 #if TBB_PREVIEW_WAITING_FOR_WORKERS || __TBB_BUILD
     #define __TBB_SUPPORTS_WORKERS_WAITING_IN_TERMINATE 1
 #endif
@@ -574,8 +616,45 @@ There are four cases that are supported:
     #endif
 #endif
 
+// Intel C++ Compiler starts analyzing usages of the deprecated content at the template
+// instantiation site, which is too late for suppression of the corresponding messages for internal
+// stuff.
+#if !defined(__INTEL_COMPILER) && (!defined(TBB_SUPPRESS_DEPRECATED_MESSAGES) || (TBB_SUPPRESS_DEPRECATED_MESSAGES == 0))
+    #if (__cplusplus >= 201402L)
+        #define __TBB_DEPRECATED [[deprecated]]
+        #define __TBB_DEPRECATED_MSG(msg) [[deprecated(msg)]]
+    #elif _MSC_VER
+        #define __TBB_DEPRECATED __declspec(deprecated)
+        #define __TBB_DEPRECATED_MSG(msg) __declspec(deprecated(msg))
+    #elif (__GNUC__ && __TBB_GCC_VERSION >= 40805) || __clang__
+        #define __TBB_DEPRECATED __attribute__((deprecated))
+        #define __TBB_DEPRECATED_MSG(msg) __attribute__((deprecated(msg)))
+    #endif
+#endif  // !defined(TBB_SUPPRESS_DEPRECATED_MESSAGES) || (TBB_SUPPRESS_DEPRECATED_MESSAGES == 0)
+
+#if !defined(__TBB_DEPRECATED)
+    #define __TBB_DEPRECATED
+    #define __TBB_DEPRECATED_MSG(msg)
+#elif !defined(__TBB_SUPPRESS_INTERNAL_DEPRECATED_MESSAGES)
+    // Suppress deprecated messages from self
+    #define __TBB_SUPPRESS_INTERNAL_DEPRECATED_MESSAGES 1
+#endif
+
+#if defined(TBB_SUPPRESS_DEPRECATED_MESSAGES) && (TBB_SUPPRESS_DEPRECATED_MESSAGES == 0)
+    #define __TBB_DEPRECATED_IN_VERBOSE_MODE __TBB_DEPRECATED
+    #define __TBB_DEPRECATED_IN_VERBOSE_MODE_MSG(msg) __TBB_DEPRECATED_MSG(msg)
+#else
+    #define __TBB_DEPRECATED_IN_VERBOSE_MODE
+    #define __TBB_DEPRECATED_IN_VERBOSE_MODE_MSG(msg)
+#endif // (TBB_SUPPRESS_DEPRECATED_MESSAGES == 0)
+
+#if (!defined(TBB_SUPPRESS_DEPRECATED_MESSAGES) || (TBB_SUPPRESS_DEPRECATED_MESSAGES == 0)) && !__TBB_CPP11_PRESENT
+    #pragma message("TBB Warning: Support for C++98/03 is deprecated. Please use the compiler that supports C++11 features at least.")
+#endif
+
 /** __TBB_WIN8UI_SUPPORT enables support of Windows* Store Apps and limit a possibility to load
     shared libraries at run time only from application container **/
+// TODO: Separate this single macro into two for Windows 8 Store* (win8ui mode) and UWP/UWD modes.
 #if defined(WINAPI_FAMILY) && WINAPI_FAMILY == WINAPI_FAMILY_APP
     #define __TBB_WIN8UI_SUPPORT 1
 #else
@@ -660,7 +739,7 @@ There are four cases that are supported:
     #define __TBB_ICC_ASM_VOLATILE_BROKEN 1
 #endif
 
-#if !__INTEL_COMPILER && (_MSC_VER || __GNUC__==3 && __GNUC_MINOR__<=2)
+#if !__INTEL_COMPILER && (_MSC_VER && _MSC_VER < 1700 || __GNUC__==3 && __GNUC_MINOR__<=2)
     /** Bug in GCC 3.2 and MSVC compilers that sometimes return 0 for __alignof(T)
         when T has not yet been instantiated. **/
     #define __TBB_ALIGNOF_NOT_INSTANTIATED_TYPES_BROKEN 1
@@ -739,6 +818,11 @@ There are four cases that are supported:
 // In some cases decltype of a function adds a reference to a return type.
 #define __TBB_CPP11_DECLTYPE_OF_FUNCTION_RETURN_TYPE_BROKEN (_MSC_VER == 1600 && !__INTEL_COMPILER)
 
+// Visual Studio 2013 does not delete the copy constructor when a user-defined move constructor is provided
+#if _MSC_VER && _MSC_VER <= 1800
+    #define __TBB_IMPLICIT_COPY_DELETION_BROKEN 1
+#endif
+
 /** End of __TBB_XXX_BROKEN macro section **/
 
 #if defined(_MSC_VER) && _MSC_VER>=1500 && !defined(__INTEL_COMPILER)
@@ -768,7 +852,22 @@ There are four cases that are supported:
 #define __TBB_PREVIEW_MESSAGE_BASED_KEY_MATCHING (TBB_PREVIEW_FLOW_GRAPH_FEATURES || __TBB_PREVIEW_OPENCL_NODE)
 #define __TBB_PREVIEW_ASYNC_MSG                 (TBB_PREVIEW_FLOW_GRAPH_FEATURES && __TBB_FLOW_GRAPH_CPP11_FEATURES)
 
-#define __TBB_PREVIEW_GFX_FACTORY               (__TBB_GFX_PRESENT && TBB_PREVIEW_FLOW_GRAPH_FEATURES && !__TBB_MIC_OFFLOAD \
-                                                && __TBB_FLOW_GRAPH_CPP11_FEATURES && __TBB_CPP11_TEMPLATE_ALIASES_PRESENT \
-                                                && __TBB_CPP11_FUTURE_PRESENT)
+
+#ifndef __TBB_PREVIEW_FLOW_GRAPH_PRIORITIES
+#define __TBB_PREVIEW_FLOW_GRAPH_PRIORITIES     TBB_PREVIEW_FLOW_GRAPH_FEATURES
+#endif
+
+// This feature works only in combination with critical tasks (__TBB_PREVIEW_CRITICAL_TASKS)
+#ifndef __TBB_PREVIEW_RESUMABLE_TASKS
+#define __TBB_PREVIEW_RESUMABLE_TASKS           ((__TBB_CPF_BUILD || TBB_PREVIEW_RESUMABLE_TASKS) && !__TBB_WIN8UI_SUPPORT && !__ANDROID__ && !__TBB_ipf)
+#endif
+
+#ifndef __TBB_PREVIEW_CRITICAL_TASKS
+#define __TBB_PREVIEW_CRITICAL_TASKS            (__TBB_CPF_BUILD || __TBB_PREVIEW_FLOW_GRAPH_PRIORITIES || __TBB_PREVIEW_RESUMABLE_TASKS)
+#endif
+
+#ifndef __TBB_PREVIEW_FLOW_GRAPH_NODE_SET
+#define __TBB_PREVIEW_FLOW_GRAPH_NODE_SET       (TBB_PREVIEW_FLOW_GRAPH_FEATURES && __TBB_CPP11_PRESENT && __TBB_FLOW_GRAPH_CPP11_FEATURES)
+#endif
+
 #endif /* __TBB_tbb_config_H */
diff --git a/src/tbb/include/tbb/tbb_disable_exceptions.h b/src/tbb/include/tbb/tbb_disable_exceptions.h
index a1d28a60..69ef5c57 100644
--- a/src/tbb/include/tbb/tbb_disable_exceptions.h
+++ b/src/tbb/include/tbb/tbb_disable_exceptions.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 //! To disable use of exceptions, include this header before any other header file from the library.
diff --git a/src/tbb/include/tbb/tbb_exception.h b/src/tbb/include/tbb/tbb_exception.h
index a2f3e1b6..3c5fb7dd 100644
--- a/src/tbb/include/tbb/tbb_exception.h
+++ b/src/tbb/include/tbb/tbb_exception.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,15 +12,14 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_exception_H
 #define __TBB_exception_H
 
+#define __TBB_tbb_exception_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #include "tbb_stddef.h"
 #include <exception>
 #include <new>    // required for bad_alloc definition, operators new
@@ -38,7 +37,7 @@ class bad_last_alloc : public std::bad_alloc {
 };
 
 //! Exception for PPL locks
-class improper_lock : public std::exception {
+class __TBB_DEPRECATED improper_lock : public std::exception {
 public:
     const char* what() const throw() __TBB_override;
 };
@@ -135,7 +134,7 @@ namespace tbb {
 
     TBB provides two implementations of this interface: tbb::captured_exception and
     template class tbb::movable_exception. See their declarations for more info. **/
-class tbb_exception : public std::exception
+class __TBB_DEPRECATED tbb_exception : public std::exception
 {
     /** No operator new is provided because the TBB usage model assumes dynamic
         creation of the TBB exception objects only by means of applying move()
@@ -189,7 +188,7 @@ class tbb_exception : public std::exception
     algorithm ) if an unhandled exception was intercepted during the algorithm execution in one
     of the workers.
     \sa tbb::tbb_exception **/
-class captured_exception : public tbb_exception
+class __TBB_DEPRECATED_IN_VERBOSE_MODE captured_exception : public tbb_exception
 {
 public:
     captured_exception( const captured_exception& src )
@@ -229,7 +228,7 @@ class captured_exception : public tbb_exception
 
 private:
     //! Used only by method move().
-    captured_exception() {}
+    captured_exception() : my_dynamic(), my_exception_name(), my_exception_info() {}
 
     //! Functionally equivalent to {captured_exception e(name,info); return e.move();}
     static captured_exception* allocate( const char* name, const char* info );
@@ -245,7 +244,7 @@ class captured_exception : public tbb_exception
     and delivered to the root thread ().
     \sa tbb::tbb_exception **/
 template<typename ExceptionData>
-class movable_exception : public tbb_exception
+class __TBB_DEPRECATED movable_exception : public tbb_exception
 {
     typedef movable_exception<ExceptionData> self_type;
 
@@ -357,4 +356,7 @@ class tbb_exception_ptr {
 
 #endif /* __TBB_TASK_GROUP_CONTEXT */
 
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_tbb_exception_H_include_area
+
 #endif /* __TBB_exception_H */
diff --git a/src/tbb/include/tbb/tbb_machine.h b/src/tbb/include/tbb/tbb_machine.h
index cf8ea04b..9752be58 100644
--- a/src/tbb/include/tbb/tbb_machine.h
+++ b/src/tbb/include/tbb/tbb_machine.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_machine_H
@@ -227,7 +223,7 @@ template<> struct atomic_selector<8> {
         #include "machine/linux_intel64.h"
     #endif
 
-#elif __linux__ || __FreeBSD__ || __NetBSD__
+#elif __linux__ || __FreeBSD__ || __NetBSD__ || __OpenBSD__
 
     #if (TBB_USE_GCC_BUILTINS && __TBB_GCC_BUILTIN_ATOMICS_PRESENT)
         #include "machine/gcc_generic.h"
@@ -241,8 +237,8 @@ template<> struct atomic_selector<8> {
         #include "machine/linux_ia64.h"
     #elif __powerpc__
         #include "machine/mac_ppc.h"
-    #elif __ARM_ARCH_7A__
-        #include "machine/gcc_armv7.h"
+    #elif __ARM_ARCH_7A__ || __aarch64__
+        #include "machine/gcc_arm.h"
     #elif __TBB_GCC_BUILTIN_ATOMICS_PRESENT
         #include "machine/gcc_generic.h"
     #endif
@@ -665,7 +661,7 @@ struct machine_load_store_seq_cst<T,8> {
     static void store ( volatile T &location, T value ) {
 #if __TBB_GCC_VERSION >= 40702
 #pragma GCC diagnostic push
-// #pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
+#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
 #endif
         // An atomic initialization leads to reading of uninitialized memory
         int64_t result = (volatile int64_t&)location;
@@ -788,7 +784,7 @@ struct __TBB_machine_type_with_alignment_##PowerOf2 { \
 #endif
 
 /* Now declare types aligned to useful powers of two */
-// TODO: Is __TBB_DefineTypeWithAlignment(8) needed on 32 bit platforms?
+__TBB_DefineTypeWithAlignment(8) // i386 ABI says that uint64_t is aligned on 4 bytes  
 __TBB_DefineTypeWithAlignment(16)
 __TBB_DefineTypeWithAlignment(32)
 __TBB_DefineTypeWithAlignment(64)
@@ -802,7 +798,7 @@ template<size_t N> struct type_with_alignment;
 template<> struct type_with_alignment<1> { char member; };
 template<> struct type_with_alignment<2> { uint16_t member; };
 template<> struct type_with_alignment<4> { uint32_t member; };
-template<> struct type_with_alignment<8> { uint64_t member; };
+template<> struct type_with_alignment<8> { __TBB_machine_type_with_alignment_8 member; };
 template<> struct type_with_alignment<16> {__TBB_machine_type_with_alignment_16 member; };
 template<> struct type_with_alignment<32> {__TBB_machine_type_with_alignment_32 member; };
 template<> struct type_with_alignment<64> {__TBB_machine_type_with_alignment_64 member; };
diff --git a/src/tbb/include/tbb/tbb_profiling.h b/src/tbb/include/tbb/tbb_profiling.h
index ffaf98b9..20f8f512 100644
--- a/src/tbb/include/tbb/tbb_profiling.h
+++ b/src/tbb/include/tbb/tbb_profiling.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,22 +12,17 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_profiling_H
 #define __TBB_profiling_H
 
+#define __TBB_tbb_profiling_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 namespace tbb {
     namespace internal {
 
-        //
-        // This is not under __TBB_ITT_STRUCTURE_API because these values are used directly in flow_graph.h.
-        //
-
         // include list of index names
         #define TBB_STRING_RESOURCE(index_name,str) index_name,
         enum string_index {
@@ -126,6 +121,7 @@ namespace tbb {
 #endif /* no tools support */
 
 #include "atomic.h"
+
 // Need these to work regardless of tools support
 namespace tbb {
     namespace internal {
@@ -138,13 +134,14 @@ namespace tbb {
         void __TBB_EXPORTED_FUNC itt_store_pointer_with_release_v3(void *dst, void *src);
         void* __TBB_EXPORTED_FUNC itt_load_pointer_with_acquire_v3(const void *src);
         void* __TBB_EXPORTED_FUNC itt_load_pointer_v3( const void* src );
-#if __TBB_ITT_STRUCTURE_API
-        enum itt_domain_enum { ITT_DOMAIN_FLOW=0 };
+        enum itt_domain_enum { ITT_DOMAIN_FLOW=0, ITT_DOMAIN_MAIN=1, ITT_DOMAIN_ALGO=2, ITT_NUM_DOMAINS };
 
         void __TBB_EXPORTED_FUNC itt_make_task_group_v7( itt_domain_enum domain, void *group, unsigned long long group_extra,
                                                          void *parent, unsigned long long parent_extra, string_index name_index );
         void __TBB_EXPORTED_FUNC itt_metadata_str_add_v7( itt_domain_enum domain, void *addr, unsigned long long addr_extra,
                                                           string_index key, const char *value );
+        void __TBB_EXPORTED_FUNC itt_metadata_ptr_add_v11( itt_domain_enum domain, void *addr, unsigned long long addr_extra,
+                                                           string_index key, void* value );
         void __TBB_EXPORTED_FUNC itt_relation_add_v7( itt_domain_enum domain, void *addr0, unsigned long long addr0_extra,
                                                       itt_relation relation, void *addr1, unsigned long long addr1_extra );
         void __TBB_EXPORTED_FUNC itt_task_begin_v7( itt_domain_enum domain, void *task, unsigned long long task_extra,
@@ -154,7 +151,6 @@ namespace tbb {
         void __TBB_EXPORTED_FUNC itt_region_begin_v9( itt_domain_enum domain, void *region, unsigned long long region_extra,
                                                       void *parent, unsigned long long parent_extra, string_index name_index );
         void __TBB_EXPORTED_FUNC itt_region_end_v9( itt_domain_enum domain, void *region, unsigned long long region_extra );
-#endif // __TBB_ITT_STRUCTURE_API
 
         // two template arguments are to workaround /Wp64 warning with tbb::atomic specialized for unsigned type
         template <typename T, typename U>
@@ -238,12 +234,6 @@ namespace tbb {
             call_itt_notify_v5((int)t, ptr);
         }
 
-#else
-        inline void call_itt_notify(notify_type /*t*/, void * /*ptr*/) {}
-
-#endif // TBB_USE_THREADING_TOOLS
-
-#if __TBB_ITT_STRUCTURE_API
         inline void itt_make_task_group( itt_domain_enum domain, void *group, unsigned long long group_extra,
                                          void *parent, unsigned long long parent_extra, string_index name_index ) {
             itt_make_task_group_v7( domain, group, group_extra, parent, parent_extra, name_index );
@@ -253,6 +243,11 @@ namespace tbb {
                                           string_index key, const char *value ) {
             itt_metadata_str_add_v7( domain, addr, addr_extra, key, value );
         }
+        
+        inline void register_node_addr(itt_domain_enum domain, void *addr, unsigned long long addr_extra,
+            string_index key, void *value) {
+            itt_metadata_ptr_add_v11(domain, addr, addr_extra, key, value);
+        }
 
         inline void itt_relation_add( itt_domain_enum domain, void *addr0, unsigned long long addr0_extra,
                                       itt_relation relation, void *addr1, unsigned long long addr1_extra ) {
@@ -276,9 +271,85 @@ namespace tbb {
         inline void itt_region_end( itt_domain_enum domain, void *region, unsigned long long region_extra  ) {
             itt_region_end_v9( domain, region, region_extra );
         }
-#endif // __TBB_ITT_STRUCTURE_API
+#else
+        inline void register_node_addr( itt_domain_enum /*domain*/, void* /*addr*/, unsigned long long /*addr_extra*/, string_index /*key*/, void* /*value*/ ) {}
+        inline void call_itt_notify(notify_type /*t*/, void* /*ptr*/) {}
+
+        inline void itt_make_task_group( itt_domain_enum /*domain*/, void* /*group*/, unsigned long long /*group_extra*/,
+                                         void* /*parent*/, unsigned long long /*parent_extra*/, string_index /*name_index*/ ) {}
+
+        inline void itt_metadata_str_add( itt_domain_enum /*domain*/, void* /*addr*/, unsigned long long /*addr_extra*/,
+                                          string_index /*key*/, const char* /*value*/ ) {}
+
+        inline void itt_relation_add( itt_domain_enum /*domain*/, void* /*addr0*/, unsigned long long /*addr0_extra*/,
+                                      itt_relation /*relation*/, void* /*addr1*/, unsigned long long /*addr1_extra*/ ) {}
+
+        inline void itt_task_begin( itt_domain_enum /*domain*/, void* /*task*/, unsigned long long /*task_extra*/,
+                                    void* /*parent*/, unsigned long long /*parent_extra*/, string_index /*name_index*/ ) {}
+
+        inline void itt_task_end( itt_domain_enum /*domain*/ ) {}
+
+        inline void itt_region_begin( itt_domain_enum /*domain*/, void* /*region*/, unsigned long long /*region_extra*/,
+                                      void* /*parent*/, unsigned long long /*parent_extra*/, string_index /*name_index*/ ) {}
+
+        inline void itt_region_end( itt_domain_enum /*domain*/, void* /*region*/, unsigned long long /*region_extra*/ ) {}
+#endif // TBB_USE_THREADING_TOOLS
 
     } // namespace internal
 } // namespace tbb
 
+#if TBB_PREVIEW_FLOW_GRAPH_TRACE
+#include <string>
+
+namespace tbb {
+namespace profiling {
+namespace interface10 {
+
+#if TBB_USE_THREADING_TOOLS && !(TBB_USE_THREADING_TOOLS == 2)
+class event {
+/** This class supports user event traces through itt.
+    Common use-case is tagging data flow graph tasks (data-id)
+    and visualization by Intel Advisor Flow Graph Analyzer (FGA)  **/
+//  TODO: Replace implementation by itt user event api.
+
+    const std::string my_name;
+
+    static void emit_trace(const std::string &input) {
+        itt_metadata_str_add( tbb::internal::ITT_DOMAIN_FLOW, NULL, tbb::internal::FLOW_NULL, tbb::internal::USER_EVENT, ( "FGA::DATAID::" + input ).c_str() );
+    }
+
+public:
+    event(const std::string &input)
+              : my_name( input )
+    { }
+
+    void emit() {
+        emit_trace(my_name);
+    }
+
+    static void emit(const std::string &description) {
+        emit_trace(description);
+    }
+
+};
+#else // TBB_USE_THREADING_TOOLS && !(TBB_USE_THREADING_TOOLS == 2)
+// Using empty struct if user event tracing is disabled:
+struct event {
+    event(const std::string &) { }
+
+    void emit() { }
+
+    static void emit(const std::string &) { }
+};
+#endif // TBB_USE_THREADING_TOOLS && !(TBB_USE_THREADING_TOOLS == 2)
+
+} // interfaceX
+using interface10::event;
+} // namespace profiling
+} // namespace tbb
+#endif // TBB_PREVIEW_FLOW_GRAPH_TRACE
+
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_tbb_profiling_H_include_area
+
 #endif /* __TBB_profiling_H */
diff --git a/src/tbb/include/tbb/tbb_stddef.h b/src/tbb/include/tbb/tbb_stddef.h
index b4ee7810..96743024 100644
--- a/src/tbb/include/tbb/tbb_stddef.h
+++ b/src/tbb/include/tbb/tbb_stddef.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,21 +12,17 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_tbb_stddef_H
 #define __TBB_tbb_stddef_H
 
 // Marketing-driven product version
-#define TBB_VERSION_MAJOR 2018
-#define TBB_VERSION_MINOR 0
+#define TBB_VERSION_MAJOR 2020
+#define TBB_VERSION_MINOR 3
 
 // Engineering-focused interface version
-#define TBB_INTERFACE_VERSION 10001
+#define TBB_INTERFACE_VERSION 11103
 #define TBB_INTERFACE_VERSION_MAJOR TBB_INTERFACE_VERSION/1000
 
 // The oldest major interface version still supported
@@ -155,8 +151,8 @@ namespace tbb {
 
 #if TBB_USE_ASSERT
 
-    //! Assert that x is true.
-    /** If x is false, print assertion failure message.
+    //! Assert that predicate is true.
+    /** If predicate is false, print assertion failure message.
         If the comment argument is not NULL, it is printed as part of the failure message.
         The comment argument has no other effect. */
     #define __TBB_ASSERT(predicate,message) __TBB_ASSERT_RELEASE(predicate,message)
@@ -246,6 +242,14 @@ const size_t NFS_MaxLineSize = 128;
 #define __TBB_override // formal comment only
 #endif
 
+#if __TBB_CPP17_FALLTHROUGH_PRESENT
+#define __TBB_fallthrough [[fallthrough]]
+#elif __TBB_FALLTHROUGH_PRESENT
+#define __TBB_fallthrough __attribute__ ((fallthrough))
+#else
+#define __TBB_fallthrough
+#endif
+
 template<class T, size_t S, size_t R>
 struct padded_base : T {
     char pad[S - R];
@@ -312,6 +316,25 @@ inline T punned_cast( U* ptr ) {
     return reinterpret_cast<T>(x);
 }
 
+#if __TBB_DEFAULTED_AND_DELETED_FUNC_PRESENT
+
+//! Base class for types that should not be assigned.
+class no_assign {
+public:
+    void operator=( const no_assign& ) = delete;
+    no_assign( const no_assign& ) = default;
+    no_assign() = default;
+};
+
+//! Base class for types that should not be copied or assigned.
+class no_copy: no_assign {
+public:
+    no_copy( const no_copy& ) = delete;
+    no_copy() = default;
+};
+
+#else /*__TBB_DEFAULTED_AND_DELETED_FUNC_PRESENT*/
+
 //! Base class for types that should not be assigned.
 class no_assign {
     // Deny assignment
@@ -332,6 +355,8 @@ class no_copy: no_assign {
     no_copy() {}
 };
 
+#endif /*__TBB_DEFAULTED_AND_DELETED_FUNC_PRESENT*/
+
 #if TBB_DEPRECATED_MUTEX_COPYING
 class mutex_copy_deprecated_and_disabled {};
 #else
@@ -423,8 +448,8 @@ class proportional_split: internal::no_assign {
 // Following is a set of classes and functions typically used in compile-time "metaprogramming".
 // TODO: move all that to a separate header
 
-#if __TBB_ALLOCATOR_TRAITS_PRESENT || __TBB_CPP11_SMART_POINTERS_PRESENT
-#include <memory> // for allocator_traits, unique_ptr
+#if __TBB_CPP11_SMART_POINTERS_PRESENT
+#include <memory> // for unique_ptr
 #endif
 
 #if __TBB_CPP11_RVALUE_REF_PRESENT || __TBB_CPP11_DECLTYPE_PRESENT || _LIBCPP_VERSION
@@ -464,15 +489,6 @@ struct bool_constant {
 typedef bool_constant<true> true_type;
 typedef bool_constant<false> false_type;
 
-#if __TBB_ALLOCATOR_TRAITS_PRESENT
-using std::allocator_traits;
-#else
-template<typename allocator>
-struct allocator_traits{
-    typedef tbb::internal::false_type propagate_on_container_move_assignment;
-};
-#endif
-
 //! A template to select either 32-bit or 64-bit constant as compile time, depending on machine word size.
 template <unsigned u, unsigned long long ull >
 struct select_size_t_constant {
@@ -533,7 +549,7 @@ struct STATIC_ASSERTION_FAILED<true>; //intentionally left undefined to cause co
 //! @endcond
 }} // namespace tbb::internal
 
-#if    __TBB_STATIC_ASSERT_PRESENT
+#if __TBB_STATIC_ASSERT_PRESENT
 #define __TBB_STATIC_ASSERT(condition,msg) static_assert(condition,msg)
 #else
 //please note condition is intentionally inverted to get a bit more understandable error msg
diff --git a/src/tbb/include/tbb/tbb_thread.h b/src/tbb/include/tbb/tbb_thread.h
index c2846b9e..48c11711 100644
--- a/src/tbb/include/tbb/tbb_thread.h
+++ b/src/tbb/include/tbb/tbb_thread.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,15 +12,25 @@
     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 "internal/_deprecated_header_message_guard.h"
 
+#if !defined(__TBB_show_deprecation_message_tbb_thread_H) && defined(__TBB_show_deprecated_header_message)
+#define  __TBB_show_deprecation_message_tbb_thread_H
+#pragma message("TBB Warning: tbb/tbb_thread.h is deprecated. For details, please see Deprecated Features appendix in the TBB reference manual.")
+#endif
 
-
-*/
+#if defined(__TBB_show_deprecated_header_message)
+#undef __TBB_show_deprecated_header_message
+#endif
 
 #ifndef __TBB_tbb_thread_H
 #define __TBB_tbb_thread_H
 
+#define __TBB_tbb_thread_H_include_area
+#include "internal/_warning_suppress_enable_notice.h"
+
 #include "tbb_stddef.h"
 
 #if _WIN32||_WIN64
@@ -246,7 +256,7 @@ namespace internal {
         friend tbb_thread_v3::id __TBB_EXPORTED_FUNC thread_get_id_v3();
 
         friend inline size_t tbb_hasher( const tbb_thread_v3::id& id ) {
-            __TBB_STATIC_ASSERT(sizeof(id.my_id) <= sizeof(size_t), "Implementaion assumes that thread_id_type fits into machine word");
+            __TBB_STATIC_ASSERT(sizeof(id.my_id) <= sizeof(size_t), "Implementation assumes that thread_id_type fits into machine word");
             return tbb::tbb_hasher(id.my_id);
         }
 
@@ -297,7 +307,7 @@ namespace internal {
 } // namespace internal;
 
 //! Users reference thread class by name tbb_thread
-typedef internal::tbb_thread_v3 tbb_thread;
+__TBB_DEPRECATED_IN_VERBOSE_MODE_MSG("tbb::thread is deprecated, use std::thread") typedef internal::tbb_thread_v3 tbb_thread;
 
 using internal::operator==;
 using internal::operator!=;
@@ -318,15 +328,18 @@ inline void swap( internal::tbb_thread_v3& t1, internal::tbb_thread_v3& t2 )  __
 }
 
 namespace this_tbb_thread {
-    inline tbb_thread::id get_id() { return internal::thread_get_id_v3(); }
+    __TBB_DEPRECATED_IN_VERBOSE_MODE inline tbb_thread::id get_id() { return internal::thread_get_id_v3(); }
     //! Offers the operating system the opportunity to schedule another thread.
-    inline void yield() { internal::thread_yield_v3(); }
+    __TBB_DEPRECATED_IN_VERBOSE_MODE inline void yield() { internal::thread_yield_v3(); }
     //! The current thread blocks at least until the time specified.
-    inline void sleep(const tick_count::interval_t &i) {
+    __TBB_DEPRECATED_IN_VERBOSE_MODE inline void sleep(const tick_count::interval_t &i) {
         internal::thread_sleep_v3(i);
     }
 }  // namespace this_tbb_thread
 
 } // namespace tbb
 
+#include "internal/_warning_suppress_disable_notice.h"
+#undef __TBB_tbb_thread_H_include_area
+
 #endif /* __TBB_tbb_thread_H */
diff --git a/src/tbb/include/tbb/tbbmalloc_proxy.h b/src/tbb/include/tbb/tbbmalloc_proxy.h
index 76cbd6d7..28f6a405 100644
--- a/src/tbb/include/tbb/tbbmalloc_proxy.h
+++ b/src/tbb/include/tbb/tbbmalloc_proxy.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 /*
@@ -63,4 +59,7 @@ struct __TBB_malloc_proxy_caller {
 
 #endif // _MSC_VER
 
+/* Public Windows API */
+extern "C" int TBB_malloc_replacement_log(char *** function_replacement_log_ptr);
+
 #endif //__TBB_tbbmalloc_proxy_H
diff --git a/src/tbb/include/tbb/tick_count.h b/src/tbb/include/tbb/tick_count.h
index a7f4e0f3..bbc92476 100644
--- a/src/tbb/include/tbb/tick_count.h
+++ b/src/tbb/include/tbb/tick_count.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_tick_count_H
diff --git a/src/tbb/index.html b/src/tbb/index.html
new file mode 100644
index 00000000..8aee7ae9
--- /dev/null
+++ b/src/tbb/index.html
@@ -0,0 +1,48 @@
+<HTML>
+<BODY>
+<H2>Overview</H2>
+Top level directory for Intel&reg; Threading Building Blocks (Intel&reg; TBB).
+<H2>Common directories</H2>
+<DL>
+<DT><A HREF="include/index.html">include</A>
+<DD>Include files required for compiling code that uses the library.
+<DT><A HREF="examples/index.html">examples</A>
+<DD>Examples of how to use the library.
+<DT><A HREF="python/index.html">python</A>
+<DD>Python* API for Intel TBB.
+</DL>
+<H2>Intel TBB source package</H2>
+<P>
+To build Intel TBB, use the <A HREF=Makefile>top-level Makefile</A>; see also the <A HREF=build/index.html#build>build directions</A>.
+To port Intel TBB to a new platform, operating system or architecture, see the <A HREF=build/index.html#port>porting directions</A>.
+</P>
+<H3>Files</H3>
+<DL>
+<DT><A HREF="Makefile">Makefile</A>
+<DD>Top-level Makefile for Intel TBB. See also the <A HREF=build/index.html#build>build directions</A>.
+</DL>
+<H3>Directories</H3>
+<DL>
+<DT><A HREF="src/index.html">src</A>
+<DD>Source code for the library.
+<DT><A HREF="build/index.html">build</A>, <A HREF="jni/">jni</A>
+<DD>Internal Makefile infrastructure for Intel TBB. Do not use directly; see the <A HREF=build/index.html#build>build directions</A>.
+</DL>
+<H2>Intel TBB binary package</H2>
+<H3>Directories</H3>
+<DL>
+<DT><A HREF="bin">bin</A>
+<DD>Start-up scripts for sourcing library for Linux* OS and macOS*. For Windows* OS: start-up scripts and dynamic-link libraries.
+<DT><A HREF="lib">lib</A>
+<DD>Platform-specific binary files for the library.
+</DL>
+<HR>
+<p></p>
+Copyright &copy; 2005-2020 Intel Corporation.  All Rights Reserved.
+<P></P>
+Intel is a registered trademark or trademark of Intel Corporation
+or its subsidiaries in the United States and other countries.
+<p></p>
+* Other names and brands may be claimed as the property of others.
+</BODY>
+</HTML>
diff --git a/src/tbb/jni/Android.mk b/src/tbb/jni/Android.mk
new file mode 100644
index 00000000..74c5863c
--- /dev/null
+++ b/src/tbb/jni/Android.mk
@@ -0,0 +1,62 @@
+# Copyright (c) 2005-2020 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.
+
+export tbb_root?=$(NDK_PROJECT_PATH)
+
+ifeq (armeabi-v7a,$(APP_ABI))
+	export SYSROOT:=$(NDK_ROOT)/platforms/$(APP_PLATFORM)/arch-arm
+else ifeq (arm64-v8a,$(APP_ABI))
+	export SYSROOT:=$(NDK_ROOT)/platforms/$(APP_PLATFORM)/arch-arm64
+else
+	export SYSROOT:=$(NDK_ROOT)/platforms/$(APP_PLATFORM)/arch-$(APP_ABI)
+endif
+
+ifeq (windows,$(tbb_os))
+	export CPATH_SEPARATOR :=;
+else
+	export CPATH_SEPARATOR :=:
+endif
+
+export ANDROID_NDK_ROOT:=$(NDK_ROOT)
+export ndk_version:=$(lastword $(subst -, ,$(ANDROID_NDK_ROOT)))
+ndk_version:= $(firstword $(subst /, ,$(ndk_version)))
+ndk_version:= $(firstword $(subst \, ,$(ndk_version)))
+
+ifeq (clang,$(compiler))
+	ifeq (,$(findstring $(ndk_version),ifeq (,$(findstring $(ndk_version),$(foreach v, 7 8 9 10 11 12,r$(v) r$(v)b r$(v)c r$(v)d r$(v)e)))))
+		TBB_RTL :=llvm-libc++
+	else
+		TBB_RTL :=llvm-libc++/libcxx
+	endif
+	TBB_RTL_LIB :=llvm-libc++
+	TBB_RTL_FILE :=libc++_shared.so
+else
+	TBB_RTL :=gnu-libstdc++/$(NDK_TOOLCHAIN_VERSION)
+	TBB_RTL_LIB :=$(TBB_RTL)
+	TBB_RTL_FILE :=libgnustl_shared.so
+endif
+
+export CPATH := $(SYSROOT)/usr/include$(CPATH_SEPARATOR)$(NDK_ROOT)/sources/cxx-stl/$(TBB_RTL)/include$(CPATH_SEPARATOR)$(NDK_ROOT)/sources/cxx-stl/$(TBB_RTL)/libs/$(APP_ABI)/include$(CPATH_SEPARATOR)$(NDK_ROOT)/sources/android/support/include
+
+LIB_STL_ANDROID_DIR := $(NDK_ROOT)/sources/cxx-stl/$(TBB_RTL_LIB)/libs/$(APP_ABI)
+#LIB_STL_ANDROID is required to be set up for copying Android specific library to a device next to test
+export LIB_STL_ANDROID := $(LIB_STL_ANDROID_DIR)/$(TBB_RTL_FILE)
+export CPLUS_LIB_PATH := $(SYSROOT)/usr/lib -L$(LIB_STL_ANDROID_DIR)
+export target_os_version:=$(APP_PLATFORM)
+export tbb_tool_prefix:=$(TOOLCHAIN_PREFIX)
+export TARGET_CXX
+export TARGET_CC
+export TARGET_CFLAGS
+
+include $(NDK_PROJECT_PATH)/src/Makefile
diff --git a/src/tbb/jni/Application.mk b/src/tbb/jni/Application.mk
new file mode 100644
index 00000000..8f711496
--- /dev/null
+++ b/src/tbb/jni/Application.mk
@@ -0,0 +1,67 @@
+# Copyright (c) 2005-2020 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.
+
+ifndef tbb_os
+
+  # Windows sets environment variable OS; for other systems, ask uname
+  ifeq ($(OS),)
+    OS:=$(shell uname)
+    ifeq ($(OS),)
+      $(error "Cannot detect operating system")
+    endif
+    export tbb_os=$(OS)
+  endif
+
+  ifeq ($(OS), Windows_NT)
+    export tbb_os=windows
+  endif
+  ifeq ($(OS), Linux)
+    export tbb_os=linux
+  endif
+  ifeq ($(OS), Darwin)
+    export tbb_os=macos
+  endif
+
+endif
+
+export compiler?=clang
+export arch?=ia32
+export target?=android
+
+ifeq (ia32,$(arch))
+    APP_ABI:=x86
+    export TRIPLE:=i686-linux-android
+else ifeq (intel64,$(arch))
+    APP_ABI:=x86_64
+    export TRIPLE:=x86_64-linux-android
+else ifeq (arm,$(arch))
+    APP_ABI:=armeabi-v7a
+    export TRIPLE:=arm-linux-androideabi
+else ifeq (arm64,$(arch))
+    APP_ABI:=arm64-v8a
+    export TRIPLE:=aarch64-linux-android
+else
+    APP_ABI:=$(arch)
+endif
+
+api_version?=21
+export API_LEVEL:=$(api_version)
+APP_PLATFORM:=android-$(api_version)
+
+ifeq (clang,$(compiler))
+    NDK_TOOLCHAIN_VERSION:=clang
+    APP_STL:=c++_shared
+else
+    NDK_TOOLCHAIN_VERSION:=4.9
+endif
diff --git a/src/tbb/python/Makefile b/src/tbb/python/Makefile
new file mode 100644
index 00000000..2afbca67
--- /dev/null
+++ b/src/tbb/python/Makefile
@@ -0,0 +1,45 @@
+# Copyright (c) 2016-2020 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.
+
+tbb_root?=..
+BUILDING_PHASE:=0
+include $(tbb_root)/build/common.inc
+.PHONY: all release test install test-install
+
+export TBBROOT=$(abspath $(tbb_root))
+SRC=$(tbb_root)/python/*.py $(tbb_root)/python/tbb/*
+PY_SETUP=python $(tbb_root)/python/setup.py
+
+all: install test
+
+clean:
+	$(PY_SETUP) clean -b$(work_dir)_release
+
+release: CC=$(compiler)
+release: $(SRC) rml
+	$(PY_SETUP) build -b$(work_dir)_release -f check
+
+install: CC=$(compiler)
+install: $(SRC) rml
+	$(PY_SETUP) build -b$(work_dir)_release build_ext -f -I$(tbb_root)/include -L$(work_dir)_release install -f
+
+test:
+	python -m tbb test
+
+rml:
+ifeq (linux,$(tbb_os))
+	$(MAKE) -C "$(work_dir)_release" -rf $(tbb_root)/python/rml/Makefile cfg=release rml
+rml_%:
+	$(MAKE) -C "$(work_dir)_release" -rf $(tbb_root)/python/rml/Makefile cfg=release $(subst rml_,,$@)
+endif
diff --git a/src/tbb/python/TBB.py b/src/tbb/python/TBB.py
new file mode 100644
index 00000000..1a5d0e32
--- /dev/null
+++ b/src/tbb/python/TBB.py
@@ -0,0 +1,24 @@
+#!/usr/bin/env python
+#
+# Copyright (c) 2016-2020 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.
+
+
+from tbb import *
+from tbb import __all__, __doc__
+
+if __name__ == "__main__":
+    from tbb import _main
+    import sys
+    sys.exit(_main())
diff --git a/src/tbb/python/index.html b/src/tbb/python/index.html
new file mode 100644
index 00000000..f5e69276
--- /dev/null
+++ b/src/tbb/python/index.html
@@ -0,0 +1,84 @@
+<HTML>
+<BODY>
+<H2>Python* API for Intel&reg; Threading Building Blocks (Intel&reg; TBB).
+</H2>
+
+<H2>Overview</H2>
+It is a preview Python* module which unlocks opportunities for additional performance in multi-threaded and multiprocess Python programs by enabling threading composability
+between two or more thread-enabled libraries like Numpy, Scipy, Sklearn, Dask, Joblib, and etc.
+<p></p>
+The biggest improvement can be achieved when a task pool like the ThreadPool or Pool from the Python standard library or libraries like Dask or Joblib (used either in multi-threading or multi-processing mode)
+execute tasks calling compute-intensive functions of Numpy/Scipy/Sklearn/PyDAAL which in turn are parallelized using Intel&reg; Math Kernel Library or/and Intel&reg; TBB.
+<p></p>
+The module implements Pool class with the standard interface using Intel&reg; TBB which can be used to replace Python's ThreadPool.
+Thanks to the monkey-patching technique implemented in class Monkey, no source code change is needed in order to enable threading composability in Python programs.
+<p></p>
+For more information and examples, please refer to <A HREF="http://software.intel.com/en-us/blogs/2016/04/04/unleash-parallel-performance-of-python-programs">online blog</A>.
+
+<H2>Directories</H2>
+<DL>
+<DT><A HREF="rml">rml</A>
+<DD>The folder contains sources for building the plugin with cross-process dynamic thread scheduler implementation.
+<DT><A HREF="tbb">tbb</A>
+<DD>The folder contains Python module sources.
+</DL>
+
+<H2>Files</H2>
+<DL>
+<DT><A HREF="setup.py">setup.py</A>
+<DD>Standard Python setup script.
+<DT><A HREF="Makefile">Makefile</A>
+<DD>Internal Makefile for building, installing, and testing. See below.
+<DT><A HREF="TBB.py">TBB.py</A>
+<DD>Alternative entry point for Python module.
+</DL>
+
+<A NAME=build><H2>Build and install (source package only)</H2></A>
+For accessing targets defined in python/Makefile, please use
+<A HREF="../src/index.html">src/Makefile</A>
+instead and build runtime libraries before working with Python.
+<DL>
+<DT><TT>make -C ../src python_all</TT>
+<DD>Install and test as described below.
+<DT><TT>make -C ../src python_install</TT>
+<DD>Install module into Python environment.
+<DT><TT>make -C ../src python_test</TT>
+<DD>Test installed Intel&reg; TBB module for Python.
+<DT><TT>make -C ../src python_release</TT>
+<DD>Recompile Python module. Result is located in Intel&reg; TBB build directory.
+<DT><TT>make  -C ../src python_clean</TT>
+<DD>Remove any intermediate files produced by the commands above. Does not remove installed module.
+</DL>
+
+<H2>Command-line interface</H2>
+<DL>
+<DT><TT>python -m tbb -h</TT>
+<DD>Print documentation on command-line interface</DD>
+<DT><TT>pydoc tbb</TT>
+<DD>Read built-in documentation for Python interfaces.</DD>
+<DT><TT>python-tbb your_script.py</TT>
+<DT><TT>python -m tbb your_script.py</TT>
+<DD>Run your_script.py in context of `with tbb.Monkey():` when Intel&reg; TBB is enabled. By default only multi-threading will be covered.</DD>
+<DT><TT>python -m tbb --ipc your_script.py</TT>
+<DD>Run your_script.py in context of `with tbb.Monkey():` when Intel&reg; TBB enabled in both multi-threading and multi-processing modes.</DD>
+</DL>
+
+<H2>System Requirements</H2>
+The Python module was not tested on older versions of Python thus we require at least Python versions 2.7 and 3.5 or higher.<BR>
+SWIG must be of version 3.0.6 or higher<BR>
+OS versions:
+Microsoft* Windows* Server 2012,
+Microsoft* Windows* 10,
+Ubuntu* 14.04 LTS,
+Red Hat* Enterprise Linux* 7.
+<HR>
+<A href="../index.html">Up to parent directory</A>
+<p></p>
+Copyright &copy; 2016-2020 Intel Corporation.  All Rights Reserved.
+<P></P>
+Intel is a registered trademark or trademark of Intel Corporation
+or its subsidiaries in the United States and other countries.
+<p></p>
+* Other names and brands may be claimed as the property of others.
+</BODY>
+</HTML>
diff --git a/src/tbb/python/rml/Makefile b/src/tbb/python/rml/Makefile
new file mode 100644
index 00000000..dc3b0bd1
--- /dev/null
+++ b/src/tbb/python/rml/Makefile
@@ -0,0 +1,151 @@
+# Copyright (c) 2017-2020 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.
+
+
+.NOTPARALLEL:
+
+tbb_root ?= ../..
+BUILDING_PHASE=0
+TEST_RESOURCE = $(RML.RES)
+include $(tbb_root)/build/common.inc
+DEBUG_SUFFIX=$(findstring _debug,_$(cfg))
+
+ifneq (linux,$(target))
+$(error "IPC RML is supported on Linux only")
+endif
+
+.PHONY: default rml test clean
+
+# default target
+default: rml test
+
+RML_ROOT ?= $(tbb_root)/src/rml
+RML_SERVER_ROOT = $(RML_ROOT)/server
+# TODO: new API needs to be added for this server, exposing everything
+RML.DEF =
+
+VPATH = $(tbb_root)/src/tbb $(tbb_root)/src/tbb/$(ASSEMBLY_SOURCE)
+VPATH += $(tbb_root)/python/rml $(RML_ROOT)/test $(tbb_root)/src/test
+VPATH += $(tbb_root)/src/rml/client
+
+include $(tbb_root)/build/common_rules.inc
+
+#--------------------------------------------------------------------------
+# Define rules for making the RML server shared library and client objects.
+#--------------------------------------------------------------------------
+
+# Object files that make up RML server
+RML_SERVER.OBJ = ipc_server.$(OBJ)
+
+# Object files that RML clients need
+RML_TBB_CLIENT.OBJ ?= ipc_utils.$(OBJ)
+RML.OBJ = $(RML_SERVER.OBJ) $(RML_TBB_CLIENT.OBJ)
+ifeq (windows,$(tbb_os))
+RML_ASM.OBJ = $(if $(findstring intel64,$(arch)),$(TBB_ASM.OBJ))
+endif
+ifeq (linux,$(tbb_os))
+RML_ASM.OBJ = $(if $(findstring ia64,$(arch)),$(TBB_ASM.OBJ))
+endif
+
+RML_TBB_DEP= cache_aligned_allocator_rml.$(OBJ) dynamic_link_rml.$(OBJ) tbb_misc_rml.$(OBJ) tbb_misc_ex_rml.$(OBJ)
+TBB_DEP_NON_RML_TEST?= cache_aligned_allocator_rml.$(OBJ) dynamic_link_rml.$(OBJ) $(RML_ASM.OBJ) tbb_misc_rml.$(OBJ) tbb_misc_ex_rml.$(OBJ)
+ifeq ($(cfg),debug)
+RML_TBB_DEP+= spin_mutex_rml.$(OBJ)
+TBB_DEP_RML_TEST?= $(RML_ASM.OBJ) tbb_misc_rml.$(OBJ)
+else
+TBB_DEP_RML_TEST?= $(RML_ASM.OBJ)
+endif
+LIBS += $(LIBDL)
+TBB_DEP_RML_TEST =  rml_tbb.$(OBJ) dynamic_link_rml.$(OBJ)
+
+INCLUDES += $(INCLUDE_KEY)$(RML_ROOT)/include $(INCLUDE_KEY).
+T_INCLUDES = $(INCLUDES) $(INCLUDE_KEY)$(tbb_root)/src/test $(INCLUDE_KEY)$(RML_SERVER_ROOT)
+
+# Suppress superfluous warnings for RML compilation
+R_CPLUS_FLAGS =  $(subst DO_ITT_NOTIFY,DO_ITT_NOTIFY=0,$(CPLUS_FLAGS)) $(WARNING_SUPPRESS) \
+		 $(DEFINE_KEY)TBB_USE_THREADING_TOOLS=0 $(DEFINE_KEY)__TBB_RML_STATIC=1 $(DEFINE_KEY)__TBB_NO_IMPLICIT_LINKAGE=1
+
+%.$(OBJ): %.cpp
+	$(CPLUS) $(COMPILE_ONLY) $(R_CPLUS_FLAGS) $(PIC_KEY) $(DSE_KEY) $(INCLUDES) $<
+
+tbb_misc_rml.$(OBJ) $(RML_SERVER.OBJ): version_string.ver
+
+RML_TEST.OBJ = test_job_automaton.$(OBJ) test_thread_monitor.$(OBJ) test_rml_tbb.$(OBJ)
+
+$(RML_TBB_DEP): %_rml.$(OBJ): %.cpp
+	$(CPLUS) $(COMPILE_ONLY) $(OUTPUTOBJ_KEY)$@ $(R_CPLUS_FLAGS) $(PIC_KEY) $(DSE_KEY) $(INCLUDES) $<
+
+$(RML_TEST.OBJ): %.$(OBJ): %.cpp
+	$(CPLUS) $(COMPILE_ONLY) $(R_CPLUS_FLAGS) $(PIC_KEY) $(T_INCLUDES) $<
+
+ifneq (,$(RML.DEF))
+rml.def: $(RML.DEF)
+	$(CPLUS) $(PREPROC_ONLY) $< $(CPLUS_FLAGS) $(INCLUDES) > $@
+
+LIB_LINK_FLAGS += $(EXPORT_KEY)rml.def
+$(RML.DLL): rml.def
+endif
+
+$(RML.DLL): CPLUS_FLAGS += $(SDL_FLAGS)
+$(RML.DLL): BUILDING_LIBRARY = $(RML.DLL)
+$(RML.DLL): $(RML_TBB_DEP) $(RML.OBJ) $(RML.RES) $(RML_NO_VERSION.DLL) $(RML_ASM.OBJ)
+	$(LIB_LINK_CMD) $(LIB_OUTPUT_KEY)$(RML.DLL) $(RML.OBJ) $(RML_TBB_DEP) $(RML_ASM.OBJ) $(RML.RES) $(LIB_LINK_LIBS) $(LIB_LINK_FLAGS)
+
+ifneq (,$(RML_NO_VERSION.DLL))
+$(RML_NO_VERSION.DLL):
+	echo "INPUT ($(RML.DLL))" > $(RML_NO_VERSION.DLL)
+endif
+
+rml: rml_dll
+rml_dll: $(RML.DLL)
+
+#------------------------------------------------------
+# End of rules for making the RML server shared library
+#------------------------------------------------------
+
+#------------------------------------------------------
+# Define rules for making the RML unit tests
+#------------------------------------------------------
+
+add_debug=$(basename $(1))_debug$(suffix $(1))
+cross_suffix=$(if $(crosstest),$(if $(DEBUG_SUFFIX),$(subst _debug,,$(1)),$(call add_debug,$(1))),$(1))
+
+RML_TESTS = test_job_automaton.$(TEST_EXT) test_thread_monitor.$(TEST_EXT)
+RML_CUSTOM_TESTS = test_rml_tbb.$(TEST_EXT)
+
+test_rml_tbb.$(TEST_EXT): test_rml_tbb.$(OBJ) $(RML_TBB_CLIENT.OBJ) $(TBB_DEP_RML_TEST)
+	$(CPLUS) $(OUTPUT_KEY)$@ $(CPLUS_FLAGS) test_rml_tbb.$(OBJ) $(RML_TBB_CLIENT.OBJ) $(TBB_DEP_RML_TEST) $(LIBS) $(LINK_FLAGS)
+
+$(RML_TESTS): %.$(TEST_EXT): %.$(OBJ) $(TBB_DEP_NON_RML_TEST)
+	$(CPLUS) $(OUTPUT_KEY)$@ $(CPLUS_FLAGS) $< $(TBB_DEP_NON_RML_TEST) $(LIBS) $(LINK_FLAGS)
+
+export IPC_ENABLE=1
+### run_cmd is usually empty
+test: $(call cross_suffix,$(RML.DLL)) $(TEST_PREREQUISITE) $(RML_TESTS) $(RML_CUSTOM_TESTS)
+	$(run_cmd) ./test_job_automaton.$(TEST_EXT) $(args)
+	$(run_cmd) ./test_thread_monitor.$(TEST_EXT) $(args)
+#TODO:	$(run_cmd) ./test_rml_tbb.$(TEST_EXT) $(args)
+#TODO:	IPC_ENABLE=1 LD_PRELOAD=$(abspath libirml.so.1) $(MAKE) -rf $(tbb_root)/src/Makefile cfg=release tbb_test_release
+
+#------------------------------------------------------
+# End of rules for making the TBBMalloc unit tests
+#------------------------------------------------------
+
+# Include automatically generated dependencies
+-include *.d
+
+clean:
+	-rm -rf *.o *.so* *.d *.def version_string.ver
+	-rm -rf $(work_dir)_release/libirml*
+	-rm -rf $(work_dir)_debug/libirml*
diff --git a/src/tbb/python/rml/ipc_server.cpp b/src/tbb/python/rml/ipc_server.cpp
new file mode 100644
index 00000000..1146a160
--- /dev/null
+++ b/src/tbb/python/rml/ipc_server.cpp
@@ -0,0 +1,1115 @@
+/*
+    Copyright (c) 2017-2020 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 "rml_tbb.h"
+#include "../server/thread_monitor.h"
+#include "tbb/atomic.h"
+#include "tbb/cache_aligned_allocator.h"
+#include "tbb/scheduler_common.h"
+#include "tbb/governor.h"
+#include "tbb/tbb_misc.h"
+
+#include "ipc_utils.h"
+
+#include <fcntl.h>
+
+namespace rml {
+namespace internal {
+
+static const char* IPC_ENABLE_VAR_NAME = "IPC_ENABLE";
+
+typedef versioned_object::version_type version_type;
+
+extern "C" factory::status_type __RML_open_factory(factory& f, version_type& /*server_version*/, version_type /*client_version*/) {
+    if( !tbb::internal::rml::get_enable_flag( IPC_ENABLE_VAR_NAME ) ) {
+        return factory::st_incompatible;
+    }
+
+    // Hack to keep this library from being closed
+    static tbb::atomic<bool> one_time_flag;
+    if( one_time_flag.compare_and_swap(true,false)==false ) {
+        __TBB_ASSERT( (size_t)f.library_handle!=factory::c_dont_unload, NULL );
+#if _WIN32||_WIN64
+        f.library_handle = reinterpret_cast<HMODULE>(factory::c_dont_unload);
+#else
+        f.library_handle = reinterpret_cast<void*>(factory::c_dont_unload);
+#endif
+    }
+    // End of hack
+
+    return factory::st_success;
+}
+
+extern "C" void __RML_close_factory(factory& /*f*/) {
+}
+
+class ipc_thread_monitor : public thread_monitor {
+public:
+    ipc_thread_monitor() : thread_monitor() {}
+
+#if USE_WINTHREAD
+#elif USE_PTHREAD
+    static handle_type launch(thread_routine_type thread_routine, void* arg, size_t stack_size);
+#endif
+};
+
+#if USE_WINTHREAD
+#elif USE_PTHREAD
+inline ipc_thread_monitor::handle_type ipc_thread_monitor::launch(void* (*thread_routine)(void*), void* arg, size_t stack_size) {
+    pthread_attr_t s;
+    if( pthread_attr_init( &s ) ) return 0;
+    if( stack_size>0 ) {
+        if( pthread_attr_setstacksize( &s, stack_size ) ) return 0;
+    }
+    pthread_t handle;
+    if( pthread_create( &handle, &s, thread_routine, arg ) ) return 0;
+    if( pthread_attr_destroy( &s ) ) return 0;
+    return handle;
+}
+#endif
+
+}} //rml::internal
+
+using rml::internal::ipc_thread_monitor;
+
+namespace tbb {
+namespace internal {
+namespace rml {
+
+typedef ipc_thread_monitor::handle_type thread_handle;
+
+class ipc_server;
+
+static const char* IPC_MAX_THREADS_VAR_NAME = "MAX_THREADS";
+static const char* IPC_ACTIVE_SEM_PREFIX = "/__IPC_active";
+static const char* IPC_STOP_SEM_PREFIX = "/__IPC_stop";
+static const char* IPC_ACTIVE_SEM_VAR_NAME = "IPC_ACTIVE_SEMAPHORE";
+static const char* IPC_STOP_SEM_VAR_NAME = "IPC_STOP_SEMAPHORE";
+static const mode_t IPC_SEM_MODE = 0660;
+
+static tbb::atomic<int> my_global_thread_count;
+
+char* get_active_sem_name() {
+    char* value = getenv( IPC_ACTIVE_SEM_VAR_NAME );
+    if( value!=NULL && strlen( value )>0 ) {
+        char* sem_name = new char[strlen( value ) + 1];
+        __TBB_ASSERT( sem_name!=NULL, NULL );
+        strcpy( sem_name, value );
+        return sem_name;
+    } else {
+        return get_shared_name( IPC_ACTIVE_SEM_PREFIX );
+    }
+}
+
+char* get_stop_sem_name() {
+    char* value = getenv( IPC_STOP_SEM_VAR_NAME );
+    if( value!=NULL && strlen( value )>0 ) {
+        char* sem_name = new char[strlen( value ) + 1];
+        __TBB_ASSERT( sem_name!=NULL, NULL );
+        strcpy( sem_name, value );
+        return sem_name;
+    } else {
+        return get_shared_name( IPC_STOP_SEM_PREFIX );
+    }
+}
+
+static void release_thread_sem(sem_t* my_sem) {
+    int old;
+    do {
+        old = my_global_thread_count;
+        if( old<=0 ) return;
+    } while( my_global_thread_count.compare_and_swap(old-1, old)!=old );
+    if( old>0 ) {
+        sem_post( my_sem );
+    }
+}
+
+extern "C" void set_active_sem_name() {
+    char* templ = new char[strlen( IPC_ACTIVE_SEM_PREFIX ) + strlen( "_XXXXXX" ) + 1];
+    __TBB_ASSERT( templ!=NULL, NULL );
+    strcpy( templ, IPC_ACTIVE_SEM_PREFIX );
+    strcpy( templ + strlen( IPC_ACTIVE_SEM_PREFIX ), "_XXXXXX" );
+    char* sem_name = mktemp( templ );
+    if( sem_name!=NULL ) {
+        int status = setenv( IPC_ACTIVE_SEM_VAR_NAME, sem_name, 1 );
+        __TBB_ASSERT_EX( status==0, NULL );
+    }
+    delete[] templ;
+}
+
+extern "C" void set_stop_sem_name() {
+    char* templ = new char[strlen( IPC_STOP_SEM_PREFIX ) + strlen( "_XXXXXX" ) + 1];
+    __TBB_ASSERT( templ!=NULL, NULL );
+    strcpy( templ, IPC_STOP_SEM_PREFIX );
+    strcpy( templ + strlen( IPC_STOP_SEM_PREFIX ), "_XXXXXX" );
+    char* sem_name = mktemp( templ );
+    if( sem_name!=NULL ) {
+        int status = setenv( IPC_STOP_SEM_VAR_NAME, sem_name, 1 );
+        __TBB_ASSERT_EX( status==0, NULL );
+    }
+    delete[] templ;
+}
+
+extern "C" void release_resources() {
+    if( my_global_thread_count!=0 ) {
+        char* active_sem_name = get_active_sem_name();
+        sem_t* my_active_sem = sem_open( active_sem_name, O_CREAT );
+        __TBB_ASSERT( my_active_sem, "Unable to open active threads semaphore" );
+        delete[] active_sem_name;
+
+        do {
+            release_thread_sem( my_active_sem );
+        } while( my_global_thread_count!=0 );
+    }
+}
+
+extern "C" void release_semaphores() {
+    int status = 0;
+    char* sem_name = NULL;
+
+    sem_name = get_active_sem_name();
+    if( sem_name==NULL ) {
+        runtime_warning("Can not get RML semaphore name");
+        return;
+    }
+    status = sem_unlink( sem_name );
+    if( status!=0 ) {
+        if( errno==ENOENT ) {
+            /* There is no semaphore with the given name, nothing to do */
+        } else {
+            runtime_warning("Can not release RML semaphore");
+            return;
+        }
+    }
+    delete[] sem_name;
+
+    sem_name = get_stop_sem_name();
+    if( sem_name==NULL ) {
+        runtime_warning( "Can not get RML semaphore name" );
+        return;
+    }
+    status = sem_unlink( sem_name );
+    if( status!=0 ) {
+        if( errno==ENOENT ) {
+            /* There is no semaphore with the given name, nothing to do */
+        } else {
+            runtime_warning("Can not release RML semaphore");
+            return;
+        }
+    }
+    delete[] sem_name;
+}
+
+class ipc_worker: no_copy {
+protected:
+    //! State in finite-state machine that controls the worker.
+    /** State diagram:
+                    /----------stop---\
+                    |           ^     |
+                    V           |     |
+        init --> starting --> normal  |
+          |         |           |     |
+          |         V           |     |
+          \------> quit <-------/<----/
+      */
+    enum state_t {
+        //! *this is initialized
+        st_init,
+        //! *this has associated thread that is starting up.
+        st_starting,
+        //! Associated thread is doing normal life sequence.
+        st_normal,
+        //! Associated thread is stopped but can be started again.
+        st_stop,
+        //! Associated thread has ended normal life sequence and promises to never touch *this again.
+        st_quit
+    };
+    atomic<state_t> my_state;
+
+    //! Associated server
+    ipc_server& my_server;
+
+    //! Associated client
+    tbb_client& my_client;
+
+    //! index used for avoiding the 64K aliasing problem
+    const size_t my_index;
+
+    //! Monitor for sleeping when there is no work to do.
+    /** The invariant that holds for sleeping workers is:
+        "my_slack<=0 && my_state==st_normal && I am on server's list of asleep threads" */
+    ipc_thread_monitor my_thread_monitor;
+
+    //! Handle of the OS thread associated with this worker
+    thread_handle my_handle;
+
+    //! Link for list of workers that are sleeping or have no associated thread.
+    ipc_worker* my_next;
+
+    friend class ipc_server;
+
+    //! Actions executed by the associated thread
+    void run();
+
+    //! Wake up associated thread (or launch a thread if there is none)
+    bool wake_or_launch();
+
+    //! Called by a thread (usually not the associated thread) to commence termination.
+    void start_shutdown(bool join);
+
+    //! Called by a thread (usually not the associated thread) to commence stopping.
+    void start_stopping(bool join);
+
+    static __RML_DECL_THREAD_ROUTINE thread_routine(void* arg);
+
+    static void release_handle(thread_handle my_handle, bool join);
+
+protected:
+    ipc_worker(ipc_server& server, tbb_client& client, const size_t i) :
+        my_server(server),
+        my_client(client),
+        my_index(i)
+    {
+        my_state = st_init;
+    }
+};
+
+static const size_t cache_line_size = tbb::internal::NFS_MaxLineSize;
+
+#if _MSC_VER && !defined(__INTEL_COMPILER)
+    // Suppress overzealous compiler warnings about uninstantiable class
+    #pragma warning(push)
+    #pragma warning(disable:4510 4610)
+#endif
+class padded_ipc_worker: public ipc_worker {
+    char pad[cache_line_size - sizeof(ipc_worker)%cache_line_size];
+public:
+    padded_ipc_worker(ipc_server& server, tbb_client& client, const size_t i)
+    : ipc_worker( server,client,i ) { suppress_unused_warning(pad); }
+};
+#if _MSC_VER && !defined(__INTEL_COMPILER)
+    #pragma warning(pop)
+#endif
+
+class ipc_waker : public padded_ipc_worker {
+private:
+    static __RML_DECL_THREAD_ROUTINE thread_routine(void* arg);
+    void run();
+    bool wake_or_launch();
+
+    friend class ipc_server;
+
+public:
+    ipc_waker(ipc_server& server, tbb_client& client, const size_t i)
+    : padded_ipc_worker( server, client, i ) {}
+};
+
+class ipc_stopper : public padded_ipc_worker {
+private:
+    static __RML_DECL_THREAD_ROUTINE thread_routine(void* arg);
+    void run();
+    bool wake_or_launch();
+
+    friend class ipc_server;
+
+public:
+    ipc_stopper(ipc_server& server, tbb_client& client, const size_t i)
+    : padded_ipc_worker( server, client, i ) {}
+};
+
+class ipc_server: public tbb_server, no_copy {
+private:
+    tbb_client& my_client;
+    //! Maximum number of threads to be created.
+    /** Threads are created lazily, so maximum might not actually be reached. */
+    tbb_client::size_type my_n_thread;
+
+    //! Stack size for each thread. */
+    const size_t my_stack_size;
+
+    //! Number of jobs that could use their associated thread minus number of active threads.
+    /** If negative, indicates oversubscription.
+        If positive, indicates that more threads should run.
+        Can be lowered asynchronously, but must be raised only while holding my_asleep_list_mutex,
+        because raising it impacts the invariant for sleeping threads. */
+    atomic<int> my_slack;
+
+    //! Counter used to determine when to delete this.
+    atomic<int> my_ref_count;
+
+    padded_ipc_worker* my_thread_array;
+
+    //! List of workers that are asleep or committed to sleeping until notified by another thread.
+    tbb::atomic<ipc_worker*> my_asleep_list_root;
+
+    //! Protects my_asleep_list_root
+    typedef scheduler_mutex_type asleep_list_mutex_type;
+    asleep_list_mutex_type my_asleep_list_mutex;
+
+    //! Should server wait workers while terminate
+    const bool my_join_workers;
+
+    //! Service thread for waking of workers
+    ipc_waker* my_waker;
+
+    //! Service thread to stop threads
+    ipc_stopper* my_stopper;
+
+    //! Semaphore to account active threads
+    sem_t* my_active_sem;
+
+    //! Semaphore to account stop threads
+    sem_t* my_stop_sem;
+
+#if TBB_USE_ASSERT
+    atomic<int> my_net_slack_requests;
+#endif /* TBB_USE_ASSERT */
+
+    //! Wake up to two sleeping workers, if there are any sleeping.
+    /** The call is used to propagate a chain reaction where each thread wakes up two threads,
+        which in turn each wake up two threads, etc. */
+    void propagate_chain_reaction() {
+        // First test of a double-check idiom.  Second test is inside wake_some(0).
+        if( my_slack>0 ) {
+            int active_threads = 0;
+            if( try_get_active_thread() ) {
+                ++active_threads;
+                if( try_get_active_thread() ) {
+                    ++active_threads;
+                }
+                wake_some( 0, active_threads );
+            }
+        }
+    }
+
+    //! Try to add t to list of sleeping workers
+    bool try_insert_in_asleep_list(ipc_worker& t);
+
+    //! Try to add t to list of sleeping workers even if there is some work to do
+    bool try_insert_in_asleep_list_forced(ipc_worker& t);
+
+    //! Equivalent of adding additional_slack to my_slack and waking up to 2 threads if my_slack permits.
+    void wake_some(int additional_slack, int active_threads);
+
+    //! Equivalent of adding additional_slack to my_slack and waking up to 1 thread if my_slack permits.
+    void wake_one_forced(int additional_slack);
+
+    //! Stop one thread from asleep list
+    bool stop_one();
+
+    //! Wait for active thread
+    bool wait_active_thread();
+
+    //! Try to get active thread
+    bool try_get_active_thread();
+
+    //! Release active thread
+    void release_active_thread();
+
+    //! Wait for thread to stop
+    bool wait_stop_thread();
+
+    //! Add thread to stop list
+    void add_stop_thread();
+
+    void remove_server_ref() {
+        if( --my_ref_count==0 ) {
+            my_client.acknowledge_close_connection();
+            this->~ipc_server();
+            tbb::cache_aligned_allocator<ipc_server>().deallocate( this, 1 );
+        }
+    }
+
+    friend class ipc_worker;
+    friend class ipc_waker;
+    friend class ipc_stopper;
+public:
+    ipc_server(tbb_client& client);
+    virtual ~ipc_server();
+
+    version_type version() const __TBB_override {
+        return 0;
+    }
+
+    void request_close_connection(bool /*exiting*/) __TBB_override {
+        my_waker->start_shutdown(false);
+        my_stopper->start_shutdown(false);
+        for( size_t i=0; i<my_n_thread; ++i )
+            my_thread_array[i].start_shutdown( my_join_workers );
+        remove_server_ref();
+    }
+
+    void yield() __TBB_override {__TBB_Yield();}
+
+    void independent_thread_number_changed(int) __TBB_override { __TBB_ASSERT( false, NULL ); }
+
+    unsigned default_concurrency() const __TBB_override { return my_n_thread - 1; }
+
+    void adjust_job_count_estimate(int delta) __TBB_override;
+
+#if _WIN32||_WIN64
+    void register_master(::rml::server::execution_resource_t&) __TBB_override {}
+    void unregister_master(::rml::server::execution_resource_t) __TBB_override {}
+#endif /* _WIN32||_WIN64 */
+};
+
+//------------------------------------------------------------------------
+// Methods of ipc_worker
+//------------------------------------------------------------------------
+#if _MSC_VER && !defined(__INTEL_COMPILER)
+    // Suppress overzealous compiler warnings about an initialized variable 'sink_for_alloca' not referenced
+    #pragma warning(push)
+    #pragma warning(disable:4189)
+#endif
+#if __MINGW32__ && __GNUC__==4 &&__GNUC_MINOR__>=2 && !__MINGW64__
+// ensure that stack is properly aligned
+__attribute__((force_align_arg_pointer))
+#endif
+__RML_DECL_THREAD_ROUTINE ipc_worker::thread_routine(void* arg) {
+    ipc_worker* self = static_cast<ipc_worker*>(arg);
+    AVOID_64K_ALIASING( self->my_index );
+    self->run();
+    return 0;
+}
+#if _MSC_VER && !defined(__INTEL_COMPILER)
+    #pragma warning(pop)
+#endif
+
+void ipc_worker::release_handle(thread_handle handle, bool join) {
+    if( join )
+        ipc_thread_monitor::join( handle );
+    else
+        ipc_thread_monitor::detach_thread( handle );
+}
+
+void ipc_worker::start_shutdown(bool join) {
+    state_t s;
+
+    do {
+        s = my_state;
+        __TBB_ASSERT( s!=st_quit, NULL );
+    } while( my_state.compare_and_swap( st_quit, s )!=s );
+    if( s==st_normal || s==st_starting ) {
+        // May have invalidated invariant for sleeping, so wake up the thread.
+        // Note that the notify() here occurs without maintaining invariants for my_slack.
+        // It does not matter, because my_state==st_quit overrides checking of my_slack.
+        my_thread_monitor.notify();
+        // Do not need release handle in st_init state,
+        // because in this case the thread wasn't started yet.
+        // For st_starting release is done at launch site.
+        if( s==st_normal )
+            release_handle( my_handle, join );
+    }
+}
+
+void ipc_worker::start_stopping(bool join) {
+    state_t s;
+
+    do {
+        s = my_state;
+    } while( my_state.compare_and_swap( st_stop, s )!=s );
+    if( s==st_normal || s==st_starting ) {
+        // May have invalidated invariant for sleeping, so wake up the thread.
+        // Note that the notify() here occurs without maintaining invariants for my_slack.
+        // It does not matter, because my_state==st_quit overrides checking of my_slack.
+        my_thread_monitor.notify();
+        // Do not need release handle in st_init state,
+        // because in this case the thread wasn't started yet.
+        // For st_starting release is done at launch site.
+        if( s==st_normal )
+            release_handle( my_handle, join );
+    }
+}
+
+void ipc_worker::run() {
+    my_server.propagate_chain_reaction();
+
+    // Transiting to st_normal here would require setting my_handle,
+    // which would create race with the launching thread and
+    // complications in handle management on Windows.
+
+    ::rml::job& j = *my_client.create_one_job();
+    state_t state = my_state;
+    while( state!=st_quit && state!=st_stop ) {
+        if( my_server.my_slack>=0 ) {
+            my_client.process(j);
+        } else {
+            ipc_thread_monitor::cookie c;
+            // Prepare to wait
+            my_thread_monitor.prepare_wait(c);
+            // Check/set the invariant for sleeping
+            state = my_state;
+            if( state!=st_quit && state!=st_stop && my_server.try_insert_in_asleep_list(*this) ) {
+                if( my_server.my_n_thread > 1 ) my_server.release_active_thread();
+                my_thread_monitor.commit_wait(c);
+                my_server.propagate_chain_reaction();
+            } else {
+                // Invariant broken
+                my_thread_monitor.cancel_wait();
+            }
+        }
+        state = my_state;
+    }
+    my_client.cleanup(j);
+
+    my_server.remove_server_ref();
+}
+
+inline bool ipc_worker::wake_or_launch() {
+    if( ( my_state==st_init && my_state.compare_and_swap( st_starting, st_init )==st_init ) ||
+        ( my_state==st_stop && my_state.compare_and_swap( st_starting, st_stop )==st_stop ) ) {
+        // after this point, remove_server_ref() must be done by created thread
+#if USE_WINTHREAD
+        my_handle = ipc_thread_monitor::launch( thread_routine, this, my_server.my_stack_size, &this->my_index );
+#elif USE_PTHREAD
+        {
+        affinity_helper fpa;
+        fpa.protect_affinity_mask( /*restore_process_mask=*/true );
+        my_handle = ipc_thread_monitor::launch( thread_routine, this, my_server.my_stack_size );
+        if( my_handle == 0 ) {
+            // Unable to create new thread for process
+            // However, this is expected situation for the use cases of this coordination server
+            state_t s = my_state.compare_and_swap( st_init, st_starting );
+            if (st_starting != s) {
+                // Do shutdown during startup. my_handle can't be released
+                // by start_shutdown, because my_handle value might be not set yet
+                // at time of transition from st_starting to st_quit.
+                __TBB_ASSERT( s==st_quit, NULL );
+                release_handle( my_handle, my_server.my_join_workers );
+            }
+            return false;
+        } else {
+            my_server.my_ref_count++;
+        }
+        // Implicit destruction of fpa resets original affinity mask.
+        }
+#endif /* USE_PTHREAD */
+        state_t s = my_state.compare_and_swap( st_normal, st_starting );
+        if( st_starting!=s ) {
+            // Do shutdown during startup. my_handle can't be released
+            // by start_shutdown, because my_handle value might be not set yet
+            // at time of transition from st_starting to st_quit.
+            __TBB_ASSERT( s==st_quit, NULL );
+            release_handle( my_handle, my_server.my_join_workers );
+        }
+    }
+    else {
+        my_thread_monitor.notify();
+    }
+
+    return true;
+}
+
+//------------------------------------------------------------------------
+// Methods of ipc_waker
+//------------------------------------------------------------------------
+#if _MSC_VER && !defined(__INTEL_COMPILER)
+    // Suppress overzealous compiler warnings about an initialized variable 'sink_for_alloca' not referenced
+    #pragma warning(push)
+    #pragma warning(disable:4189)
+#endif
+#if __MINGW32__ && __GNUC__==4 &&__GNUC_MINOR__>=2 && !__MINGW64__
+// ensure that stack is properly aligned
+__attribute__((force_align_arg_pointer))
+#endif
+__RML_DECL_THREAD_ROUTINE ipc_waker::thread_routine(void* arg) {
+    ipc_waker* self = static_cast<ipc_waker*>(arg);
+    AVOID_64K_ALIASING( self->my_index );
+    self->run();
+    return 0;
+}
+#if _MSC_VER && !defined(__INTEL_COMPILER)
+    #pragma warning(pop)
+#endif
+
+void ipc_waker::run() {
+    // Transiting to st_normal here would require setting my_handle,
+    // which would create race with the launching thread and
+    // complications in handle management on Windows.
+
+    while( my_state!=st_quit ) {
+        bool have_to_sleep = false;
+        if( my_server.my_slack>0 ) {
+            if( my_server.wait_active_thread() ) {
+                if( my_server.my_slack>0 ) {
+                    my_server.wake_some( 0, 1 );
+                } else {
+                    my_server.release_active_thread();
+                    have_to_sleep = true;
+                }
+            }
+        } else {
+            have_to_sleep = true;
+        }
+        if( have_to_sleep ) {
+            ipc_thread_monitor::cookie c;
+            // Prepare to wait
+            my_thread_monitor.prepare_wait(c);
+            // Check/set the invariant for sleeping
+            if( my_state!=st_quit && my_server.my_slack<0 ) {
+                my_thread_monitor.commit_wait(c);
+            } else {
+                // Invariant broken
+                my_thread_monitor.cancel_wait();
+            }
+        }
+    }
+
+    my_server.remove_server_ref();
+}
+
+inline bool ipc_waker::wake_or_launch() {
+    if( my_state==st_init && my_state.compare_and_swap( st_starting, st_init )==st_init ) {
+        // after this point, remove_server_ref() must be done by created thread
+#if USE_WINTHREAD
+        my_handle = ipc_thread_monitor::launch( thread_routine, this, my_server.my_stack_size, &this->my_index );
+#elif USE_PTHREAD
+        {
+        affinity_helper fpa;
+        fpa.protect_affinity_mask( /*restore_process_mask=*/true );
+        my_handle = ipc_thread_monitor::launch( thread_routine, this, my_server.my_stack_size );
+        if( my_handle == 0 ) {
+            runtime_warning( "Unable to create new thread for process %d", getpid() );
+            state_t s = my_state.compare_and_swap( st_init, st_starting );
+            if (st_starting != s) {
+                // Do shutdown during startup. my_handle can't be released
+                // by start_shutdown, because my_handle value might be not set yet
+                // at time of transition from st_starting to st_quit.
+                __TBB_ASSERT( s==st_quit, NULL );
+                release_handle( my_handle, my_server.my_join_workers );
+            }
+            return false;
+        } else {
+            my_server.my_ref_count++;
+        }
+        // Implicit destruction of fpa resets original affinity mask.
+        }
+#endif /* USE_PTHREAD */
+        state_t s = my_state.compare_and_swap( st_normal, st_starting );
+        if( st_starting!=s ) {
+            // Do shutdown during startup. my_handle can't be released
+            // by start_shutdown, because my_handle value might be not set yet
+            // at time of transition from st_starting to st_quit.
+            __TBB_ASSERT( s==st_quit, NULL );
+            release_handle( my_handle, my_server.my_join_workers );
+        }
+    }
+    else {
+        my_thread_monitor.notify();
+    }
+
+    return true;
+}
+
+//------------------------------------------------------------------------
+// Methods of ipc_stopper
+//------------------------------------------------------------------------
+#if _MSC_VER && !defined(__INTEL_COMPILER)
+    // Suppress overzealous compiler warnings about an initialized variable 'sink_for_alloca' not referenced
+    #pragma warning(push)
+    #pragma warning(disable:4189)
+#endif
+#if __MINGW32__ && __GNUC__==4 &&__GNUC_MINOR__>=2 && !__MINGW64__
+// ensure that stack is properly aligned
+__attribute__((force_align_arg_pointer))
+#endif
+__RML_DECL_THREAD_ROUTINE ipc_stopper::thread_routine(void* arg) {
+    ipc_stopper* self = static_cast<ipc_stopper*>(arg);
+    AVOID_64K_ALIASING( self->my_index );
+    self->run();
+    return 0;
+}
+#if _MSC_VER && !defined(__INTEL_COMPILER)
+    #pragma warning(pop)
+#endif
+
+void ipc_stopper::run() {
+    // Transiting to st_normal here would require setting my_handle,
+    // which would create race with the launching thread and
+    // complications in handle management on Windows.
+
+    while( my_state!=st_quit ) {
+        if( my_server.wait_stop_thread() ) {
+            if( my_state!=st_quit ) {
+                if( !my_server.stop_one() ) {
+                    my_server.add_stop_thread();
+                    prolonged_pause();
+                }
+            }
+        }
+    }
+
+    my_server.remove_server_ref();
+}
+
+inline bool ipc_stopper::wake_or_launch() {
+    if( my_state==st_init && my_state.compare_and_swap( st_starting, st_init )==st_init ) {
+        // after this point, remove_server_ref() must be done by created thread
+#if USE_WINTHREAD
+        my_handle = ipc_thread_monitor::launch( thread_routine, this, my_server.my_stack_size, &this->my_index );
+#elif USE_PTHREAD
+        {
+        affinity_helper fpa;
+        fpa.protect_affinity_mask( /*restore_process_mask=*/true );
+        my_handle = ipc_thread_monitor::launch( thread_routine, this, my_server.my_stack_size );
+        if( my_handle == 0 ) {
+            runtime_warning( "Unable to create new thread for process %d", getpid() );
+            state_t s = my_state.compare_and_swap( st_init, st_starting );
+            if (st_starting != s) {
+                // Do shutdown during startup. my_handle can't be released
+                // by start_shutdown, because my_handle value might be not set yet
+                // at time of transition from st_starting to st_quit.
+                __TBB_ASSERT( s==st_quit, NULL );
+                release_handle( my_handle, my_server.my_join_workers );
+            }
+            return false;
+        } else {
+            my_server.my_ref_count++;
+        }
+        // Implicit destruction of fpa resets original affinity mask.
+        }
+#endif /* USE_PTHREAD */
+        state_t s = my_state.compare_and_swap( st_normal, st_starting );
+        if( st_starting!=s ) {
+            // Do shutdown during startup. my_handle can't be released
+            // by start_shutdown, because my_handle value might be not set yet
+            // at time of transition from st_starting to st_quit.
+            __TBB_ASSERT( s==st_quit, NULL );
+            release_handle( my_handle, my_server.my_join_workers );
+        }
+    }
+    else {
+        my_thread_monitor.notify();
+    }
+
+    return true;
+}
+
+//------------------------------------------------------------------------
+// Methods of ipc_server
+//------------------------------------------------------------------------
+ipc_server::ipc_server(tbb_client& client) :
+    my_client( client ),
+    my_stack_size( client.min_stack_size() ),
+    my_thread_array(NULL),
+    my_join_workers(false),
+    my_waker(NULL),
+    my_stopper(NULL)
+{
+    my_ref_count = 1;
+    my_slack = 0;
+#if TBB_USE_ASSERT
+    my_net_slack_requests = 0;
+#endif /* TBB_USE_ASSERT */
+    my_n_thread = get_num_threads(IPC_MAX_THREADS_VAR_NAME);
+    if( my_n_thread==0 ) {
+        my_n_thread = AvailableHwConcurrency();
+        __TBB_ASSERT( my_n_thread>0, NULL );
+    }
+
+    my_asleep_list_root = NULL;
+    my_thread_array = tbb::cache_aligned_allocator<padded_ipc_worker>().allocate( my_n_thread );
+    memset( my_thread_array, 0, sizeof(padded_ipc_worker)*my_n_thread );
+    for( size_t i=0; i<my_n_thread; ++i ) {
+        ipc_worker* t = new( &my_thread_array[i] ) padded_ipc_worker( *this, client, i );
+        t->my_next = my_asleep_list_root;
+        my_asleep_list_root = t;
+    }
+
+    my_waker = tbb::cache_aligned_allocator<ipc_waker>().allocate(1);
+    memset( my_waker, 0, sizeof(ipc_waker) );
+    new( my_waker ) ipc_waker( *this, client, my_n_thread );
+
+    my_stopper = tbb::cache_aligned_allocator<ipc_stopper>().allocate(1);
+    memset( my_stopper, 0, sizeof(ipc_stopper) );
+    new( my_stopper ) ipc_stopper( *this, client, my_n_thread + 1 );
+
+    char* active_sem_name = get_active_sem_name();
+    my_active_sem = sem_open( active_sem_name, O_CREAT, IPC_SEM_MODE, my_n_thread - 1 );
+    __TBB_ASSERT( my_active_sem, "Unable to open active threads semaphore" );
+    delete[] active_sem_name;
+
+    char* stop_sem_name = get_stop_sem_name();
+    my_stop_sem = sem_open( stop_sem_name, O_CREAT, IPC_SEM_MODE, 0 );
+    __TBB_ASSERT( my_stop_sem, "Unable to open stop threads semaphore" );
+    delete[] stop_sem_name;
+}
+
+ipc_server::~ipc_server() {
+    __TBB_ASSERT( my_net_slack_requests==0, NULL );
+
+    for( size_t i=my_n_thread; i--; )
+        my_thread_array[i].~padded_ipc_worker();
+    tbb::cache_aligned_allocator<padded_ipc_worker>().deallocate( my_thread_array, my_n_thread );
+    tbb::internal::poison_pointer( my_thread_array );
+
+    my_waker->~ipc_waker();
+    tbb::cache_aligned_allocator<ipc_waker>().deallocate( my_waker, 1 );
+    tbb::internal::poison_pointer( my_waker );
+
+    my_stopper->~ipc_stopper();
+    tbb::cache_aligned_allocator<ipc_stopper>().deallocate( my_stopper, 1 );
+    tbb::internal::poison_pointer( my_stopper );
+
+    sem_close( my_active_sem );
+    sem_close( my_stop_sem );
+}
+
+inline bool ipc_server::try_insert_in_asleep_list(ipc_worker& t) {
+    asleep_list_mutex_type::scoped_lock lock;
+    if( !lock.try_acquire( my_asleep_list_mutex ) )
+        return false;
+    // Contribute to slack under lock so that if another takes that unit of slack,
+    // it sees us sleeping on the list and wakes us up.
+    int k = ++my_slack;
+    if( k<=0 ) {
+        t.my_next = my_asleep_list_root;
+        my_asleep_list_root = &t;
+        return true;
+    } else {
+        --my_slack;
+        return false;
+    }
+}
+
+inline bool ipc_server::try_insert_in_asleep_list_forced(ipc_worker& t) {
+    asleep_list_mutex_type::scoped_lock lock;
+    if( !lock.try_acquire( my_asleep_list_mutex ) )
+        return false;
+    // Contribute to slack under lock so that if another takes that unit of slack,
+    // it sees us sleeping on the list and wakes us up.
+    ++my_slack;
+    t.my_next = my_asleep_list_root;
+    my_asleep_list_root = &t;
+    return true;
+}
+
+inline bool ipc_server::wait_active_thread() {
+    if( sem_wait( my_active_sem ) == 0 ) {
+        ++my_global_thread_count;
+        return true;
+    }
+    return false;
+}
+
+inline bool ipc_server::try_get_active_thread() {
+    if( sem_trywait( my_active_sem ) == 0 ) {
+        ++my_global_thread_count;
+        return true;
+    }
+    return false;
+}
+
+inline void ipc_server::release_active_thread() {
+    release_thread_sem( my_active_sem );
+}
+
+inline bool ipc_server::wait_stop_thread() {
+    struct timespec ts;
+    if( clock_gettime( CLOCK_REALTIME, &ts )==0 ) {
+        ts.tv_sec++;
+        if( sem_timedwait( my_stop_sem, &ts )==0 ) {
+            return true;
+        }
+    }
+    return false;
+}
+
+inline void ipc_server::add_stop_thread() {
+    sem_post( my_stop_sem );
+}
+
+void ipc_server::wake_some( int additional_slack, int active_threads ) {
+    __TBB_ASSERT( additional_slack>=0, NULL );
+    ipc_worker* wakee[2];
+    ipc_worker **w = wakee;
+    {
+        asleep_list_mutex_type::scoped_lock lock(my_asleep_list_mutex);
+        while( active_threads>0 && my_asleep_list_root && w<wakee+2 ) {
+            if( additional_slack>0 ) {
+                if( additional_slack+my_slack<=0 ) // additional demand does not exceed surplus supply
+                    break;
+                --additional_slack;
+            } else {
+                // Chain reaction; Try to claim unit of slack
+                int old;
+                do {
+                    old = my_slack;
+                    if( old<=0 ) goto done;
+                } while( my_slack.compare_and_swap( old-1, old )!=old );
+            }
+            // Pop sleeping worker to combine with claimed unit of slack
+            my_asleep_list_root = (*w++ = my_asleep_list_root)->my_next;
+            --active_threads;
+        }
+        if( additional_slack ) {
+            // Contribute our unused slack to my_slack.
+            my_slack += additional_slack;
+        }
+    }
+done:
+    while( w>wakee ) {
+        if( !(*--w)->wake_or_launch() ) {
+            add_stop_thread();
+            do {
+            } while( !try_insert_in_asleep_list_forced(**w) );
+            release_active_thread();
+        }
+    }
+    while( active_threads ) {
+        release_active_thread();
+        --active_threads;
+    }
+}
+
+void ipc_server::wake_one_forced( int additional_slack ) {
+    __TBB_ASSERT( additional_slack>=0, NULL );
+    ipc_worker* wakee[1];
+    ipc_worker **w = wakee;
+    {
+        asleep_list_mutex_type::scoped_lock lock(my_asleep_list_mutex);
+        while( my_asleep_list_root && w<wakee+1 ) {
+            if( additional_slack>0 ) {
+                if( additional_slack+my_slack<=0 ) // additional demand does not exceed surplus supply
+                    break;
+                --additional_slack;
+            } else {
+                // Chain reaction; Try to claim unit of slack
+                int old;
+                do {
+                    old = my_slack;
+                    if( old<=0 ) goto done;
+                } while( my_slack.compare_and_swap( old-1, old )!=old );
+            }
+            // Pop sleeping worker to combine with claimed unit of slack
+            my_asleep_list_root = (*w++ = my_asleep_list_root)->my_next;
+        }
+        if( additional_slack ) {
+            // Contribute our unused slack to my_slack.
+            my_slack += additional_slack;
+        }
+    }
+done:
+    while( w>wakee ) {
+        if( !(*--w)->wake_or_launch() ) {
+            add_stop_thread();
+            do {
+            } while( !try_insert_in_asleep_list_forced(**w) );
+        }
+    }
+}
+
+bool ipc_server::stop_one() {
+    ipc_worker* current = NULL;
+    ipc_worker* next = NULL;
+    {
+        asleep_list_mutex_type::scoped_lock lock(my_asleep_list_mutex);
+        if( my_asleep_list_root ) {
+            current = my_asleep_list_root;
+            if( current->my_state==ipc_worker::st_normal ) {
+                next = current->my_next;
+                while( next!= NULL && next->my_state==ipc_worker::st_normal ) {
+                    current = next;
+                    next = current->my_next;
+                }
+                current->start_stopping( my_join_workers );
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+void ipc_server::adjust_job_count_estimate( int delta ) {
+#if TBB_USE_ASSERT
+    my_net_slack_requests+=delta;
+#endif /* TBB_USE_ASSERT */
+    if( my_n_thread > 1 ) {
+        if( delta<0 ) {
+            my_slack+=delta;
+        } else if( delta>0 ) {
+            int active_threads = 0;
+            if( try_get_active_thread() ) {
+                ++active_threads;
+                if( try_get_active_thread() ) {
+                    ++active_threads;
+                }
+            }
+            wake_some( delta, active_threads );
+
+            if( !my_waker->wake_or_launch() ) {
+                add_stop_thread();
+            }
+            if( !my_stopper->wake_or_launch() ) {
+                add_stop_thread();
+            }
+        }
+    } else { // Corner case when RML shouldn't provide any worker thread but client has to have at least one
+        if( delta<0 ) {
+            my_slack += delta;
+        } else {
+            wake_one_forced( delta );
+        }
+    }
+}
+
+//------------------------------------------------------------------------
+// RML factory methods
+//------------------------------------------------------------------------
+
+#if USE_PTHREAD
+
+static tbb_client* my_global_client = NULL;
+static tbb_server* my_global_server = NULL;
+
+void rml_atexit() {
+    release_resources();
+}
+
+void rml_atfork_child() {
+    if( my_global_server!=NULL && my_global_client!=NULL ) {
+        ipc_server* server = static_cast<ipc_server*>( my_global_server );
+        server->~ipc_server();
+        memset( server, 0, sizeof(ipc_server) );
+        new( server ) ipc_server( *my_global_client );
+        pthread_atfork( NULL, NULL, rml_atfork_child );
+        atexit( rml_atexit );
+    }
+}
+
+#endif /* USE_PTHREAD */
+
+extern "C" tbb_factory::status_type __TBB_make_rml_server(tbb_factory& /*f*/, tbb_server*& server, tbb_client& client) {
+    server = new( tbb::cache_aligned_allocator<ipc_server>().allocate(1) ) ipc_server(client);
+#if USE_PTHREAD
+    my_global_client = &client;
+    my_global_server = server;
+    pthread_atfork( NULL, NULL, rml_atfork_child );
+    atexit( rml_atexit );
+#endif /* USE_PTHREAD */
+    if( getenv( "RML_DEBUG" ) ) {
+        runtime_warning("IPC server is started");
+    }
+    return tbb_factory::st_success;
+}
+
+extern "C" void __TBB_call_with_my_server_info(::rml::server_info_callback_t /*cb*/, void* /*arg*/) {
+}
+
+} // namespace rml
+} // namespace internal
+
+} // namespace tbb
diff --git a/src/tbb/python/rml/ipc_utils.cpp b/src/tbb/python/rml/ipc_utils.cpp
new file mode 100644
index 00000000..8bb5e160
--- /dev/null
+++ b/src/tbb/python/rml/ipc_utils.cpp
@@ -0,0 +1,140 @@
+/*
+    Copyright (c) 2017-2020 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 "ipc_utils.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <limits.h>
+#include <string.h>
+#include <unistd.h>
+
+namespace tbb {
+namespace internal {
+namespace rml {
+
+#define MAX_STR_LEN 255
+#define STARTTIME_ITEM_ID 21
+
+static char* get_stat_item(char* line, int item_id) {
+    int id = 0, i = 0;
+
+    while( id!=item_id ) {
+        while( line[i]!='(' && line[i]!=' ' && line[i]!='\0' ) {
+            ++i;
+        }
+        if( line[i]==' ' ) {
+            ++id;
+            ++i;
+        } else if( line[i]=='(' ) {
+            while( line[i]!=')' && line[i]!='\0' ) {
+               ++i;
+            }
+            if( line[i]==')' ) {
+                ++i;
+            } else {
+                return NULL;
+            }
+        } else {
+            return NULL;
+        }
+    }
+
+    return line + i;
+}
+
+unsigned long long get_start_time(int pid) {
+    const char* stat_file_path_template = "/proc/%d/stat";
+    char stat_file_path[MAX_STR_LEN + 1];
+    sprintf( stat_file_path, stat_file_path_template, pid );
+
+    FILE* stat_file = fopen( stat_file_path, "rt" );
+    if( stat_file==NULL ) {
+        return 0;
+    }
+
+    char stat_line[MAX_STR_LEN + 1];
+    char* line = fgets( stat_line, MAX_STR_LEN, stat_file );
+    if( line==NULL ) {
+        return 0;
+    }
+
+    char* starttime_str = get_stat_item( stat_line, STARTTIME_ITEM_ID );
+    if( starttime_str==NULL ) {
+        return 0;
+    }
+
+    unsigned long long starttime = strtoull( starttime_str, NULL, 10 );
+    if( starttime==ULLONG_MAX ) {
+        return 0;
+    }
+
+    return starttime;
+}
+
+char* get_shared_name(const char* prefix, int pid, unsigned long long time) {
+    const char* name_template = "%s_%d_%llu";
+    const int digits_in_int = 10;
+    const int digits_in_long = 20;
+
+    int len = strlen( name_template ) + strlen( prefix ) + digits_in_int + digits_in_long + 1;
+    char* name = new char[len];
+    sprintf( name, name_template, prefix, pid, time );
+
+    return name;
+}
+
+char* get_shared_name(const char* prefix) {
+    int pid = getpgrp();
+    unsigned long long time = get_start_time( pid );
+    return get_shared_name( prefix, pid, time );
+}
+
+int get_num_threads(const char* env_var) {
+    if( env_var==NULL ) {
+        return 0;
+    }
+
+    char* value = getenv( env_var );
+    if( value==NULL ) {
+        return 0;
+    }
+
+    int num_threads = (int)strtol( value, NULL, 10 );
+    return num_threads;
+}
+
+bool get_enable_flag(const char* env_var) {
+    if( env_var==NULL ) {
+        return false;
+    }
+
+    char* value = getenv( env_var );
+    if( value==NULL ) {
+        return false;
+    }
+
+    if( strcmp( value, "0" ) == 0 ||
+        strcmp( value, "false" ) == 0 ||
+        strcmp( value, "False" ) == 0 ||
+        strcmp( value, "FALSE" ) == 0 ) {
+        return false;
+    }
+
+    return true;
+}
+
+}}} //tbb::internal::rml
diff --git a/src/tbb/python/rml/ipc_utils.h b/src/tbb/python/rml/ipc_utils.h
new file mode 100644
index 00000000..171c89bc
--- /dev/null
+++ b/src/tbb/python/rml/ipc_utils.h
@@ -0,0 +1,30 @@
+/*
+    Copyright (c) 2017-2020 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.
+*/
+
+#ifndef __IPC_UTILS_H
+#define __IPC_UTILS_H
+
+namespace tbb {
+namespace internal {
+namespace rml {
+
+char* get_shared_name(const char* prefix);
+int get_num_threads(const char* env_var);
+bool get_enable_flag(const char* env_var);
+
+}}} //tbb::internal::rml
+
+#endif
diff --git a/src/tbb/python/setup.py b/src/tbb/python/setup.py
new file mode 100644
index 00000000..8e93355c
--- /dev/null
+++ b/src/tbb/python/setup.py
@@ -0,0 +1,120 @@
+#!/usr/bin/env python
+#
+# Copyright (c) 2016-2020 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.
+
+
+# System imports
+from __future__ import print_function
+from glob import glob
+import platform
+import os
+
+from distutils.core import *
+from distutils.command.build import build
+
+rundir = os.getcwd()
+os.chdir(os.path.abspath(os.path.dirname(__file__)))
+
+if any(i in os.environ for i in ["CC", "CXX"]):
+    if "CC" not in os.environ:
+        os.environ['CC'] = os.environ['CXX']
+    if "CXX" not in os.environ:
+        os.environ['CXX'] = os.environ['CC']
+    if platform.system() == 'Linux':
+        os.environ['LDSHARED'] = os.environ['CXX'] + " -shared"
+    print("Environment specifies CC=%s CXX=%s"%(os.environ['CC'], os.environ['CXX']))
+
+intel_compiler = os.getenv('CC', '') in ['icl', 'icpc', 'icc']
+try:
+    tbb_root = os.environ['TBBROOT']
+    print("Using TBBROOT=", tbb_root)
+except:
+    tbb_root = '..'
+    if not intel_compiler:
+        print("Warning: TBBROOT env var is not set and Intel's compiler is not used. It might lead\n"
+              "    !!!: to compile/link problems. Source tbbvars.sh/.csh file to set environment")
+use_compiler_tbb = intel_compiler and tbb_root == '..'
+if use_compiler_tbb:
+    print("Using Intel TBB from Intel's compiler")
+if platform.system() == 'Windows':
+    if intel_compiler:
+        os.environ['DISTUTILS_USE_SDK'] = '1'  # Enable environment settings in distutils
+        os.environ['MSSdk'] = '1'
+        print("Using compiler settings from environment")
+    tbb_flag = ['/Qtbb'] if use_compiler_tbb else []
+    tbb_flag += ['/EHsc'] # for Python 2
+    compile_flags = ['/Qstd=c++11'] if intel_compiler else []
+else:
+    tbb_flag = ['-tbb'] if use_compiler_tbb else []
+    compile_flags = ['-std=c++11', '-Wno-unused-variable']
+
+_tbb = Extension("tbb._api", ["tbb/api.i"],
+        include_dirs=[os.path.join(tbb_root, 'include')] if not use_compiler_tbb else [],
+        swig_opts   =['-c++', '-O', '-threads'] + (  # add '-builtin' later
+              ['-I' + os.path.join(tbb_root, 'include')] if not use_compiler_tbb else []),
+        extra_compile_args=compile_flags + tbb_flag,
+        extra_link_args=tbb_flag,
+        libraries   =(['tbb'] if not use_compiler_tbb else []) +
+                     (['irml'] if platform.system() == "Linux" else []),   # TODO: why do we need this?
+        library_dirs=[ rundir,                                              # for custom-builds
+                       os.path.join(tbb_root, 'lib', 'intel64', 'gcc4.8'),  # for Linux
+                       os.path.join(tbb_root, 'lib'),                       # for MacOS
+                       os.path.join(tbb_root, 'lib', 'intel64', 'vc_mt'),   # for Windows
+                     ] if not use_compiler_tbb else [],
+        language    ='c++',
+        )
+
+
+class TBBBuild(build):
+    sub_commands = [  # define build order
+        ('build_ext', build.has_ext_modules),
+        ('build_py', build.has_pure_modules),
+    ]
+
+
+setup(  name        ="TBB",
+        description ="Python API for Intel TBB",
+        long_description="Python API to Intel(R) Threading Building Blocks library (Intel(R) TBB) "
+                         "extended with standard Pool implementation and monkey-patching",
+        url         ="https://software.intel.com/en-us/intel-tbb",
+        author      ="Intel Corporation",
+        author_email="inteltbbdevelopers@intel.com",
+        license     ="Dual license: Apache or Proprietary",
+        version     ="0.1",
+        classifiers =[
+            'Development Status :: 4 - Beta',
+            'Environment :: Console',
+            'Environment :: Plugins',
+            'Intended Audience :: Developers',
+            'Intended Audience :: System Administrators',
+            'Intended Audience :: Other Audience',
+            'Intended Audience :: Science/Research',
+            'License :: OSI Approved :: Apache Software License',
+            'Operating System :: MacOS :: MacOS X',
+            'Operating System :: Microsoft :: Windows',
+            'Operating System :: POSIX :: Linux',
+            'Programming Language :: Python',
+            'Programming Language :: Python :: 2',
+            'Programming Language :: Python :: 3',
+            'Programming Language :: C++',
+            'Topic :: System :: Hardware :: Symmetric Multi-processing',
+            'Topic :: Software Development :: Libraries',
+          ],
+        keywords='TBB multiprocessing multithreading composable parallelism',
+        ext_modules=[_tbb],
+        packages=['tbb'],
+        py_modules=['TBB'],
+        cmdclass={'build': TBBBuild}
+)
diff --git a/src/tbb/python/tbb/__init__.py b/src/tbb/python/tbb/__init__.py
new file mode 100644
index 00000000..508ad1ef
--- /dev/null
+++ b/src/tbb/python/tbb/__init__.py
@@ -0,0 +1,325 @@
+#!/usr/bin/env python
+#
+# Copyright (c) 2016-2020 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.
+
+
+from __future__ import print_function
+
+import multiprocessing.pool
+import ctypes
+import atexit
+import sys
+import os
+ 
+from .api import  *
+from .api import __all__ as api__all
+from .pool import *
+from .pool import __all__ as pool__all
+
+__all__ = ["Monkey", "is_active"] + api__all + pool__all
+
+__doc__ = """
+Python API for Intel(R) Threading Building Blocks (Intel(R) TBB)
+extended with standard Python's pools implementation and monkey-patching.
+
+Command-line interface example:
+$  python -m tbb $your_script.py
+Runs your_script.py in context of tbb.Monkey
+"""
+
+is_active = False
+""" Indicates whether TBB context is activated """
+
+ipc_enabled = False
+""" Indicates whether IPC mode is enabled """
+
+libirml = "libirml.so.1"
+
+
+def _test(arg=None):
+    """Some tests"""
+    import platform
+    if platform.system() == "Linux":
+        ctypes.CDLL(libirml)
+        assert 256 == os.system("ldd "+_api.__file__+"| grep -E 'libimf|libsvml|libintlc'")
+    from .test import test
+    test(arg)
+    print("done")
+
+
+def tbb_process_pool_worker27(inqueue, outqueue, initializer=None, initargs=(),
+                            maxtasks=None):
+    from multiprocessing.pool import worker
+    worker(inqueue, outqueue, initializer, initargs, maxtasks)
+    if ipc_enabled:
+        try:
+            librml = ctypes.CDLL(libirml)
+            librml.release_resources()
+        except:
+            print("Warning: Can not load ", libirml, file=sys.stderr)
+
+
+class TBBProcessPool27(multiprocessing.pool.Pool):
+    def _repopulate_pool(self):
+        """Bring the number of pool processes up to the specified number,
+        for use after reaping workers which have exited.
+        """
+        from multiprocessing.util import debug
+
+        for i in range(self._processes - len(self._pool)):
+            w = self.Process(target=tbb_process_pool_worker27,
+                             args=(self._inqueue, self._outqueue,
+                                   self._initializer,
+                                   self._initargs, self._maxtasksperchild)
+                            )
+            self._pool.append(w)
+            w.name = w.name.replace('Process', 'PoolWorker')
+            w.daemon = True
+            w.start()
+            debug('added worker')
+
+    def __del__(self):
+        self.close()
+        for p in self._pool:
+            p.join()
+
+    def __exit__(self, *args):
+        self.close()
+        for p in self._pool:
+            p.join()
+
+
+def tbb_process_pool_worker3(inqueue, outqueue, initializer=None, initargs=(),
+                            maxtasks=None, wrap_exception=False):
+    from multiprocessing.pool import worker
+    worker(inqueue, outqueue, initializer, initargs, maxtasks, wrap_exception)
+    if ipc_enabled:
+        try:
+            librml = ctypes.CDLL(libirml)
+            librml.release_resources()
+        except:
+            print("Warning: Can not load ", libirml, file=sys.stderr)
+
+
+class TBBProcessPool3(multiprocessing.pool.Pool):
+    def _repopulate_pool(self):
+        """Bring the number of pool processes up to the specified number,
+        for use after reaping workers which have exited.
+        """
+        from multiprocessing.util import debug
+
+        for i in range(self._processes - len(self._pool)):
+            w = self.Process(target=tbb_process_pool_worker3,
+                             args=(self._inqueue, self._outqueue,
+                                   self._initializer,
+                                   self._initargs, self._maxtasksperchild,
+                                   self._wrap_exception)
+                            )
+            self._pool.append(w)
+            w.name = w.name.replace('Process', 'PoolWorker')
+            w.daemon = True
+            w.start()
+            debug('added worker')
+
+    def __del__(self):
+        self.close()
+        for p in self._pool:
+            p.join()
+
+    def __exit__(self, *args):
+        self.close()
+        for p in self._pool:
+            p.join()
+
+
+class Monkey:
+    """
+    Context manager which replaces standard multiprocessing.pool
+    implementations with tbb.pool using monkey-patching. It also enables TBB
+    threading for Intel(R) Math Kernel Library (Intel(R) MKL). For example:
+
+        with tbb.Monkey():
+            run_my_numpy_code()
+
+    It allows multiple parallel tasks to be executed on the same thread pool
+    and coordinate number of threads across multiple processes thus avoiding
+    overheads from oversubscription.
+    """
+    _items   = {}
+    _modules = {}
+
+    def __init__(self, max_num_threads=None, benchmark=False):
+        """
+        Create context manager for running under TBB scheduler.
+        :param max_num_threads: if specified, limits maximal number of threads
+        :param benchmark: if specified, blocks in initialization until requested number of threads are ready
+        """
+        if max_num_threads:
+            self.ctl = global_control(global_control.max_allowed_parallelism, int(max_num_threads))
+        if benchmark:
+            if not max_num_threads:
+               max_num_threads = default_num_threads()
+            from .api import _concurrency_barrier
+            _concurrency_barrier(int(max_num_threads))
+
+    def _patch(self, class_name, module_name, obj):
+        m = self._modules[class_name] = __import__(module_name, globals(),
+                                                   locals(), [class_name])
+        if m == None:
+            return
+        oldattr = getattr(m, class_name, None)
+        if oldattr == None:
+            self._modules[class_name] = None
+            return
+        self._items[class_name] = oldattr
+        setattr(m, class_name, obj)
+
+    def __enter__(self):
+        global is_active
+        assert is_active == False, "tbb.Monkey does not support nesting yet"
+        is_active = True
+        self.env_mkl = os.getenv('MKL_THREADING_LAYER')
+        os.environ['MKL_THREADING_LAYER'] = 'TBB'
+        self.env_numba = os.getenv('NUMBA_THREADING_LAYER')
+        os.environ['NUMBA_THREADING_LAYER'] = 'TBB'
+
+        if ipc_enabled:
+            if sys.version_info.major == 2 and sys.version_info.minor >= 7:
+                self._patch("Pool", "multiprocessing.pool", TBBProcessPool27)
+            elif sys.version_info.major == 3 and sys.version_info.minor >= 5:
+                self._patch("Pool", "multiprocessing.pool", TBBProcessPool3)
+        self._patch("ThreadPool", "multiprocessing.pool", Pool)
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        global is_active
+        assert is_active == True, "modified?"
+        is_active = False
+        if self.env_mkl is None:
+            del os.environ['MKL_THREADING_LAYER']
+        else:
+            os.environ['MKL_THREADING_LAYER'] = self.env_mkl
+        if self.env_numba is None:
+            del os.environ['NUMBA_THREADING_LAYER']
+        else:
+            os.environ['NUMBA_THREADING_LAYER'] = self.env_numba
+        for name in self._items.keys():
+            setattr(self._modules[name], name, self._items[name])
+
+
+def init_sem_name():
+    try:
+        librml = ctypes.CDLL(libirml)
+        librml.set_active_sem_name()
+        librml.set_stop_sem_name()
+    except Exception as e:
+        print("Warning: Can not initialize name of shared semaphores:", e,
+              file=sys.stderr)
+
+
+def tbb_atexit():
+    if ipc_enabled:
+        try:
+            librml = ctypes.CDLL(libirml)
+            librml.release_semaphores()
+        except:
+            print("Warning: Can not release shared semaphores",
+                  file=sys.stderr)
+
+
+def _main():
+    # Run the module specified as the next command line argument
+    # python -m TBB user_app.py
+    global ipc_enabled
+
+    import platform
+    import argparse
+    parser = argparse.ArgumentParser(prog="python -m tbb", description="""
+                Run your Python script in context of tbb.Monkey, which
+                replaces standard Python pools and threading layer of
+                Intel(R) Math Kernel Library by implementation based on
+                Intel(R) Threading Building Blocks. It enables multiple parallel
+                tasks to be executed on the same thread pool and coordinate
+                number of threads across multiple processes thus avoiding
+                overheads from oversubscription.
+             """, formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+    if platform.system() == "Linux":
+        parser.add_argument('--ipc', action='store_true',
+                        help="Enable inter-process (IPC) coordination between Intel TBB schedulers")
+        parser.add_argument('-a', '--allocator', action='store_true',
+                        help="Enable Intel TBB scalable allocator as a replacement for standard memory allocator")
+        parser.add_argument('--allocator-huge-pages', action='store_true',
+                        help="Enable huge pages for Intel TBB allocator (implies: -a)")
+    parser.add_argument('-p', '--max-num-threads', default=default_num_threads(), type=int,
+                        help="Initialize Intel TBB with P max number of threads per process", metavar='P')
+    parser.add_argument('-b', '--benchmark', action='store_true',
+                        help="Block Intel TBB initialization until all the threads are created before continue the script. "
+                        "This is necessary for performance benchmarks that want to exclude lazy scheduler initialization effects from the measurements")
+    parser.add_argument('-v', '--verbose', action='store_true',
+                        help="Request verbose and version information")
+    parser.add_argument('-m', action='store_true', dest='module',
+                        help="Executes following as a module")
+    parser.add_argument('name', help="Script or module name")
+    parser.add_argument('args', nargs=argparse.REMAINDER,
+                        help="Command line arguments")
+    args = parser.parse_args()
+
+    if args.verbose:
+        os.environ["TBB_VERSION"] = "1"
+    if platform.system() == "Linux":
+        if args.allocator_huge_pages:
+            args.allocator = True
+        if args.allocator and not os.environ.get("_TBB_MALLOC_PRELOAD"):
+            libtbbmalloc_lib = 'libtbbmalloc_proxy.so.2'
+            ld_preload = 'LD_PRELOAD'
+            os.environ["_TBB_MALLOC_PRELOAD"] = "1"
+            preload_list = filter(None, os.environ.get(ld_preload, "").split(':'))
+            if libtbbmalloc_lib in preload_list:
+                print('Info:', ld_preload, "contains", libtbbmalloc_lib, "already\n")
+            else:
+                os.environ[ld_preload] = ':'.join([libtbbmalloc_lib] + list(preload_list))
+
+            if args.allocator_huge_pages:
+                assert platform.system() == "Linux"
+                try:
+                    with open('/proc/sys/vm/nr_hugepages', 'r') as f:
+                        pages = int(f.read())
+                    if pages == 0:
+                        print("TBB: Pre-allocated huge pages are not currently reserved in the system. To reserve, run e.g.:\n"
+                              "\tsudo sh -c 'echo 2000 > /proc/sys/vm/nr_hugepages'")
+                    os.environ["TBB_MALLOC_USE_HUGE_PAGES"] = "1"
+                except:
+                    print("TBB: Failed to read number of pages from /proc/sys/vm/nr_hugepages\n"
+                          "\tIs the Linux kernel configured with the huge pages feature?")
+                    sys.exit(1)
+
+            os.execl(sys.executable, sys.executable, '-m', 'tbb', *sys.argv[1:])
+            assert False, "Re-execution failed"
+
+    sys.argv = [args.name] + args.args
+    ipc_enabled = platform.system() == "Linux" and args.ipc
+    os.environ["IPC_ENABLE"] = "1" if ipc_enabled else "0"
+    if ipc_enabled:
+        atexit.register(tbb_atexit)
+        init_sem_name()
+    if not os.environ.get("KMP_BLOCKTIME"): # TODO move
+        os.environ["KMP_BLOCKTIME"] = "0"
+    if '_' + args.name in globals():
+        return globals()['_' + args.name](*args.args)
+    else:
+        import runpy
+        runf = runpy.run_module if args.module else runpy.run_path
+        with Monkey(max_num_threads=args.max_num_threads, benchmark=args.benchmark):
+            runf(args.name, run_name='__main__')
diff --git a/src/tbb/python/tbb/__main__.py b/src/tbb/python/tbb/__main__.py
new file mode 100644
index 00000000..34873625
--- /dev/null
+++ b/src/tbb/python/tbb/__main__.py
@@ -0,0 +1,20 @@
+#!/usr/bin/env python
+#
+# Copyright (c) 2016-2020 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.
+
+
+from . import _main
+from sys import exit
+exit(_main())
diff --git a/src/tbb/python/tbb/api.i b/src/tbb/python/tbb/api.i
new file mode 100644
index 00000000..7a07eb3c
--- /dev/null
+++ b/src/tbb/python/tbb/api.i
@@ -0,0 +1,175 @@
+%pythonbegin %{
+#
+# Copyright (c) 2016-2020 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.
+
+
+__all__ = ["task_arena", "task_group", "task_scheduler_init", "global_control", "default_num_threads"]
+%}
+%begin %{
+/* Defines Python wrappers for Intel(R) Threading Building Blocks (Intel TBB).*/
+%}
+%module api
+
+#if SWIG_VERSION < 0x030001
+#error SWIG version 3.0.6 or newer is required for correct functioning
+#endif
+
+%{
+#define TBB_PREVIEW_WAITING_FOR_WORKERS 1
+#include <tbb/tbb.h>
+#include <tbb/compat/condition_variable>
+#if TBB_IMPLEMENT_CPP0X
+namespace std { using tbb::mutex; }
+#define unique_ptr auto_ptr
+#else
+#include <condition_variable>
+#include <mutex>
+#include <memory>
+#endif
+using namespace tbb;
+
+class PyCaller : public swig::SwigPtr_PyObject {
+public:
+    // icpc 2013 does not support simple using SwigPtr_PyObject::SwigPtr_PyObject;
+    PyCaller(const PyCaller& s) : SwigPtr_PyObject(s) {}
+    PyCaller(PyObject *p, bool initial = true) : SwigPtr_PyObject(p, initial) {}
+
+    void operator()() const {
+        SWIG_PYTHON_THREAD_BEGIN_BLOCK;
+        PyObject* r = PyObject_CallFunctionObjArgs((PyObject*)*this, NULL);
+        if(r) Py_DECREF(r);
+        SWIG_PYTHON_THREAD_END_BLOCK;
+    }
+};
+
+struct ArenaPyCaller {
+    task_arena *my_arena;
+    PyObject *my_callable;
+    ArenaPyCaller(task_arena *a, PyObject *c) : my_arena(a), my_callable(c) {
+        SWIG_PYTHON_THREAD_BEGIN_BLOCK;
+        Py_XINCREF(c);
+        SWIG_PYTHON_THREAD_END_BLOCK;
+    }
+    void operator()() const {
+        my_arena->execute(PyCaller(my_callable, false));
+    }
+};
+
+struct barrier_data {
+    std::condition_variable event;
+    std::mutex m;
+    int worker_threads, full_threads;
+};
+
+class barrier_task : public tbb::task {
+    barrier_data &b;
+public:
+    barrier_task(barrier_data &d) : b(d) {}
+    /*override*/ tbb::task *execute() {
+        std::unique_lock<std::mutex> lock(b.m);
+        if(++b.worker_threads >= b.full_threads)
+            b.event.notify_all();
+        else while(b.worker_threads < b.full_threads)
+            b.event.wait(lock);
+        return NULL;
+    }
+};
+
+void _concurrency_barrier(int threads = tbb::task_scheduler_init::automatic) {
+    if(threads == task_scheduler_init::automatic)
+        threads = task_scheduler_init::default_num_threads();
+    if(threads < 2)
+        return;
+    std::unique_ptr<global_control> g(
+        (global_control::active_value(global_control::max_allowed_parallelism) < unsigned(threads))?
+            new global_control(global_control::max_allowed_parallelism, threads) : NULL);
+    barrier_data b;
+    b.worker_threads = 0;
+    b.full_threads = threads-1;
+    for(int i = 0; i < b.full_threads; i++)
+        tbb::task::enqueue( *new( tbb::task::allocate_root() ) barrier_task(b) );
+    std::unique_lock<std::mutex> lock(b.m);
+    b.event.wait(lock);
+};
+
+%}
+
+void _concurrency_barrier(int threads = tbb::task_scheduler_init::automatic);
+
+namespace tbb {
+    class task_scheduler_init {
+    public:
+        //! Typedef for number of threads that is automatic.
+        static const int automatic = -1;
+        //! Argument to initialize() or constructor that causes initialization to be deferred.
+        static const int deferred = -2;
+        task_scheduler_init( int max_threads=automatic,
+                             size_t thread_stack_size=0 );
+        ~task_scheduler_init();
+        void initialize( int max_threads=automatic );
+        void terminate();
+        static int default_num_threads();
+        bool is_active() const;
+        void blocking_terminate();
+    };
+
+    class task_arena {
+    public:
+        static const int automatic = -1;
+        static int current_thread_index();
+        task_arena(int max_concurrency = automatic, unsigned reserved_for_masters = 1);
+        task_arena(const task_arena &s);
+        ~task_arena();
+        void initialize();
+        void initialize(int max_concurrency, unsigned reserved_for_masters = 1);
+        void terminate();
+        bool is_active();
+        %extend {
+        void enqueue( PyObject *c ) { $self->enqueue(PyCaller(c)); }
+        void execute( PyObject *c ) { $self->execute(PyCaller(c)); }
+        };
+    };
+
+    class task_group {
+    public:
+        task_group();
+        ~task_group();
+        void wait(); 
+        bool is_canceling();
+        void cancel();
+        %extend {
+        void run( PyObject *c ) { $self->run(PyCaller(c)); }
+        void run( PyObject *c, task_arena *a ) { $self->run(ArenaPyCaller(a, c)); }
+        };
+    };
+
+    class global_control {
+    public:
+        enum parameter {
+            max_allowed_parallelism,
+            thread_stack_size,
+            parameter_max // insert new parameters above this point
+        };
+        global_control(parameter param, size_t value);
+        ~global_control();
+        static size_t active_value(parameter param);
+    };
+
+} // tbb
+
+// Additional definitions for Python part of the module
+%pythoncode %{
+default_num_threads = task_scheduler_init_default_num_threads
+%}
diff --git a/src/tbb/python/tbb/pool.py b/src/tbb/python/tbb/pool.py
new file mode 100644
index 00000000..56b6c319
--- /dev/null
+++ b/src/tbb/python/tbb/pool.py
@@ -0,0 +1,631 @@
+#!/usr/bin/env python
+#
+# Copyright (c) 2016-2020 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.
+
+# Based on the software developed by:
+# Copyright (c) 2008,2016 david decotigny (Pool of threads)
+# Copyright (c) 2006-2008, R Oudkerk (multiprocessing.Pool)
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# 1. Redistributions of source code must retain the above copyright
+#    notice, this list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright
+#    notice, this list of conditions and the following disclaimer in the
+#    documentation and/or other materials provided with the distribution.
+# 3. Neither the name of author nor the names of any contributors may be
+#    used to endorse or promote products derived from this software
+#    without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+# OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+# HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+# OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+# SUCH DAMAGE.
+#
+
+# @brief Python Pool implementation based on TBB with monkey-patching
+#
+# See http://docs.python.org/dev/library/multiprocessing.html
+# Differences: added imap_async and imap_unordered_async, and terminate()
+# has to be called explicitly (it's not registered by atexit).
+#
+# The general idea is that we submit works to a workqueue, either as
+# single Jobs (one function to call), or JobSequences (batch of
+# Jobs). Each Job is associated with an ApplyResult object which has 2
+# states: waiting for the Job to complete, or Ready. Instead of
+# waiting for the jobs to finish, we wait for their ApplyResult object
+# to become ready: an event mechanism is used for that.
+# When we apply a function to several arguments in "parallel", we need
+# a way to wait for all/part of the Jobs to be processed: that's what
+# "collectors" are for; they group and wait for a set of ApplyResult
+# objects. Once a collector is ready to be used, we can use a
+# CollectorIterator to iterate over the result values it's collecting.
+#
+# The methods of a Pool object use all these concepts and expose
+# them to their caller in a very simple way.
+
+import sys
+import threading
+import traceback
+from .api import *
+
+__all__ = ["Pool", "TimeoutError"]
+__doc__ = """
+Standard Python Pool implementation based on Python API
+for Intel(R) Threading Building Blocks library (Intel(R) TBB)
+"""
+
+
+class TimeoutError(Exception):
+    """Raised when a result is not available within the given timeout"""
+    pass
+
+
+class Pool(object):
+    """
+    The Pool class provides standard multiprocessing.Pool interface
+    which is mapped onto Intel(R) TBB tasks executing in its thread pool
+    """
+
+    def __init__(self, nworkers=0, name="Pool"):
+        """
+        \param nworkers (integer) number of worker threads to start
+        \param name (string) prefix for the worker threads' name
+        """
+        self._closed = False
+        self._tasks = task_group()
+        self._pool = [None,]*default_num_threads()  # Dask asks for len(_pool)
+
+    def apply(self, func, args=(), kwds=dict()):
+        """Equivalent of the apply() builtin function. It blocks till
+        the result is ready."""
+        return self.apply_async(func, args, kwds).get()
+
+    def map(self, func, iterable, chunksize=None):
+        """A parallel equivalent of the map() builtin function. It
+        blocks till the result is ready.
+
+        This method chops the iterable into a number of chunks which
+        it submits to the process pool as separate tasks. The
+        (approximate) size of these chunks can be specified by setting
+        chunksize to a positive integer."""
+        return self.map_async(func, iterable, chunksize).get()
+
+    def imap(self, func, iterable, chunksize=1):
+        """
+        An equivalent of itertools.imap().
+
+        The chunksize argument is the same as the one used by the
+        map() method. For very long iterables using a large value for
+        chunksize can make the job complete much faster than
+        using the default value of 1.
+
+        Also if chunksize is 1 then the next() method of the iterator
+        returned by the imap() method has an optional timeout
+        parameter: next(timeout) will raise processing.TimeoutError if
+        the result cannot be returned within timeout seconds.
+        """
+        collector = OrderedResultCollector(as_iterator=True)
+        self._create_sequences(func, iterable, chunksize, collector)
+        return iter(collector)
+
+    def imap_unordered(self, func, iterable, chunksize=1):
+        """The same as imap() except that the ordering of the results
+        from the returned iterator should be considered
+        arbitrary. (Only when there is only one worker process is the
+        order guaranteed to be "correct".)"""
+        collector = UnorderedResultCollector()
+        self._create_sequences(func, iterable, chunksize, collector)
+        return iter(collector)
+
+    def apply_async(self, func, args=(), kwds=dict(), callback=None):
+        """A variant of the apply() method which returns an
+        ApplyResult object.
+
+        If callback is specified then it should be a callable which
+        accepts a single argument. When the result becomes ready,
+        callback is applied to it (unless the call failed). callback
+        should complete immediately since otherwise the thread which
+        handles the results will get blocked."""
+        assert not self._closed  # No lock here. We assume it's atomic...
+        apply_result = ApplyResult(callback=callback)
+        job = Job(func, args, kwds, apply_result)
+        self._tasks.run(job)
+        return apply_result
+
+    def map_async(self, func, iterable, chunksize=None, callback=None):
+        """A variant of the map() method which returns a ApplyResult
+        object.
+
+        If callback is specified then it should be a callable which
+        accepts a single argument. When the result becomes ready
+        callback is applied to it (unless the call failed). callback
+        should complete immediately since otherwise the thread which
+        handles the results will get blocked."""
+        apply_result = ApplyResult(callback=callback)
+        collector    = OrderedResultCollector(apply_result, as_iterator=False)
+        if not self._create_sequences(func, iterable, chunksize, collector):
+          apply_result._set_value([])
+        return apply_result
+
+    def imap_async(self, func, iterable, chunksize=None, callback=None):
+        """A variant of the imap() method which returns an ApplyResult
+        object that provides an iterator (next method(timeout)
+        available).
+
+        If callback is specified then it should be a callable which
+        accepts a single argument. When the resulting iterator becomes
+        ready, callback is applied to it (unless the call
+        failed). callback should complete immediately since otherwise
+        the thread which handles the results will get blocked."""
+        apply_result = ApplyResult(callback=callback)
+        collector    = OrderedResultCollector(apply_result, as_iterator=True)
+        if not self._create_sequences(func, iterable, chunksize, collector):
+          apply_result._set_value(iter([]))
+        return apply_result
+
+    def imap_unordered_async(self, func, iterable, chunksize=None,
+                             callback=None):
+        """A variant of the imap_unordered() method which returns an
+        ApplyResult object that provides an iterator (next
+        method(timeout) available).
+
+        If callback is specified then it should be a callable which
+        accepts a single argument. When the resulting iterator becomes
+        ready, callback is applied to it (unless the call
+        failed). callback should complete immediately since otherwise
+        the thread which handles the results will get blocked."""
+        apply_result = ApplyResult(callback=callback)
+        collector    = UnorderedResultCollector(apply_result)
+        if not self._create_sequences(func, iterable, chunksize, collector):
+          apply_result._set_value(iter([]))
+        return apply_result
+
+    def close(self):
+        """Prevents any more tasks from being submitted to the
+        pool. Once all the tasks have been completed the worker
+        processes will exit."""
+        # No lock here. We assume it's sufficiently atomic...
+        self._closed = True
+
+    def terminate(self):
+        """Stops the worker processes immediately without completing
+        outstanding work. When the pool object is garbage collected
+        terminate() will be called immediately."""
+        self.close()
+        self._tasks.cancel()
+
+    def join(self):
+        """Wait for the worker processes to exit. One must call
+        close() or terminate() before using join()."""
+        self._tasks.wait()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.join()
+
+    def __del__(self):
+        self.terminate()
+        self.join()
+
+    def _create_sequences(self, func, iterable, chunksize, collector):
+        """
+        Create callable objects to process and pushes them on the
+        work queue. Each work unit is meant to process a slice of
+        iterable of size chunksize. If collector is specified, then
+        the ApplyResult objects associated with the jobs will notify
+        collector when their result becomes ready.
+
+        \return the list callable objects (basically: JobSequences)
+        pushed onto the work queue
+        """
+        assert not self._closed  # No lock here. We assume it's atomic...
+        it_ = iter(iterable)
+        exit_loop = False
+        sequences = []
+        while not exit_loop:
+            seq = []
+            for _ in range(chunksize or 1):
+                try:
+                    arg = next(it_)
+                except StopIteration:
+                    exit_loop = True
+                    break
+                apply_result = ApplyResult(collector)
+                job = Job(func, (arg,), {}, apply_result)
+                seq.append(job)
+            if seq:
+                sequences.append(JobSequence(seq))
+        for t in sequences:
+            self._tasks.run(t)
+        return sequences
+
+
+class Job:
+    """A work unit that corresponds to the execution of a single function"""
+
+    def __init__(self, func, args, kwds, apply_result):
+        """
+        \param func/args/kwds used to call the function
+        \param apply_result ApplyResult object that holds the result
+        of the function call
+        """
+        self._func = func
+        self._args = args
+        self._kwds = kwds
+        self._result = apply_result
+
+    def __call__(self):
+        """
+        Call the function with the args/kwds and tell the ApplyResult
+        that its result is ready. Correctly handles the exceptions
+        happening during the execution of the function
+        """
+        try:
+            result = self._func(*self._args, **self._kwds)
+        except:
+            self._result._set_exception()
+        else:
+            self._result._set_value(result)
+
+
+class JobSequence:
+    """A work unit that corresponds to the processing of a continuous
+    sequence of Job objects"""
+
+    def __init__(self, jobs):
+        self._jobs = jobs
+
+    def __call__(self):
+        """
+        Call all the Job objects that have been specified
+        """
+        for job in self._jobs:
+            job()
+
+
+class ApplyResult(object):
+    """An object associated with a Job object that holds its result:
+    it's available during the whole life the Job and after, even when
+    the Job didn't process yet. It's possible to use this object to
+    wait for the result/exception of the job to be available.
+
+    The result objects returns by the Pool::*_async() methods are of
+    this type"""
+
+    def __init__(self, collector=None, callback=None):
+        """
+        \param collector when not None, the notify_ready() method of
+        the collector will be called when the result from the Job is
+        ready
+        \param callback when not None, function to call when the
+        result becomes available (this is the parameter passed to the
+        Pool::*_async() methods.
+        """
+        self._success = False
+        self._event = threading.Event()
+        self._data = None
+        self._collector = None
+        self._callback = callback
+
+        if collector is not None:
+            collector.register_result(self)
+            self._collector = collector
+
+    def get(self, timeout=None):
+        """
+        Returns the result when it arrives. If timeout is not None and
+        the result does not arrive within timeout seconds then
+        TimeoutError is raised. If the remote call raised an exception
+        then that exception will be reraised by get().
+        """
+        if not self.wait(timeout):
+            raise TimeoutError("Result not available within %fs" % timeout)
+        if self._success:
+            return self._data
+        if sys.version_info[0] == 3:
+            raise self._data[0](self._data[1]).with_traceback(self._data[2])
+        else:
+            exec("raise self._data[0], self._data[1], self._data[2]")
+
+    def wait(self, timeout=None):
+        """Waits until the result is available or until timeout
+        seconds pass."""
+        self._event.wait(timeout)
+        return self._event.isSet()
+
+    def ready(self):
+        """Returns whether the call has completed."""
+        return self._event.isSet()
+
+    def successful(self):
+        """Returns whether the call completed without raising an
+        exception. Will raise AssertionError if the result is not
+        ready."""
+        assert self.ready()
+        return self._success
+
+    def _set_value(self, value):
+        """Called by a Job object to tell the result is ready, and
+        provides the value of this result. The object will become
+        ready and successful. The collector's notify_ready() method
+        will be called, and the callback method too"""
+        assert not self.ready()
+        self._data = value
+        self._success = True
+        self._event.set()
+        if self._collector is not None:
+            self._collector.notify_ready(self)
+        if self._callback is not None:
+            try:
+                self._callback(value)
+            except:
+                traceback.print_exc()
+
+    def _set_exception(self):
+        """Called by a Job object to tell that an exception occurred
+        during the processing of the function. The object will become
+        ready but not successful. The collector's notify_ready()
+        method will be called, but NOT the callback method"""
+        # traceback.print_exc()
+        assert not self.ready()
+        self._data = sys.exc_info()
+        self._success = False
+        self._event.set()
+        if self._collector is not None:
+            self._collector.notify_ready(self)
+
+
+class AbstractResultCollector(object):
+    """ABC to define the interface of a ResultCollector object. It is
+    basically an object which knows whuich results it's waiting for,
+    and which is able to get notify when they get available. It is
+    also able to provide an iterator over the results when they are
+    available"""
+
+    def __init__(self, to_notify):
+        """
+        \param to_notify ApplyResult object to notify when all the
+        results we're waiting for become available. Can be None.
+        """
+        self._to_notify = to_notify
+
+    def register_result(self, apply_result):
+        """Used to identify which results we're waiting for. Will
+        always be called BEFORE the Jobs get submitted to the work
+        queue, and BEFORE the __iter__ and _get_result() methods can
+        be called
+        \param apply_result ApplyResult object to add in our collection
+        """
+        raise NotImplementedError("Children classes must implement it")
+
+    def notify_ready(self, apply_result):
+        """Called by the ApplyResult object (already registered via
+        register_result()) that it is now ready (ie. the Job's result
+        is available or an exception has been raised).
+        \param apply_result ApplyResult object telling us that the job
+        has been processed
+        """
+        raise NotImplementedError("Children classes must implement it")
+
+    def _get_result(self, idx, timeout=None):
+        """Called by the CollectorIterator object to retrieve the
+        result's values one after another (order defined by the
+        implementation)
+        \param idx The index of the result we want, wrt collector's order
+        \param timeout integer telling how long to wait (in seconds)
+        for the result at index idx to be available, or None (wait
+        forever)
+        """
+        raise NotImplementedError("Children classes must implement it")
+
+    def __iter__(self):
+        """Return a new CollectorIterator object for this collector"""
+        return CollectorIterator(self)
+
+
+class CollectorIterator(object):
+    """An iterator that allows to iterate over the result values
+    available in the given collector object. Equipped with an extended
+    next() method accepting a timeout argument. Created by the
+    AbstractResultCollector::__iter__() method"""
+
+    def __init__(self, collector):
+        """\param AbstractResultCollector instance"""
+        self._collector = collector
+        self._idx = 0
+
+    def __iter__(self):
+        return self
+
+    def next(self, timeout=None):
+        """Return the next result value in the sequence. Raise
+        StopIteration at the end. Can raise the exception raised by
+        the Job"""
+        try:
+            apply_result = self._collector._get_result(self._idx, timeout)
+        except IndexError:
+            # Reset for next time
+            self._idx = 0
+            raise StopIteration
+        except:
+            self._idx = 0
+            raise
+        self._idx += 1
+        assert apply_result.ready()
+        return apply_result.get(0)
+
+    def __next__(self):
+        return self.next()
+
+
+class UnorderedResultCollector(AbstractResultCollector):
+    """An AbstractResultCollector implementation that collects the
+    values of the ApplyResult objects in the order they become ready. The
+    CollectorIterator object returned by __iter__() will iterate over
+    them in the order they become ready"""
+
+    def __init__(self, to_notify=None):
+        """
+        \param to_notify ApplyResult object to notify when all the
+        results we're waiting for become available. Can be None.
+        """
+        AbstractResultCollector.__init__(self, to_notify)
+        self._cond = threading.Condition()
+        self._collection = []
+        self._expected = 0
+
+    def register_result(self, apply_result):
+        """Used to identify which results we're waiting for. Will
+        always be called BEFORE the Jobs get submitted to the work
+        queue, and BEFORE the __iter__ and _get_result() methods can
+        be called
+        \param apply_result ApplyResult object to add in our collection
+        """
+        self._expected += 1
+
+    def _get_result(self, idx, timeout=None):
+        """Called by the CollectorIterator object to retrieve the
+        result's values one after another, in the order the results have
+        become available.
+        \param idx The index of the result we want, wrt collector's order
+        \param timeout integer telling how long to wait (in seconds)
+        for the result at index idx to be available, or None (wait
+        forever)
+        """
+        self._cond.acquire()
+        try:
+            if idx >= self._expected:
+                raise IndexError
+            elif idx < len(self._collection):
+                return self._collection[idx]
+            elif idx != len(self._collection):
+                # Violation of the sequence protocol
+                raise IndexError()
+            else:
+                self._cond.wait(timeout=timeout)
+                try:
+                    return self._collection[idx]
+                except IndexError:
+                    # Still not added !
+                    raise TimeoutError("Timeout while waiting for results")
+        finally:
+            self._cond.release()
+
+    def notify_ready(self, apply_result=None):
+        """Called by the ApplyResult object (already registered via
+        register_result()) that it is now ready (ie. the Job's result
+        is available or an exception has been raised).
+        \param apply_result ApplyResult object telling us that the job
+        has been processed
+        """
+        first_item = False
+        self._cond.acquire()
+        try:
+            self._collection.append(apply_result)
+            first_item = (len(self._collection) == 1)
+
+            self._cond.notifyAll()
+        finally:
+            self._cond.release()
+
+        if first_item and self._to_notify is not None:
+            self._to_notify._set_value(iter(self))
+
+
+class OrderedResultCollector(AbstractResultCollector):
+    """An AbstractResultCollector implementation that collects the
+    values of the ApplyResult objects in the order they have been
+    submitted. The CollectorIterator object returned by __iter__()
+    will iterate over them in the order they have been submitted"""
+
+    def __init__(self, to_notify=None, as_iterator=True):
+        """
+        \param to_notify ApplyResult object to notify when all the
+        results we're waiting for become available. Can be None.
+        \param as_iterator boolean telling whether the result value
+        set on to_notify should be an iterator (available as soon as 1
+        result arrived) or a list (available only after the last
+        result arrived)
+        """
+        AbstractResultCollector.__init__(self, to_notify)
+        self._results = []
+        self._lock = threading.Lock()
+        self._remaining = 0
+        self._as_iterator = as_iterator
+
+    def register_result(self, apply_result):
+        """Used to identify which results we're waiting for. Will
+        always be called BEFORE the Jobs get submitted to the work
+        queue, and BEFORE the __iter__ and _get_result() methods can
+        be called
+        \param apply_result ApplyResult object to add in our collection
+        """
+        self._results.append(apply_result)
+        self._remaining += 1
+
+    def _get_result(self, idx, timeout=None):
+        """Called by the CollectorIterator object to retrieve the
+        result's values one after another (order defined by the
+        implementation)
+        \param idx The index of the result we want, wrt collector's order
+        \param timeout integer telling how long to wait (in seconds)
+        for the result at index idx to be available, or None (wait
+        forever)
+        """
+        res = self._results[idx]
+        res.wait(timeout)
+        return res
+
+    def notify_ready(self, apply_result):
+        """Called by the ApplyResult object (already registered via
+        register_result()) that it is now ready (ie. the Job's result
+        is available or an exception has been raised).
+        \param apply_result ApplyResult object telling us that the job
+        has been processed
+        """
+        got_first = False
+        got_last = False
+        self._lock.acquire()
+        try:
+            assert self._remaining > 0
+            got_first = (len(self._results) == self._remaining)
+            self._remaining -= 1
+            got_last = (self._remaining == 0)
+        finally:
+            self._lock.release()
+
+        if self._to_notify is not None:
+            if self._as_iterator and got_first:
+                self._to_notify._set_value(iter(self))
+            elif not self._as_iterator and got_last:
+                try:
+                    lst = [r.get(0) for r in self._results]
+                except:
+                    self._to_notify._set_exception()
+                else:
+                    self._to_notify._set_value(lst)
diff --git a/src/tbb/python/tbb/test.py b/src/tbb/python/tbb/test.py
new file mode 100644
index 00000000..2f2885ef
--- /dev/null
+++ b/src/tbb/python/tbb/test.py
@@ -0,0 +1,195 @@
+#!/usr/bin/env python
+#
+# Copyright (c) 2016-2020 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.
+
+# Based on the software developed by:
+# Copyright (c) 2008,2016 david decotigny (Pool of threads)
+# Copyright (c) 2006-2008, R Oudkerk (multiprocessing.Pool)
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# 1. Redistributions of source code must retain the above copyright
+#    notice, this list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright
+#    notice, this list of conditions and the following disclaimer in the
+#    documentation and/or other materials provided with the distribution.
+# 3. Neither the name of author nor the names of any contributors may be
+#    used to endorse or promote products derived from this software
+#    without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+# OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+# HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+# OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+# SUCH DAMAGE.
+#
+
+from __future__ import print_function
+import time
+import threading
+
+from .api import *
+from .pool import *
+
+
+def test(arg=None):
+    if arg == "-v":
+        def say(*x):
+            print(*x)
+    else:
+        def say(*x):
+            pass
+    say("Start Pool testing")
+
+    get_tid = lambda: threading.current_thread().ident
+
+    def return42():
+        return 42
+
+    def f(x):
+        return x * x
+
+    def work(mseconds):
+        res = str(mseconds)
+        if mseconds < 0:
+            mseconds = -mseconds
+        say("[%d] Start to work for %fms..." % (get_tid(), mseconds*10))
+        time.sleep(mseconds/100.)
+        say("[%d] Work done (%fms)." % (get_tid(), mseconds*10))
+        return res
+
+    ### Test copy/pasted from multiprocessing
+    pool = Pool(4)  # start worker threads
+
+    # edge cases
+    assert pool.map(return42, []) == []
+    assert pool.apply_async(return42, []).get() == 42
+    assert pool.apply(return42, []) == 42
+    assert list(pool.imap(return42, iter([]))) == []
+    assert list(pool.imap_unordered(return42, iter([]))) == []
+    assert pool.map_async(return42, []).get() == []
+    assert list(pool.imap_async(return42, iter([])).get()) == []
+    assert list(pool.imap_unordered_async(return42, iter([])).get()) == []
+
+    # basic tests
+    result = pool.apply_async(f, (10,))  # evaluate "f(10)" asynchronously
+    assert result.get(timeout=1) == 100  # ... unless slow computer
+    assert list(pool.map(f, range(10))) == list(map(f, range(10)))
+    it = pool.imap(f, range(10))
+    assert next(it) == 0
+    assert next(it) == 1
+    assert next(it) == 4
+
+    # Test apply_sync exceptions
+    result = pool.apply_async(time.sleep, (3,))
+    try:
+        say(result.get(timeout=1))  # raises `TimeoutError`
+    except TimeoutError:
+        say("Good. Got expected timeout exception.")
+    else:
+        assert False, "Expected exception !"
+    assert result.get() is None  # sleep() returns None
+
+    def cb(s):
+        say("Result ready: %s" % s)
+
+    # Test imap()
+    assert list(pool.imap(work, range(10, 3, -1), chunksize=4)) == list(map(
+        str, range(10, 3, -1)))
+
+    # Test imap_unordered()
+    assert sorted(pool.imap_unordered(work, range(10, 3, -1))) == sorted(map(
+        str, range(10, 3, -1)))
+
+    # Test map_async()
+    result = pool.map_async(work, range(10), callback=cb)
+    try:
+        result.get(timeout=0.01)  # raises `TimeoutError`
+    except TimeoutError:
+        say("Good. Got expected timeout exception.")
+    else:
+        assert False, "Expected exception !"
+    say(result.get())
+
+    # Test imap_async()
+    result = pool.imap_async(work, range(3, 10), callback=cb)
+    try:
+        result.get(timeout=0.01)  # raises `TimeoutError`
+    except TimeoutError:
+        say("Good. Got expected timeout exception.")
+    else:
+        assert False, "Expected exception !"
+    for i in result.get():
+        say("Item:", i)
+    say("### Loop again:")
+    for i in result.get():
+        say("Item2:", i)
+
+    # Test imap_unordered_async()
+    result = pool.imap_unordered_async(work, range(10, 3, -1), callback=cb)
+    try:
+        say(result.get(timeout=0.01))  # raises `TimeoutError`
+    except TimeoutError:
+        say("Good. Got expected timeout exception.")
+    else:
+        assert False, "Expected exception !"
+    for i in result.get():
+        say("Item1:", i)
+    for i in result.get():
+        say("Item2:", i)
+    r = result.get()
+    for i in r:
+        say("Item3:", i)
+    for i in r:
+        say("Item4:", i)
+    for i in r:
+        say("Item5:", i)
+
+    #
+    # The case for the exceptions
+    #
+
+    # Exceptions in imap_unordered_async()
+    result = pool.imap_unordered_async(work, range(2, -10, -1), callback=cb)
+    time.sleep(3)
+    try:
+        for i in result.get():
+            say("Got item:", i)
+    except (IOError, ValueError):
+        say("Good. Got expected exception")
+
+    # Exceptions in imap_async()
+    result = pool.imap_async(work, range(2, -10, -1), callback=cb)
+    time.sleep(3)
+    try:
+        for i in result.get():
+            say("Got item:", i)
+    except (IOError, ValueError):
+        say("Good. Got expected exception")
+
+    # Stop the test: need to stop the pool !!!
+    pool.terminate()
+    pool.join()
+
+
diff --git a/src/tbb/src/Makefile b/src/tbb/src/Makefile
index 195304d5..57234fe7 100644
--- a/src/tbb/src/Makefile
+++ b/src/tbb/src/Makefile
@@ -1,4 +1,4 @@
-# Copyright (c) 2005-2017 Intel Corporation
+# Copyright (c) 2005-2020 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -11,10 +11,6 @@
 # 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.
-#
-#
-#
-#
 
 tbb_root?=..
 examples_root:=$(tbb_root)/examples
@@ -24,17 +20,19 @@ include $(tbb_root)/build/common.inc
 #According to documentation, recursively invoked make commands can process their targets in parallel
 .NOTPARALLEL:
 
-.PHONY: all tbb tbbmalloc tbbproxy test test_no_depends release debug examples clean
+.PHONY: all tbb tbbmalloc tbbbind tbbproxy test test_no_depends release debug examples clean mkdir
 
-all: release debug examples
+all: release examples
 
 tbb: tbb_release tbb_debug
 
 tbbmalloc: tbbmalloc_release tbbmalloc_debug
 
-tbbproxy: tbbproxy_release tbbproxy_debug
+tbbbind: tbbbind_release
 
-rml: rml_release rml_debug
+tbbproxy: tbbproxy_release
+
+rml: rml_release
 
 test: tbbmalloc_test_release $(if $(use_proxy),tbbproxy_test_release) tbb_test_release tbbmalloc_test_debug $(if $(use_proxy),tbbproxy_test_debug) tbb_test_debug
 ifeq (,$(findstring skip,$(target:android=skip) $(offload:mic=skip)))
@@ -57,6 +55,8 @@ examples_no_depends: examples_release_no_depends examples_debug_no_depends
 clean: clean_release clean_debug clean_examples
 	@echo clean done
 
+mkdir: mkdir_debug mkdir_release
+
 .PHONY: full
 full:
 	$(MAKE) -sir --no-print-directory -f Makefile tbb_root=.. clean all
@@ -94,11 +94,12 @@ else
 	@$(MAKE) -C "$(work_dir)_$(cfg)"  -r -f $(tbb_root)/build/Makefile.test $@
 endif
 
-python_%: tbb_release
-	bash -c ". $(work_dir)_release$(SLASH)tbbvars.sh && $(MAKE) -rC '$(full_tbb_root)/python' CXX=$(compiler) $(subst python_,,$@)"
+python_%: mkdir_release
+	$(MAKE) -C "$(work_dir)_release" -rf $(tbb_root)/python/Makefile $(subst python_,,$@)
 
 .PHONY: test_release test_debug test_release_no_depends test_debug_no_depends
 .PHONY: tbb_release tbb_debug tbb_test_release tbb_test_debug tbb_test_release_no_depends tbb_test_debug_no_depends
+.PHONY: tbbbind_release tbbbind_debug
 # do not delete double-space after -C option
 tbb_release: mkdir_release
 	$(MAKE) -C "$(work_dir)_release"  -r -f $(tbb_root)/build/Makefile.tbb cfg=release
@@ -121,6 +122,12 @@ test_debug: tbb_test_debug
 test_release_no_depends: tbb_test_release_no_depends
 test_debug_no_depends: tbb_test_debug_no_depends
 
+tbbbind_release: mkdir_release
+	$(MAKE) -C "$(work_dir)_release"  -r -f $(tbb_root)/build/Makefile.tbbbind cfg=release tbbbind
+
+tbbbind_debug: mkdir_debug
+	$(MAKE) -C "$(work_dir)_debug"  -r -f $(tbb_root)/build/Makefile.tbbbind cfg=debug tbbbind
+
 .PHONY: tbbmalloc_release tbbmalloc_debug
 .PHONY: tbbmalloc_dll_release tbbmalloc_dll_debug tbbmalloc_proxy_dll_release tbbmalloc_proxy_dll_debug
 .PHONY: tbbmalloc_test tbbmalloc_test_release tbbmalloc_test_debug tbbmalloc_test_release_no_depends tbbmalloc_test_debug_no_depends
diff --git a/src/tbb/src/index.html b/src/tbb/src/index.html
index e828987c..ddb823b0 100644
--- a/src/tbb/src/index.html
+++ b/src/tbb/src/index.html
@@ -66,7 +66,7 @@ <h2>Files</h2>
 <HR/>
 <A HREF="../index.html">Up to parent directory</A>
 <p></p>
-Copyright &copy; 2005-2017 Intel Corporation.  All Rights Reserved.
+Copyright &copy; 2005-2020 Intel Corporation.  All Rights Reserved.
 <P></P>
 Intel is a registered trademark or trademark of Intel Corporation
 or its subsidiaries in the United States and other countries.
diff --git a/src/tbb/src/old/concurrent_queue_v2.cpp b/src/tbb/src/old/concurrent_queue_v2.cpp
index 1be9dc7f..43a20feb 100644
--- a/src/tbb/src/old/concurrent_queue_v2.cpp
+++ b/src/tbb/src/old/concurrent_queue_v2.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 "concurrent_queue_v2.h"
@@ -32,8 +28,6 @@
 
 #define RECORD_EVENTS 0
 
-using namespace std;
-
 namespace tbb {
 
 namespace internal {
@@ -210,7 +204,7 @@ concurrent_queue_base::concurrent_queue_base( size_t item_sz ) {
     __TBB_ASSERT( (size_t)&my_rep->head_counter % NFS_GetLineSize()==0, "alignment error" );
     __TBB_ASSERT( (size_t)&my_rep->tail_counter % NFS_GetLineSize()==0, "alignment error" );
     __TBB_ASSERT( (size_t)&my_rep->array % NFS_GetLineSize()==0, "alignment error" );
-    memset((void*) my_rep, 0, sizeof(concurrent_queue_rep));
+    std::memset(static_cast<void*>(my_rep),0,sizeof(concurrent_queue_rep));
     this->item_size = item_sz;
 }
 
diff --git a/src/tbb/src/old/concurrent_queue_v2.h b/src/tbb/src/old/concurrent_queue_v2.h
index 54dd8223..3f8bef0e 100644
--- a/src/tbb/src/old/concurrent_queue_v2.h
+++ b/src/tbb/src/old/concurrent_queue_v2.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_concurrent_queue_H
@@ -54,13 +50,13 @@ class concurrent_queue_base: no_copy {
     //! Prefix on a page
     struct page {
         page* next;
-        uintptr_t mask; 
+        uintptr_t mask;
     };
 
 protected:
     //! Capacity of the queue
     ptrdiff_t my_capacity;
-   
+
     //! Always a power of 2
     size_t items_per_page;
 
@@ -94,7 +90,7 @@ class concurrent_queue_base: no_copy {
 
 //! Type-independent portion of concurrent_queue_iterator.
 /** @ingroup containers */
-class concurrent_queue_iterator_base : no_assign{
+class concurrent_queue_iterator_base : no_assign {
     //! concurrent_queue over which we are iterating.
     /** NULL if one past last element in queue. */
     concurrent_queue_iterator_rep* my_rep;
@@ -109,10 +105,10 @@ class concurrent_queue_iterator_base : no_assign{
     mutable void* my_item;
 
     //! Default constructor
-    __TBB_EXPORTED_METHOD concurrent_queue_iterator_base() : my_rep(NULL), my_item(NULL) {}
+    __TBB_EXPORTED_METHOD concurrent_queue_iterator_base() : no_assign(), my_rep(NULL), my_item(NULL) {}
 
     //! Copy constructor
-    concurrent_queue_iterator_base( const concurrent_queue_iterator_base& i ) : my_rep(NULL), my_item(NULL) {
+    concurrent_queue_iterator_base( const concurrent_queue_iterator_base& i ) : no_assign(), my_rep(NULL), my_item(NULL) {
         assign(i);
     }
 
@@ -139,7 +135,7 @@ class concurrent_queue_iterator: public concurrent_queue_iterator_base {
     friend class ::tbb::concurrent_queue;
 #else
 public: // workaround for MSVC
-#endif 
+#endif
     //! Construct iterator pointing to head of queue.
     concurrent_queue_iterator( const concurrent_queue_base& queue ) :
         concurrent_queue_iterator_base(queue)
@@ -148,7 +144,7 @@ class concurrent_queue_iterator: public concurrent_queue_iterator_base {
 public:
     concurrent_queue_iterator() {}
 
-    /** If Value==Container::value_type, then this routine is the copy constructor. 
+    /** If Value==Container::value_type, then this routine is the copy constructor.
         If Value==const Container::value_type, then this routine is a conversion constructor. */
     concurrent_queue_iterator( const concurrent_queue_iterator<Container,typename Container::value_type>& other ) :
         concurrent_queue_iterator_base(other)
@@ -160,7 +156,7 @@ class concurrent_queue_iterator: public concurrent_queue_iterator_base {
         return *this;
     }
 
-    //! Reference to current item 
+    //! Reference to current item
     Value& operator*() const {
         return *static_cast<Value*>(my_item);
     }
@@ -202,12 +198,12 @@ template<typename T>
 class concurrent_queue: public internal::concurrent_queue_base {
     template<typename Container, typename Value> friend class internal::concurrent_queue_iterator;
 
-    //! Class used to ensure exception-safety of method "pop" 
+    //! Class used to ensure exception-safety of method "pop"
     class destroyer {
         T& my_value;
     public:
         destroyer( T& value ) : my_value(value) {}
-        ~destroyer() {my_value.~T();}          
+        ~destroyer() {my_value.~T();}
     };
 
     T& get_ref( page& pg, size_t index ) {
@@ -244,7 +240,7 @@ class concurrent_queue: public internal::concurrent_queue_base {
     typedef std::ptrdiff_t difference_type;
 
     //! Construct empty queue
-    concurrent_queue() : 
+    concurrent_queue() :
         concurrent_queue_base( sizeof(T) )
     {
     }
@@ -278,8 +274,8 @@ class concurrent_queue: public internal::concurrent_queue_base {
     }
 
     //! Return number of pushes minus number of pops.
-    /** Note that the result can be negative if there are pops waiting for the 
-        corresponding pushes.  The result can also exceed capacity() if there 
+    /** Note that the result can be negative if there are pops waiting for the
+        corresponding pushes.  The result can also exceed capacity() if there
         are push operations in flight. */
     size_type size() const {return internal_size();}
 
@@ -308,8 +304,8 @@ class concurrent_queue: public internal::concurrent_queue_base {
     iterator end() {return iterator();}
     const_iterator begin() const {return const_iterator(*this);}
     const_iterator end() const {return const_iterator();}
-    
-}; 
+
+};
 
 template<typename T>
 concurrent_queue<T>::~concurrent_queue() {
diff --git a/src/tbb/src/old/concurrent_vector_v2.cpp b/src/tbb/src/old/concurrent_vector_v2.cpp
index d31b5b3a..0f96b755 100644
--- a/src/tbb/src/old/concurrent_vector_v2.cpp
+++ b/src/tbb/src/old/concurrent_vector_v2.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 "concurrent_vector_v2.h"
@@ -71,7 +67,7 @@ class concurrent_vector_base::helper {
 void concurrent_vector_base::helper::extend_segment( concurrent_vector_base& v ) {
     const size_t pointers_per_long_segment = sizeof(void*)==4 ? 32 : 64;
     segment_t* s = (segment_t*)NFS_Allocate( pointers_per_long_segment, sizeof(segment_t), NULL );
-    std::memset( (void*) s, 0, pointers_per_long_segment*sizeof(segment_t) );
+    std::memset( static_cast<void*>(s), 0, pointers_per_long_segment*sizeof(segment_t) );
     // If other threads are trying to set pointers in the short segment, wait for them to finish their
     // assignments before we copy the short segment to the long segment.
     atomic_backoff backoff;
diff --git a/src/tbb/src/old/concurrent_vector_v2.h b/src/tbb/src/old/concurrent_vector_v2.h
index 6dcae595..1cb482eb 100644
--- a/src/tbb/src/old/concurrent_vector_v2.h
+++ b/src/tbb/src/old/concurrent_vector_v2.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_concurrent_vector_H
diff --git a/src/tbb/src/old/spin_rw_mutex_v2.cpp b/src/tbb/src/old/spin_rw_mutex_v2.cpp
index 02cf633a..79b667d8 100644
--- a/src/tbb/src/old/spin_rw_mutex_v2.cpp
+++ b/src/tbb/src/old/spin_rw_mutex_v2.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 "spin_rw_mutex_v2.h"
diff --git a/src/tbb/src/old/spin_rw_mutex_v2.h b/src/tbb/src/old/spin_rw_mutex_v2.h
index 12e097d6..a49cc58b 100644
--- a/src/tbb/src/old/spin_rw_mutex_v2.h
+++ b/src/tbb/src/old/spin_rw_mutex_v2.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_spin_rw_mutex_H
diff --git a/src/tbb/src/old/task_v2.cpp b/src/tbb/src/old/task_v2.cpp
index 9b569c3b..e49635db 100644
--- a/src/tbb/src/old/task_v2.cpp
+++ b/src/tbb/src/old/task_v2.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 /*  This compilation unit provides definition of task::destroy( task& )
diff --git a/src/tbb/src/old/test_concurrent_queue_v2.cpp b/src/tbb/src/old/test_concurrent_queue_v2.cpp
index b0bb56ba..74112757 100644
--- a/src/tbb/src/old/test_concurrent_queue_v2.cpp
+++ b/src/tbb/src/old/test_concurrent_queue_v2.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 "old/concurrent_queue_v2.h"
diff --git a/src/tbb/src/old/test_concurrent_vector_v2.cpp b/src/tbb/src/old/test_concurrent_vector_v2.cpp
index 1d0fd2a7..02b8dc75 100644
--- a/src/tbb/src/old/test_concurrent_vector_v2.cpp
+++ b/src/tbb/src/old/test_concurrent_vector_v2.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 "concurrent_vector_v2.h"
diff --git a/src/tbb/src/old/test_mutex_v2.cpp b/src/tbb/src/old/test_mutex_v2.cpp
index e6d9c3d5..b550d302 100644
--- a/src/tbb/src/old/test_mutex_v2.cpp
+++ b/src/tbb/src/old/test_mutex_v2.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #define HARNESS_DEFAULT_MIN_THREADS 1
diff --git a/src/tbb/src/old/test_task_scheduler_observer_v3.cpp b/src/tbb/src/old/test_task_scheduler_observer_v3.cpp
index cfd772be..732e4b7e 100644
--- a/src/tbb/src/old/test_task_scheduler_observer_v3.cpp
+++ b/src/tbb/src/old/test_task_scheduler_observer_v3.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,13 +12,9 @@
     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.
-
-
-
-
 */
 
-//TODO: when removing TBB_PREVIEW_LOCAL_OBSERVER, change the header or defines here
+#define __TBB_ARENA_OBSERVER 0
 #include "tbb/task_scheduler_observer.h"
 
 typedef uintptr_t FlagType;
@@ -95,7 +91,7 @@ class DoTest {
     DoTest( int n ) : nthread(n) {}
     void operator()( int i ) const {
         LocalState->IsMaster = true;
-        if( i==0 ) {   
+        if( i==0 ) {
             tbb::task_scheduler_init init(nthread);
             DoFib(0);
         } else {
@@ -112,8 +108,8 @@ void TestObserver( int p, int q ) {
 }
 
 int TestMain () {
-    for( int p=MinThread; p<=MaxThread; ++p ) 
-        for( int q=MinThread; q<=MaxThread; ++q ) 
+    for( int p=MinThread; p<=MaxThread; ++p )
+        for( int q=MinThread; q<=MaxThread; ++q )
             TestObserver(p,q);
     ASSERT( EntryCount>0, "on_scheduler_entry not exercised" );
     ASSERT( ExitCount>0, "on_scheduler_exit not exercised" );
diff --git a/src/tbb/src/perf/coarse_grained_raii_lru_cache.h b/src/tbb/src/perf/coarse_grained_raii_lru_cache.h
index 9b11400e..019a6da0 100644
--- a/src/tbb/src/perf/coarse_grained_raii_lru_cache.h
+++ b/src/tbb/src/perf/coarse_grained_raii_lru_cache.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef coarse_grained_raii_lru_cache_H
diff --git a/src/tbb/src/perf/cpq_pdes.cpp b/src/tbb/src/perf/cpq_pdes.cpp
index c54eb8fc..56645129 100644
--- a/src/tbb/src/perf/cpq_pdes.cpp
+++ b/src/tbb/src/perf/cpq_pdes.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 <cstdlib>
diff --git a/src/tbb/src/perf/fibonacci_impl_tbb.cpp b/src/tbb/src/perf/fibonacci_impl_tbb.cpp
index 158ddb49..0c54d0cd 100644
--- a/src/tbb/src/perf/fibonacci_impl_tbb.cpp
+++ b/src/tbb/src/perf/fibonacci_impl_tbb.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 <cstdio>
diff --git a/src/tbb/src/perf/harness_perf.h b/src/tbb/src/perf/harness_perf.h
new file mode 100644
index 00000000..02bb3f2a
--- /dev/null
+++ b/src/tbb/src/perf/harness_perf.h
@@ -0,0 +1,39 @@
+/*
+    Copyright (c) 2005-2020 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.
+*/
+
+#ifndef __TBB_HARNESS_PERF
+#define __TBB_HARNESS_PERF
+
+#include <iterator>
+#include <algorithm>
+
+namespace harness_perf {
+
+template<typename InputIterator>
+typename InputIterator::value_type median(InputIterator first, InputIterator last) {
+    std::sort(first, last);
+    typename InputIterator::difference_type distance = std::distance(first, last);
+    std::advance(first, distance / 2 - 1);
+    if (distance % 2 == 0)
+        return typename InputIterator::value_type((*first + *(++first)) / 2);
+    else
+        return typename InputIterator::value_type(*first);
+}
+
+} // namespace harness_perf
+
+#endif // !__TBB_HARNESS_PERF
+
diff --git a/src/tbb/src/perf/perf.cpp b/src/tbb/src/perf/perf.cpp
index 36a3ba8e..b7925770 100644
--- a/src/tbb/src/perf/perf.cpp
+++ b/src/tbb/src/perf/perf.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 "perf.h"
diff --git a/src/tbb/src/perf/perf.h b/src/tbb/src/perf/perf.h
index fb5f2ce6..4ea267fb 100644
--- a/src/tbb/src/perf/perf.h
+++ b/src/tbb/src/perf/perf.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __tbb_perf_h__
diff --git a/src/tbb/src/perf/perf_sched.cpp b/src/tbb/src/perf/perf_sched.cpp
index 321fed68..43331c3c 100644
--- a/src/tbb/src/perf/perf_sched.cpp
+++ b/src/tbb/src/perf/perf_sched.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 "perf.h"
diff --git a/src/tbb/src/perf/run_statistics.sh b/src/tbb/src/perf/run_statistics.sh
index ac7ffd7c..232d5084 100644
--- a/src/tbb/src/perf/run_statistics.sh
+++ b/src/tbb/src/perf/run_statistics.sh
@@ -1,6 +1,6 @@
 #!/bin/bash
 #
-# Copyright (c) 2005-2017 Intel Corporation
+# Copyright (c) 2005-2020 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -13,15 +13,11 @@
 # 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.
-#
-#
-#
-#
 
 export LD_LIBRARY_PATH=.:$LD_LIBRARY_PATH
 #setting output format .csv, 'pivot' - is pivot table mode, ++ means append
 export STAT_FORMAT=pivot-csv++
-#check existing files because of apend mode
+#check existing files because of append mode
 ls *.csv
 rm -i *.csv
 #setting a delimiter in txt or csv file
diff --git a/src/tbb/src/perf/statistics.cpp b/src/tbb/src/perf/statistics.cpp
index f0c190b4..4825cf98 100644
--- a/src/tbb/src/perf/statistics.cpp
+++ b/src/tbb/src/perf/statistics.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 "statistics.h"
diff --git a/src/tbb/src/perf/statistics.h b/src/tbb/src/perf/statistics.h
index 7113a7ea..8f9a3816 100644
--- a/src/tbb/src/perf/statistics.h
+++ b/src/tbb/src/perf/statistics.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 // Internal Intel tool
diff --git a/src/tbb/src/perf/statistics_xml.h b/src/tbb/src/perf/statistics_xml.h
index 396241de..3a31ce10 100644
--- a/src/tbb/src/perf/statistics_xml.h
+++ b/src/tbb/src/perf/statistics_xml.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 const char XMLBRow[]=
diff --git a/src/tbb/src/perf/time_async_return.cpp b/src/tbb/src/perf/time_async_return.cpp
new file mode 100644
index 00000000..59272556
--- /dev/null
+++ b/src/tbb/src/perf/time_async_return.cpp
@@ -0,0 +1,222 @@
+/*
+    Copyright (c) 2005-2020 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.
+*/
+
+/*
+    This microbenchmark measures prioritization of the tasks that were spawned to execute async_node
+    successor's body. The idea of the prioritization is to have TBB worker threads react eagerly on
+    the work, which was returned back to the graph through async_node's gateway interface while
+    being occupied by CPU work generated by function_node with nested parallelism. Worker threads
+    should prefer async_node task instead of next parallel_for task. The result of correct work
+    prioritization is the interleaving of CPU and ASYNC work:
+
+        ASYNC task=1 started, thread_idx=0
+        CPU task=1 started, thread_idx=0
+            CPU task=1, nested pfor task=0, thread_idx=0
+            CPU task=1, nested pfor task=4, thread_idx=1
+        ASYNC task=1 finished, thread_idx=0
+        ASYNC task=2 started, thread_idx=0
+            CPU task=1, nested pfor task=1, thread_idx=0
+            CPU task=1, nested pfor task=5, thread_idx=1
+        ASYNC task=2 finished, thread_idx=0
+        ASYNC task=3 started, thread_idx=0
+            CPU task=1, nested pfor task=2, thread_idx=0
+            CPU task=1, nested pfor task=6, thread_idx=1
+        ASYNC task=3 finished, thread_idx=0
+        ASYNC task=4 started, thread_idx=0
+            CPU task=1, nested pfor task=3, thread_idx=0
+            CPU task=1, nested pfor task=7, thread_idx=1
+        ASYNC task=4 finished, thread_idx=0
+        ASYNC task=5 started, thread_idx=0
+        CPU task=1 finished, thread_idx=0
+        CPU task=2 started, thread_idx=0
+            CPU task=2, nested pfor task=0, thread_idx=0
+            CPU task=2, nested pfor task=4, thread_idx=1
+            CPU task=2, nested pfor task=5, thread_idx=1
+        ASYNC task=5 finished, thread_idx=0
+        ASYNC task=6 started, thread_idx=0
+            CPU task=2, nested pfor task=1, thread_idx=0
+        ASYNC task=6 finished, thread_idx=1
+            CPU task=2, nested pfor task=2, thread_idx=0
+        ASYNC task=7 started, thread_idx=1
+            CPU task=2, nested pfor task=6, thread_idx=1
+        ASYNC task=7 finished, thread_idx=0
+        ASYNC task=8 started, thread_idx=0
+            CPU task=2, nested pfor task=7, thread_idx=1
+            CPU task=2, nested pfor task=3, thread_idx=0
+        CPU task=2 finished, thread_idx=0
+        ASYNC task=8 finished, thread_idx=1
+        Elapsed time: 8.002
+
+    The parameters are chosen so that CPU and ASYNC work take approximately the same time.
+*/
+
+#define TBB_PREVIEW_FLOW_GRAPH_FEATURES __TBB_CPF_BUILD
+
+#include "tbb/task_scheduler_init.h"
+#include "tbb/parallel_for.h"
+#include "tbb/concurrent_queue.h"
+#include "tbb/tick_count.h"
+#include "tbb/tbb_thread.h"
+#include "tbb/flow_graph.h"
+#include "tbb/task_arena.h"
+#include <vector>
+#include <cstdio>
+
+const int NUM_THREADS = 2;                          // number of threads TBB is initialized with
+const int CPU_LIMIT = 2;                            // number of repetitions of sub-graph with function_node
+const double CPU_SPIN = 1.;                         // execution time of every parallel_for task
+const int NESTED_CPU_TASKS_COUNT = 4 * NUM_THREADS; // number of parallel_for tasks
+const int ASYNC_LIMIT = 8;                          // number of repetitions of sub-graph with async_node
+const double ASYNC_SPIN = 0.5;                      // execution time of every async_node work
+
+void spin(double s) {
+    tbb::tick_count start = tbb::tick_count::now();
+    while ((tbb::tick_count::now() - start).seconds() < s);
+}
+
+typedef int data_type;
+typedef tbb::flow::async_node<data_type, data_type> async_node_type;
+typedef tbb::flow::multifunction_node<data_type,
+    tbb::flow::tuple<data_type, data_type> > decider_node_type;
+
+struct AsyncActivity {
+    typedef async_node_type::gateway_type gateway_type;
+
+    struct work_type {
+        data_type input;
+        gateway_type* gateway;
+    };
+    bool done;
+    bool end_of_work() { return done; }
+    tbb::concurrent_queue<work_type> my_queue;
+    tbb::tbb_thread my_service_thread;
+
+    struct ServiceThreadFunc {
+        void operator()(AsyncActivity* activity) {
+            while (!activity->end_of_work()) {
+                work_type work;
+                while (activity->my_queue.try_pop(work)) {
+                    spin(ASYNC_SPIN); // do work
+                    work.gateway->try_put(work.input);
+                    work.gateway->release_wait();
+                }
+            }
+        }
+    };
+
+    void stop_and_wait() {
+        done = true;
+        my_service_thread.join();
+    }
+
+    void submit(data_type input, gateway_type* gateway) {
+        work_type work = { input, gateway };
+        gateway->reserve_wait();
+        my_queue.push(work);
+    }
+
+    AsyncActivity() : done(false), my_service_thread(ServiceThreadFunc(), this) {}
+};
+
+struct StartBody {
+    bool has_run;
+    bool operator()(data_type& input) {
+        if (has_run) return false;
+        else {
+            input = 1;
+            has_run = true;
+            return true;
+        }
+    }
+    StartBody() : has_run(false) {}
+};
+
+struct ParallelForBody {
+    const data_type& my_input;
+    ParallelForBody(const data_type& input) : my_input(input) {}
+    void operator()(const data_type& p) const {
+        std::printf("    CPU task=%d, nested pfor task=%d, thread_idx=%d\n", my_input, p,
+                    tbb::this_task_arena::current_thread_index());
+        spin(CPU_SPIN);
+    }
+};
+
+struct CpuWorkBody {
+    const int parallel_for_tasks_count;
+    data_type operator()(const data_type& input) {
+        std::printf("CPU task=%d started, thread_idx=%d\n", input,
+                    tbb::this_task_arena::current_thread_index());
+        tbb::parallel_for(0, parallel_for_tasks_count, ParallelForBody(input));
+        return input;
+    }
+    CpuWorkBody() : parallel_for_tasks_count(NESTED_CPU_TASKS_COUNT) {}
+};
+
+struct DeciderBody {
+    const int& my_limit;
+    DeciderBody( const int& limit ) : my_limit( limit ) {}
+    void operator()(data_type input, decider_node_type::output_ports_type& ports) {
+        const char* work_type = my_limit == ASYNC_LIMIT ? "ASYNC" : "CPU";
+        std::printf("%s task=%d finished, thread_idx=%d\n", work_type, input,
+                    tbb::this_task_arena::current_thread_index());
+        if (input < my_limit)
+            tbb::flow::get<0>(ports).try_put(input + 1);
+        else
+            tbb::flow::get<1>(ports).try_put(input + 1);
+    }
+};
+
+struct AsyncSubmissionBody {
+    AsyncActivity* my_activity;
+    void operator()(data_type input, async_node_type::gateway_type& gateway) {
+        my_activity->submit(input, &gateway);
+        std::printf("ASYNC task=%d started, thread_idx=%d\n", input,
+                    tbb::this_task_arena::current_thread_index());
+    }
+    AsyncSubmissionBody(AsyncActivity* activity) : my_activity(activity) {}
+};
+
+int main() {
+    tbb::task_scheduler_init init(NUM_THREADS);
+    AsyncActivity activity;
+    tbb::flow::graph g;
+
+    tbb::flow::source_node<data_type> starter_node(g, StartBody(), false);
+    tbb::flow::function_node<data_type, data_type> cpu_work_node(g, tbb::flow::unlimited, CpuWorkBody());
+    decider_node_type cpu_restarter_node(g, tbb::flow::unlimited, DeciderBody(CPU_LIMIT));
+    async_node_type async_node(g, tbb::flow::unlimited, AsyncSubmissionBody(&activity));
+    decider_node_type async_restarter_node(g, tbb::flow::unlimited, DeciderBody(ASYNC_LIMIT)
+#if __TBB_PREVIEW_FLOW_GRAPH_PRIORITIES
+                                           , /*priority=*/1
+#endif
+    );
+
+    tbb::flow::make_edge(starter_node, cpu_work_node);
+    tbb::flow::make_edge(cpu_work_node, cpu_restarter_node);
+    tbb::flow::make_edge(tbb::flow::output_port<0>(cpu_restarter_node), cpu_work_node);
+
+    tbb::flow::make_edge(starter_node, async_node);
+    tbb::flow::make_edge(async_node, async_restarter_node);
+    tbb::flow::make_edge(tbb::flow::output_port<0>(async_restarter_node), async_node);
+
+    tbb::tick_count start_time = tbb::tick_count::now();
+    starter_node.activate();
+    g.wait_for_all();
+    activity.stop_and_wait();
+    std::printf("Elapsed time: %lf seconds\n", (tbb::tick_count::now() - start_time).seconds());
+
+    return 0;
+}
diff --git a/src/tbb/src/perf/time_cpq_throughput_test.cpp b/src/tbb/src/perf/time_cpq_throughput_test.cpp
index 02f9bfd3..04f6cc11 100644
--- a/src/tbb/src/perf/time_cpq_throughput_test.cpp
+++ b/src/tbb/src/perf/time_cpq_throughput_test.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #define HARNESS_CUSTOM_MAIN 1
diff --git a/src/tbb/src/perf/time_fibonacci_cutoff.cpp b/src/tbb/src/perf/time_fibonacci_cutoff.cpp
index 2a9e74d0..4e0b2a58 100644
--- a/src/tbb/src/perf/time_fibonacci_cutoff.cpp
+++ b/src/tbb/src/perf/time_fibonacci_cutoff.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 <cstdio>
diff --git a/src/tbb/src/perf/time_framework.h b/src/tbb/src/perf/time_framework.h
index a749dff6..d670e831 100644
--- a/src/tbb/src/perf/time_framework.h
+++ b/src/tbb/src/perf/time_framework.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TIME_FRAMEWORK_H__
diff --git a/src/tbb/src/perf/time_hash_map.cpp b/src/tbb/src/perf/time_hash_map.cpp
index 690d092f..2d87ef25 100644
--- a/src/tbb/src/perf/time_hash_map.cpp
+++ b/src/tbb/src/perf/time_hash_map.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 // configuration:
diff --git a/src/tbb/src/perf/time_hash_map_fill.cpp b/src/tbb/src/perf/time_hash_map_fill.cpp
index f0919375..7e3ca942 100644
--- a/src/tbb/src/perf/time_hash_map_fill.cpp
+++ b/src/tbb/src/perf/time_hash_map_fill.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 // configuration:
diff --git a/src/tbb/src/perf/time_hash_map_fill.html b/src/tbb/src/perf/time_hash_map_fill.html
index 766e85e1..b038ab48 100644
--- a/src/tbb/src/perf/time_hash_map_fill.html
+++ b/src/tbb/src/perf/time_hash_map_fill.html
@@ -8,7 +8,7 @@ <H2>time_hash_map_fill</H2>
 </P>
 <H2>Diagram</H2><img src="time_hash_map_fill.gif"/>
 <H3>Prepare results</H3>
-<P>This benchmark outputs results in Excel* and html file formats by default. To generate text (CSV) file instead, specify STAT_FORMAT=pivot-csv evironment variable. To change the default table size, set TABLE_SIZE.
+<P>This benchmark outputs results in Excel* and html file formats by default. To generate text (CSV) file instead, specify STAT_FORMAT=pivot-csv environment variable. To change the default table size, set TABLE_SIZE.
 <code><b><pre>src$    make time_hash_map_fill args=-v STAT_FORMAT=pivot-csv TABLE_SIZE=250000</pre></b></code>Or to get statistics from different runs:
 <code><b><pre>src$    make time_hash_map_fill TABLE_SIZE=50000 run_cmd="bash ../../src/perf/<a href=run_statistics.sh>run_statistics.sh</a>"</pre></b></code>
 </P>
@@ -112,7 +112,7 @@ <H3>Script body</H3>
 <HR/>
 <A HREF="../index.html">Up to parent directory</A>
 <p></p>
-Copyright &copy; 2005-2017 Intel Corporation.  All Rights Reserved.
+Copyright &copy; 2005-2020 Intel Corporation.  All Rights Reserved.
 <P></P>
 Intel is a registered trademark or trademark of Intel Corporation
 or its subsidiaries in the United States and other countries.
diff --git a/src/tbb/src/perf/time_locked_work.cpp b/src/tbb/src/perf/time_locked_work.cpp
index 3a966bbb..2a7f0bb9 100644
--- a/src/tbb/src/perf/time_locked_work.cpp
+++ b/src/tbb/src/perf/time_locked_work.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 ////// Test configuration ////////////////////////////////////////////////////
diff --git a/src/tbb/src/perf/time_lru_cache_throughput.cpp b/src/tbb/src/perf/time_lru_cache_throughput.cpp
index 151ef061..f7673fb1 100644
--- a/src/tbb/src/perf/time_lru_cache_throughput.cpp
+++ b/src/tbb/src/perf/time_lru_cache_throughput.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 "../examples/common/utility/utility.h"
@@ -38,7 +34,7 @@
 #include <algorithm>
 #include "tbb/mutex.h"
 
-//TODO: probably move this to separate header utlity file
+//TODO: probably move this to separate header utility file
 namespace micro_benchmarking{
 namespace utils{
     template <typename type>
diff --git a/src/tbb/src/perf/time_parallel_for_each.cpp b/src/tbb/src/perf/time_parallel_for_each.cpp
index 10e99c0d..65904fdb 100644
--- a/src/tbb/src/perf/time_parallel_for_each.cpp
+++ b/src/tbb/src/perf/time_parallel_for_each.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 <vector>
diff --git a/src/tbb/src/perf/time_resumable_tasks.cpp b/src/tbb/src/perf/time_resumable_tasks.cpp
new file mode 100644
index 00000000..bcfb824f
--- /dev/null
+++ b/src/tbb/src/perf/time_resumable_tasks.cpp
@@ -0,0 +1,323 @@
+/*
+    Copyright (c) 2005-2020 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.
+*/
+
+#define TBB_PREVIEW_RESUMABLE_TASKS 1
+#include "tbb/tbb_config.h"
+
+#include "tbb/task.h"
+#include "tbb/task_group.h"
+#include "tbb/task_scheduler_init.h"
+#include "tbb/tick_count.h"
+
+#include "tbb/parallel_for.h"
+
+#include <vector>
+#include <stack>
+#include <functional>
+#include <numeric>
+#include <algorithm>
+
+/************************************************************************/
+/* SETTINGS                                                             */
+/************************************************************************/
+
+const int DEF_BENCH_RUNS = 1000;
+
+/************************************************************************/
+/* HELPERS                                                              */
+/************************************************************************/
+
+#include "harness_perf.h" // harness_perf::median
+
+template<typename T>
+T get_median(std::vector<T>& times) {
+    return harness_perf::median(times.begin(), times.end());
+}
+
+/************************************************************************/
+/* SERIAL BENCHMARKS                                                    */
+/************************************************************************/
+
+//! Allocate COROUTINES_NUM fibers in a row (suspend) in a recursive manner
+//! and then swith back (resume) unwinding the ctx_stack.
+void BenchCoroutinesAllocation() {
+    tbb::task_scheduler_init init(1);
+
+    const int COROUTINES_NUM = 100;
+    std::stack<tbb::task::suspend_point> ctx_stack;
+    tbb::task_group tg;
+
+    std::function<void(int)> recursive_f;
+    recursive_f = [=, &ctx_stack, &tg, &recursive_f](int i) {
+        if (i < COROUTINES_NUM) {
+            tg.run([&recursive_f, i]() {
+                recursive_f(i + 1);
+            });
+            tbb::task::suspend([&ctx_stack](tbb::task::suspend_point ctx) {
+                ctx_stack.push(ctx);
+            });
+        }
+        if (ctx_stack.size() != 0) {
+            tbb::task::suspend_point ctx = ctx_stack.top(); ctx_stack.pop();
+            tbb::task::resume(ctx);
+        }
+    };
+    tg.run([=, &recursive_f]() {
+        std::vector<double> times;
+        for (int i = 0; i < DEF_BENCH_RUNS; i++) {
+            tbb::tick_count tick = tbb::tick_count::now();
+            recursive_f(1);
+            double interval = (tbb::tick_count::now() - tick).seconds() * 1e6;
+            times.push_back(interval);
+        }
+        // COROUTINES_NUM suspend and resume operations in each run
+        double median = get_median(times) / double(COROUTINES_NUM);
+        printf("Test 1 (Coroutines alloc/dealloc): Median time (microseconds): %.4f\n", median);
+    });
+    tg.wait();
+}
+
+//! Create a task, which suspends and resumes intself, thus reusing once created coroutine
+void BenchReusage() {
+    tbb::task_scheduler_init init(1);
+    tbb::task_group tg;
+
+    std::vector<double> times;
+    tg.run([&times]() {
+        for (int i = 0; i < DEF_BENCH_RUNS * 10; i++) {
+            tbb::tick_count tick = tbb::tick_count::now();
+            tbb::task::suspend([](tbb::task::suspend_point ctx) {
+                tbb::task::resume(ctx);
+            });
+            double diff = (tbb::tick_count::now() - tick).seconds() * 1e6;
+            times.push_back(diff);
+        }
+    });
+    tg.wait();
+    double median = get_median(times);
+    printf("Test 2 (Coroutine reusage): Median time (microseconds): %.4f\n", median);
+}
+
+//! Create two tasks and switch between them (suspend current and resume previously suspended coroutine)
+//! Measure an average time of the context switch
+void BenchContextSwitch() {
+    tbb::task_scheduler_init init(1);
+    tbb::task_group tg;
+    const int N = 10000; // number of switches
+    const int tasks_num = 2;
+
+    std::vector<double> times;
+    for (int i = 0; i < 100; ++i) {
+        int switch_counter = N;
+        tbb::task::suspend_point current_ctx = NULL;
+
+        tbb::tick_count tick = tbb::tick_count::now();
+        for (int j = 0; j < tasks_num; ++j) {
+            tg.run([=, &switch_counter, &current_ctx]() {
+                while (switch_counter-- > 0) {
+                    tbb::task::suspend([=, &switch_counter, &current_ctx](tbb::task::suspend_point ctx) {
+                        if (switch_counter == N - 1) {
+                            current_ctx = ctx;
+                        } else {
+                            tbb::task::suspend_point ctx_to_resume = current_ctx;
+                            current_ctx = ctx;
+                            tbb::task::resume(ctx_to_resume);
+                        }
+                    });
+                }
+                if (switch_counter == -1) {
+                    tbb::task::resume(current_ctx);
+                }
+            });
+        }
+        tg.wait();
+        // To get an average context switch time divide the bench time by the number of context switches
+        double diff = ((tbb::tick_count::now() - tick).seconds() / double(N)) * 1e6;
+        times.push_back(diff);
+    }
+    printf("Test 3 (Context Switch): Median time (microseconds): %.4f\n", get_median(times));
+}
+
+/************************************************************************/
+/* PARALLEL BENCHMARKS                                                  */
+/************************************************************************/
+
+//! Strong scaling benchmark with predefined number of iterations (N), each parallel_for task
+//! suspends and resumes itself with a predefined busy-waiting iterations (work size).
+//! Reports 3 numbers: serial, half of the machine, and full available concurrency
+template <bool UseResumableTasks>
+void ScalabilityBenchmark(const size_t work_size) {
+    const int N = 1000;
+    const int NUM_THREADS = tbb::task_scheduler_init::default_num_threads();
+    const int STEP_RATIO = 2;
+
+    // Count 3 scalability metrics: the serial, half and full machine concurrency
+    for (int i = 0; i <= NUM_THREADS; i += (NUM_THREADS / STEP_RATIO)) {
+        const int concurrency = (i == 0) ? 1 : i; // just to make step loop nice looking
+        tbb::task_scheduler_init init(concurrency);
+        std::vector<double> times;
+        for (int j = 0; j < 100; j++) {
+            tbb::tick_count tick = tbb::tick_count::now();
+            tbb::parallel_for(0, N, [&work_size](const int /*j*/) {
+                if (UseResumableTasks) {
+                    tbb::task::suspend([](tbb::task::suspend_point ctx) {
+                        tbb::task::resume(ctx);
+                    });
+                }
+                for (volatile size_t k = 0; k < work_size; ++k);
+            }, tbb::simple_partitioner());
+            double diff = (tbb::tick_count::now() - tick).seconds() * 1e3;
+            times.push_back(diff);
+        }
+        printf("Test 4 (Scalability): Work Size: %zu, With RT-feature: %s, Concurrency: %d, Time (milliseconds): %.4f\n",
+                work_size, (UseResumableTasks ? "true" : "false"), concurrency, get_median(times));
+    }
+}
+
+/************************************************************************/
+/* NATIVE IMPLEMENTATION                                                */
+/************************************************************************/
+
+// Dependencies section for co_context.h
+
+#if _WIN32
+#include <windows.h> // GetSystemInfo
+#else
+#include <unistd.h> // sysconf(_SC_PAGESIZE)
+#endif
+
+namespace tbb {
+namespace internal {
+//! System dependent impl
+inline size_t GetDefaultSystemPageSize() {
+#if _WIN32
+    SYSTEM_INFO si;
+    GetSystemInfo(&si);
+    return si.dwPageSize;
+#else
+    return sysconf(_SC_PAGESIZE);
+#endif
+}
+class governor {
+    //! Caches the size of OS regular memory page
+    static size_t DefaultPageSize;
+public:
+    //! Staic accessor for OS regular memory page size
+    static size_t default_page_size () {
+        return DefaultPageSize ? DefaultPageSize : DefaultPageSize = GetDefaultSystemPageSize();
+    }
+};
+size_t governor::DefaultPageSize;
+} // namespace internal
+} // namespace tbb
+
+// No-op versions of __TBB_ASSERT/EX for co_context.h header
+#define __TBB_ASSERT(predicate,comment) ((void)0)
+#define __TBB_ASSERT_EX(predicate,comment) ((void)(1 && (predicate)))
+
+// TBB coroutines implementation
+// Disable governor header to remove the dependency
+#define _TBB_governor_H
+#include "../tbb/co_context.h"
+using namespace tbb::internal;
+#undef _TBB_governor_H
+
+#define HARNESS_CUSTOM_MAIN 1
+#include "../test/harness.h" // NativeParallelFor
+
+namespace tbb {
+namespace internal {
+// Our native coroutine function
+#if _WIN32
+/* [[noreturn]] */ inline void __stdcall co_local_wait_for_all(void* arg) {
+#else
+/* [[noreturn]] */ inline void co_local_wait_for_all(void* arg) {
+#endif
+    coroutine_type next = *static_cast<coroutine_type*>(arg);
+    coroutine_type current; current_coroutine(current);
+    swap_coroutine(current, next);
+}
+} // namespace internal
+} // namespace tbb
+
+// The same scalability benchmark as for TBB, but written with native OS fibers implementation
+void BenchNativeImpl(const size_t work_size) {
+    const int N = 1000;
+    const int NUM_THREADS = tbb::task_scheduler_init::default_num_threads();
+    const int STEP_RATIO = 2;
+    const size_t STACK_SIZE = 4 * 1024 * 1024; // Just like default TBB worker thread stack size
+
+    // Count 3 scalability metrics: the serial, half and full machine concurrency
+    for (int i = 0; i <= NUM_THREADS; i += (NUM_THREADS / STEP_RATIO)) {
+        const int concurrency = (i == 0) ? 1 : i; // just to make step loop nice looking
+        const int sub_range = N / concurrency;
+        std::vector<double> times;
+        for (int r = 0; r < 100; r++) {
+            tbb::tick_count tick = tbb::tick_count::now();
+            NativeParallelFor(concurrency, [=, &work_size, &sub_range](int /*idx*/) {
+                // Each iteration of sub-range emulates a single TBB task
+                for (int j = 0; j < sub_range; j++) {
+                    coroutine_type co_next;
+                    coroutine_type co_current; current_coroutine(co_current);
+                    create_coroutine(co_next, STACK_SIZE, &co_current);
+                    swap_coroutine(co_current, co_next);
+
+                    // Busy-wait for a while emulating some work
+                    for (volatile size_t k = 0; k < work_size; ++k);
+                    destroy_coroutine(co_next);
+                }
+            });
+            double diff = (tbb::tick_count::now() - tick).seconds() * 1e3;
+            times.push_back(diff);
+        }
+        printf("Test 5 (Native Implementation): Work size: %zu, Concurrency: %d, Time (milliseconds): %.4f\n",
+                work_size, concurrency, get_median(times));
+    }
+}
+
+/************************************************************************/
+/* MAIN DRIVER                                                          */
+/************************************************************************/
+
+int main() {
+    // Serial microbenchmarks
+    BenchCoroutinesAllocation();
+    BenchReusage();
+    BenchContextSwitch();
+
+    // Scalability benchmarks
+    // Big work size + no resumable tasks feature (false)
+    ScalabilityBenchmark<false>(100000);
+    // Big work size + resumable tasks feature (true)
+    ScalabilityBenchmark<true>(100000);
+    // Small work size + no resumable tasks feature (false)
+    ScalabilityBenchmark<false>(1000);
+    // Small work size + resumable tasks feature (true)
+    ScalabilityBenchmark<true>(1000);
+    // No any work + just resumable tasks feature (true)
+    ScalabilityBenchmark<true>(0);
+
+    // Native implementation
+    // Big work size
+    BenchNativeImpl(100000);
+    // Small work size
+    BenchNativeImpl(1000);
+    // Just coroutines/fibers switching
+    BenchNativeImpl(0);
+
+    return 0;
+}
+
diff --git a/src/tbb/src/perf/time_sandbox.h b/src/tbb/src/perf/time_sandbox.h
index 120b1b50..2b7ca7cf 100644
--- a/src/tbb/src/perf/time_sandbox.h
+++ b/src/tbb/src/perf/time_sandbox.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TIME_FRAMEWORK_H__
diff --git a/src/tbb/src/perf/time_split_node.cpp b/src/tbb/src/perf/time_split_node.cpp
index dab9ac42..f19c209c 100644
--- a/src/tbb/src/perf/time_split_node.cpp
+++ b/src/tbb/src/perf/time_split_node.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 <iostream>
diff --git a/src/tbb/src/perf/time_vector.cpp b/src/tbb/src/perf/time_vector.cpp
index 02ae84c7..ca23758a 100644
--- a/src/tbb/src/perf/time_vector.cpp
+++ b/src/tbb/src/perf/time_vector.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 //#define DO_SCALABLEALLOC
diff --git a/src/tbb/src/rml/client/index.html b/src/tbb/src/rml/client/index.html
index 53152ca9..81a02952 100644
--- a/src/tbb/src/rml/client/index.html
+++ b/src/tbb/src/rml/client/index.html
@@ -31,7 +31,7 @@ <H3> Specific to client=TBB</H3>
 <HR/>
 <A HREF="../index.html">Up to parent directory</A>
 <p></p>
-Copyright &copy; 2005-2017 Intel Corporation.  All Rights Reserved.
+Copyright &copy; 2005-2020 Intel Corporation.  All Rights Reserved.
 <P></P>
 Intel is a registered trademark or trademark of Intel Corporation
 or its subsidiaries in the United States and other countries.
diff --git a/src/tbb/src/rml/client/library_assert.h b/src/tbb/src/rml/client/library_assert.h
index df3fcdbd..18ef9eb8 100644
--- a/src/tbb/src/rml/client/library_assert.h
+++ b/src/tbb/src/rml/client/library_assert.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef LIBRARY_ASSERT_H
diff --git a/src/tbb/src/rml/client/omp_dynamic_link.cpp b/src/tbb/src/rml/client/omp_dynamic_link.cpp
index e9a8d2e4..71fdb234 100644
--- a/src/tbb/src/rml/client/omp_dynamic_link.cpp
+++ b/src/tbb/src/rml/client/omp_dynamic_link.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 "omp_dynamic_link.h"
diff --git a/src/tbb/src/rml/client/omp_dynamic_link.h b/src/tbb/src/rml/client/omp_dynamic_link.h
index 30202931..576c21f3 100644
--- a/src/tbb/src/rml/client/omp_dynamic_link.h
+++ b/src/tbb/src/rml/client/omp_dynamic_link.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __KMP_omp_dynamic_link_H
diff --git a/src/tbb/src/rml/client/rml_factory.h b/src/tbb/src/rml/client/rml_factory.h
index 0c4626a9..0d6d6720 100644
--- a/src/tbb/src/rml/client/rml_factory.h
+++ b/src/tbb/src/rml/client/rml_factory.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 // No ifndef guard because this file is not a normal include file.
@@ -33,7 +29,7 @@
 #define RML_SERVER_NAME "libirml" DEBUG_SUFFIX ".dylib"
 #elif __linux__
 #define RML_SERVER_NAME "libirml" DEBUG_SUFFIX ".so.1"
-#elif __FreeBSD__ || __NetBSD__ || __sun || _AIX
+#elif __FreeBSD__ || __NetBSD__ || __OpenBSD__ || __sun || _AIX
 #define RML_SERVER_NAME "libirml" DEBUG_SUFFIX ".so"
 #else
 #error Unknown OS
diff --git a/src/tbb/src/rml/client/rml_omp.cpp b/src/tbb/src/rml/client/rml_omp.cpp
index 86935ed2..114ab90e 100644
--- a/src/tbb/src/rml/client/rml_omp.cpp
+++ b/src/tbb/src/rml/client/rml_omp.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 "rml_omp.h"
diff --git a/src/tbb/src/rml/client/rml_tbb.cpp b/src/tbb/src/rml/client/rml_tbb.cpp
index 5842d1ed..648c9276 100644
--- a/src/tbb/src/rml/client/rml_tbb.cpp
+++ b/src/tbb/src/rml/client/rml_tbb.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 "../include/rml_tbb.h"
diff --git a/src/tbb/src/rml/include/index.html b/src/tbb/src/rml/include/index.html
index 46c8b0a7..d0bbf05b 100644
--- a/src/tbb/src/rml/include/index.html
+++ b/src/tbb/src/rml/include/index.html
@@ -18,7 +18,7 @@ <H2>Files</H2>
 <HR>
 <A HREF="../index.html">Up to parent directory</A>
 <p></p>
-Copyright &copy; 2005-2017 Intel Corporation.  All Rights Reserved.
+Copyright &copy; 2005-2020 Intel Corporation.  All Rights Reserved.
 <P></P>
 Intel is a registered trademark or trademark of Intel Corporation
 or its subsidiaries in the United States and other countries.
diff --git a/src/tbb/src/rml/include/rml_base.h b/src/tbb/src/rml/include/rml_base.h
index 951026fa..8303b9ae 100644
--- a/src/tbb/src/rml/include/rml_base.h
+++ b/src/tbb/src/rml/include/rml_base.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 // Header guard and namespace names follow rml conventions.
diff --git a/src/tbb/src/rml/include/rml_omp.h b/src/tbb/src/rml/include/rml_omp.h
index 103936bb..6838d48c 100644
--- a/src/tbb/src/rml/include/rml_omp.h
+++ b/src/tbb/src/rml/include/rml_omp.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 // Header guard and namespace names follow OpenMP runtime conventions.
@@ -64,10 +60,10 @@ class omp_server: public ::rml::server {
        Note: conversion between a coin and a thread does not affect the accounting.
      */
 #if _WIN32||_WIN64
-    //! Inform server of a tbb master thread.
+    //! Inform server of a TBB master thread.
     virtual void register_master( execution_resource_t& /*v*/ ) = 0;
 
-    //! Inform server that the tbb master thread is done with its work.
+    //! Inform server that the TBB master thread is done with its work.
     virtual void unregister_master( execution_resource_t /*v*/ ) = 0;
  
     //! deactivate
diff --git a/src/tbb/src/rml/include/rml_tbb.h b/src/tbb/src/rml/include/rml_tbb.h
index ce47f175..452a8967 100644
--- a/src/tbb/src/rml/include/rml_tbb.h
+++ b/src/tbb/src/rml/include/rml_tbb.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 // Header guard and namespace names follow TBB conventions.
@@ -36,17 +32,17 @@ class tbb_client;
 // Classes instantiated by the server
 //------------------------------------------------------------------------
 
-//! Represents a set of tbb worker threads provided by the server.
+//! Represents a set of TBB worker threads provided by the server.
 class tbb_server: public ::rml::server {
 public:
     //! Inform server of adjustments in the number of workers that the client can profitably use.
     virtual void adjust_job_count_estimate( int delta ) = 0;
 
 #if _WIN32||_WIN64
-    //! Inform server of a tbb master thread.
+    //! Inform server of a TBB master thread.
     virtual void register_master( execution_resource_t& v ) = 0;
 
-    //! Inform server that the tbb master thread is done with its work.
+    //! Inform server that the TBB master thread is done with its work.
     virtual void unregister_master( execution_resource_t v ) = 0;
 #endif /* _WIN32||_WIN64 */
 };
diff --git a/src/tbb/src/rml/index.html b/src/tbb/src/rml/index.html
index 7c8e7ea2..b974713b 100644
--- a/src/tbb/src/rml/index.html
+++ b/src/tbb/src/rml/index.html
@@ -20,7 +20,7 @@ <H2>Directories</H2>
 <HR>
 <A HREF="../index.html">Up to parent directory</A>
 <p></p>
-Copyright &copy; 2005-2017 Intel Corporation.  All Rights Reserved.
+Copyright &copy; 2005-2020 Intel Corporation.  All Rights Reserved.
 <P></P>
 Intel is a registered trademark or trademark of Intel Corporation
 or its subsidiaries in the United States and other countries.
diff --git a/src/tbb/src/rml/perfor/omp_nested.cpp b/src/tbb/src/rml/perfor/omp_nested.cpp
index f0f675fe..34ac3742 100644
--- a/src/tbb/src/rml/perfor/omp_nested.cpp
+++ b/src/tbb/src/rml/perfor/omp_nested.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 <cstddef>
diff --git a/src/tbb/src/rml/perfor/omp_simple.cpp b/src/tbb/src/rml/perfor/omp_simple.cpp
index 334b5717..12e4e5b2 100644
--- a/src/tbb/src/rml/perfor/omp_simple.cpp
+++ b/src/tbb/src/rml/perfor/omp_simple.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 <cstddef>
diff --git a/src/tbb/src/rml/perfor/tbb_multi_omp.cpp b/src/tbb/src/rml/perfor/tbb_multi_omp.cpp
index b324d13f..0fc28b73 100644
--- a/src/tbb/src/rml/perfor/tbb_multi_omp.cpp
+++ b/src/tbb/src/rml/perfor/tbb_multi_omp.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 <cstddef>
diff --git a/src/tbb/src/rml/perfor/tbb_simple.cpp b/src/tbb/src/rml/perfor/tbb_simple.cpp
index b00bad93..4435ece1 100644
--- a/src/tbb/src/rml/perfor/tbb_simple.cpp
+++ b/src/tbb/src/rml/perfor/tbb_simple.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 <cstddef>
diff --git a/src/tbb/src/rml/perfor/thread_level.h b/src/tbb/src/rml/perfor/thread_level.h
index 6a2912ee..ca416c0e 100644
--- a/src/tbb/src/rml/perfor/thread_level.h
+++ b/src/tbb/src/rml/perfor/thread_level.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 // Thread level recorder
diff --git a/src/tbb/src/rml/server/index.html b/src/tbb/src/rml/server/index.html
index dc248746..a32f8f42 100644
--- a/src/tbb/src/rml/server/index.html
+++ b/src/tbb/src/rml/server/index.html
@@ -7,7 +7,7 @@ <H2>Overview</H2>
 <HR>
 <A HREF="../index.html">Up to parent directory</A>
 <p></p>
-Copyright &copy; 2005-2017 Intel Corporation.  All Rights Reserved.
+Copyright &copy; 2005-2020 Intel Corporation.  All Rights Reserved.
 <P></P>
 Intel is a registered trademark or trademark of Intel Corporation
 or its subsidiaries in the United States and other countries.
diff --git a/src/tbb/src/rml/server/irml.rc b/src/tbb/src/rml/server/irml.rc
index 73a84f83..8ab95998 100644
--- a/src/tbb/src/rml/server/irml.rc
+++ b/src/tbb/src/rml/server/irml.rc
@@ -1,4 +1,4 @@
-// Copyright (c) 2005-2017 Intel Corporation
+// Copyright (c) 2005-2020 Intel Corporation
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -11,10 +11,6 @@
 // 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.
-//
-//
-//
-//
 
 // Microsoft Visual C++ generated resource script.
 //
@@ -81,7 +77,7 @@ BEGIN
             VALUE "CompanyName", "Intel Corporation\0"
             VALUE "FileDescription", "Intel(R) Threading Building Blocks resource manager library\0"
             VALUE "FileVersion", TBB_VERSION "\0"
-            VALUE "LegalCopyright", "Copyright 2005-2017 Intel Corporation.  All Rights Reserved.\0"
+            VALUE "LegalCopyright", "Copyright 2005-2020 Intel Corporation.  All Rights Reserved.\0"
             VALUE "LegalTrademarks", "\0"
 #ifndef TBB_USE_DEBUG
             VALUE "OriginalFilename", "irml.dll\0"
diff --git a/src/tbb/src/rml/server/job_automaton.h b/src/tbb/src/rml/server/job_automaton.h
index 8fe81c96..548f9749 100644
--- a/src/tbb/src/rml/server/job_automaton.h
+++ b/src/tbb/src/rml/server/job_automaton.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __RML_job_automaton_H
diff --git a/src/tbb/src/rml/server/lin-rml-export.def b/src/tbb/src/rml/server/lin-rml-export.def
index 5fb069b4..fe116f68 100644
--- a/src/tbb/src/rml/server/lin-rml-export.def
+++ b/src/tbb/src/rml/server/lin-rml-export.def
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 {
diff --git a/src/tbb/src/rml/server/rml_server.cpp b/src/tbb/src/rml/server/rml_server.cpp
index b2597416..d73c6e66 100644
--- a/src/tbb/src/rml/server/rml_server.cpp
+++ b/src/tbb/src/rml/server/rml_server.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 "rml_tbb.h"
@@ -53,7 +49,7 @@
 #include <concrtrm.h>
 using namespace Concurrency;
 #include <vector>
-#include <hash_map>
+#include <unordered_map>
 #define __RML_REMOVE_VIRTUAL_PROCESSORS_DISABLED 0
 #endif /* RML_USE_WCRM */
 
@@ -151,7 +147,7 @@ enum thread_state_t {
     ts_omp_busy,
     //! Thread is busy doing TBB work.
     ts_tbb_busy,
-    //! For tbb threads only
+    //! For TBB threads only
     ts_done,
     ts_created,
     ts_started,
@@ -874,7 +870,7 @@ thread_map::size_type thread_map::wakeup_tbb_threads( size_type n ) {
 
 class thread_map : no_copy {
     friend class omp_connection_v2;
-    typedef ::std::hash_map<uintptr_t,server_thread*> hash_map_type;
+    typedef ::std::unordered_map<uintptr_t,server_thread*> unordered_map_type;
     size_t my_min_stack_size;
     size_t my_unrealized_threads;
     ::rml::client& my_client;
@@ -884,7 +880,7 @@ class thread_map : no_copy {
     ref_count my_server_ref_count;
     ref_count my_client_ref_count;
     // FIXME: pad this?
-    hash_map_type my_map;
+    unordered_map_type my_map;
     bool shutdown_in_progress;
     std::vector<IExecutionResource*> original_exec_resources;
     tbb::cache_aligned_allocator<padded<tbb_server_thread> > my_tbb_allocator;
@@ -922,7 +918,7 @@ class thread_map : no_copy {
             my_scavenger_allocator.deallocate(static_cast<padded<thread_scavenger_thread>*>(tst),1);
         }
         // deallocate thread contexts
-        for( hash_map_type::const_iterator hi=my_map.begin(); hi!=my_map.end(); ++hi ) {
+        for( unordered_map_type::const_iterator hi=my_map.begin(); hi!=my_map.end(); ++hi ) {
             server_thread* thr = hi->second;
             if( thr->tbb_thread ) {
                 while( ((tbb_server_thread*)thr)->activation_count>1 )
@@ -943,9 +939,9 @@ class thread_map : no_copy {
             __TBB_ASSERT( !my_scheduler, NULL );
         }
     }
-    typedef hash_map_type::key_type key_type;
-    typedef hash_map_type::value_type value_type;
-    typedef hash_map_type::iterator iterator;
+    typedef unordered_map_type::key_type key_type;
+    typedef unordered_map_type::value_type value_type;
+    typedef unordered_map_type::iterator iterator;
     iterator begin() {return my_map.begin();}
     iterator end() {return my_map.end();}
     iterator find( key_type k ) {return my_map.find( k );}
@@ -1009,7 +1005,7 @@ connection_scavenger_thread connection_scavenger;
 template<typename Server, typename Client>
 struct connection_traits {};
 
-// head of the active tbb connections
+// head of the active TBB connections
 static tbb::atomic<uintptr_t> active_tbb_connections;
 static tbb::atomic<int> current_tbb_conn_readers;
 static size_t current_tbb_conn_reader_epoch;
@@ -1385,7 +1381,7 @@ template<typename Server, typename Client>
 void generic_connection<Server,Client>::request_close_connection( bool ) {
 #endif /* RML_USE_WCRM */
     if( connection_traits<Server,Client>::is_tbb ) {
-        // acquire the head of active tbb connections
+        // acquire the head of active TBB connections
         uintptr_t conn;
         do {
             for( ; (conn=active_tbb_connections)&1; )
@@ -1406,7 +1402,7 @@ void generic_connection<Server,Client>::request_close_connection( bool ) {
         } else
             active_tbb_connections = (uintptr_t) curr_conn->next_conn; // update & release it
         curr_conn->next_conn = NULL;
-        // Increment the tbb connection close event count
+        // Increment the TBB connection close event count
         my_ec = ++close_tbb_connection_event_count;
         // Wait happens in tbb_connection_v2::~tbb_connection_v2()
     }
@@ -1676,12 +1672,12 @@ void omp_connection_v2::reactivate( rml::job* j )
 
 #endif  /* RML_USE_WCRM */
 
-//! Wake up some available tbb threads
+//! Wake up some available TBB threads
 void wakeup_some_tbb_threads()
 {
     /* First, atomically grab the connection, then increase the server ref count to keep
        it from being released prematurely.  Second, check if the balance is available for TBB
-       and the tbb conneciton has slack to exploit.  If the answer is true, go ahead and
+       and the TBB connection has slack to exploit.  If the answer is true, go ahead and
        try to wake some up. */
     if( generic_connection<tbb_server,tbb_client >::get_addr(active_tbb_connections)==0 )
         // the next connection will see the change; return.
@@ -1691,7 +1687,7 @@ void wakeup_some_tbb_threads()
     int n_curr_readers = ++current_tbb_conn_readers;
     if( n_curr_readers>1 ) // I lost
         return;
-    // if n_curr_readers==1, i am the first one, so I will take responsibility for waking tbb threads up.
+    // if n_curr_readers==1, i am the first one, so I will take responsibility for waking TBB threads up.
 
     // update the current epoch
     current_tbb_conn_reader_epoch = close_tbb_connection_event_count;
@@ -1706,7 +1702,7 @@ void wakeup_some_tbb_threads()
     generic_connection<tbb_server,tbb_client>* next_conn_wake_up = generic_connection<tbb_server,tbb_client>::get_addr( active_tbb_connections );
 
     for( ; next_conn_wake_up; ) {
-        /* some threads are creating tbb server threads; they may not see my changes made to the_balance */
+        /* some threads are creating TBB server threads; they may not see my changes made to the_balance */
         /* When a thread is in adjust_job_count_estimate() to increase the slack
            RML tries to activate worker threads on behalf of the requesting thread
            by repeatedly drawing a coin from the bank optimistically and grabbing a
@@ -2080,7 +2076,7 @@ void server_thread::loop() {
         if( s==ts_omp_busy ) {
             // Enslaved by OpenMP team.
             omp_dispatch.consume();
-            /* here wake tbb threads up if feasible */
+            /* here wake TBB threads up if feasible */
             if( ++the_balance>0 )
                 wakeup_some_tbb_threads();
             state = ts_idle;
@@ -2113,7 +2109,7 @@ void server_thread::loop() {
                     }
                 } // else the new request will see my changes to state & the_balance.
             }
-            /* here wake tbb threads up if feasible */
+            /* here wake TBB threads up if feasible */
             if( the_balance>0 )
                 wakeup_some_tbb_threads();
         }
@@ -2233,7 +2229,7 @@ void tbb_server_thread::Dispatch( DispatchState* ) {
     make_job( *tbb_conn, *this );
 
     for( ;; ) {
-        // Try to wake some tbb threads if the balance is positive.
+        // Try to wake some TBB threads if the balance is positive.
         // When a thread is added by ConcRT and enter here for the first time,
         // the thread may wake itself up (i.e., atomically change its state to ts_busy.
         if( the_balance>0 )
@@ -2356,8 +2352,8 @@ bool tbb_server_thread::switch_out() {
             // the thread's state should be either ts_idle or ts_done.
             while( is_removed() )
                 __TBB_Yield();
-            thread_state_t s = read_state();
-            __TBB_ASSERT( s==ts_idle || s==ts_done, NULL );
+            thread_state_t state = read_state();
+            __TBB_ASSERT( state==ts_idle || state==ts_done, NULL );
         }
 #endif
         __TBB_ASSERT( my_state==ts_asleep||my_state==ts_idle, NULL );
@@ -2712,7 +2708,7 @@ void thread_map::mark_virtual_processors_as_lent( IVirtualProcessorRoot** vproot
         iterator i = my_map.find( (key_type) vproots[c] );
         if( i==end ) {
             // The vproc has not been added to the map in create_oversubscribers()
-            my_map.insert( hash_map_type::value_type( (key_type) vproots[c], (server_thread*)1 ) );
+            my_map.insert( unordered_map_type::value_type( (key_type) vproots[c], (server_thread*)1 ) );
         } else {
             server_thread* thr = (*i).second;
             if( ((uintptr_t)thr)&~(uintptr_t)1 ) {
@@ -2730,8 +2726,8 @@ void thread_map::create_oversubscribers( unsigned n, std::vector<server_thread*>
         curr_exec_rsc = original_exec_resources; // copy construct
     }
     typedef std::vector<IExecutionResource*>::iterator iterator_er;
-    typedef ::std::vector<std::pair<hash_map_type::key_type, hash_map_type::mapped_type> > hash_val_vector_t;
-    hash_val_vector_t v_vec(n);
+    typedef ::std::vector<std::pair<unordered_map_type::key_type, unordered_map_type::mapped_type> > map_val_vector_t;
+    map_val_vector_t v_vec(n);
     iterator_er begin = curr_exec_rsc.begin();
     iterator_er end   = curr_exec_rsc.end();
     iterator_er i = begin;
@@ -2739,7 +2735,7 @@ void thread_map::create_oversubscribers( unsigned n, std::vector<server_thread*>
         IVirtualProcessorRoot* vpr = my_scheduler_proxy->CreateOversubscriber( *i );
         omp_server_thread* t = new ( my_omp_allocator.allocate(1) ) omp_server_thread( true, my_scheduler, (IExecutionResource*)vpr, &conn, *this, my_client );
         thr_vec[c] = t;
-        v_vec[c] = hash_map_type::value_type( (key_type) vpr, t );
+        v_vec[c] = unordered_map_type::value_type( (key_type) vpr, t );
         if( ++i==end ) i = begin;
     }
 
@@ -2748,17 +2744,17 @@ void thread_map::create_oversubscribers( unsigned n, std::vector<server_thread*>
 
         if( is_closing() ) return;
 
-        iterator end = my_map.end();
+        iterator map_end = my_map.end();
         unsigned c = 0;
-        for( hash_val_vector_t::iterator vi=v_vec.begin(); vi!=v_vec.end(); ++vi, ++c ) {
-            iterator i = my_map.find( (key_type) (*vi).first );
-            if( i==end ) {
+        for( map_val_vector_t::iterator vi=v_vec.begin(); vi!=v_vec.end(); ++vi, ++c ) {
+            iterator j = my_map.find( (key_type) (*vi).first );
+            if( j==map_end ) {
                 my_map.insert( *vi );
             } else {
                 // the vproc has not been added to the map in mark_virtual_processors_as_returned();
-                uintptr_t lent = (uintptr_t) (*i).second;
+                uintptr_t lent = (uintptr_t) (*j).second;
                 __TBB_ASSERT( lent<=1, "vproc map entry added incorrectly?");
-                (*i).second = thr_vec[c];
+                (*j).second = thr_vec[c];
                 if( lent )
                     ((omp_server_thread*)thr_vec[c])->set_lent();
                 else
@@ -2841,7 +2837,7 @@ void thread_map::mark_virtual_processors_as_returned( IVirtualProcessorRoot** vp
             iterator i = my_map.find( (key_type) vprocs[c] );
             if( i==end ) {
                 // the vproc has not been added to the map in create_oversubscribers()
-                my_map.insert( hash_map_type::value_type( (key_type) vprocs[c], static_cast<server_thread*>(0) ) );
+                my_map.insert( unordered_map_type::value_type( (key_type) vprocs[c], static_cast<server_thread*>(0) ) );
             } else {
                 omp_server_thread* thr = (omp_server_thread*) (*i).second;
                 if( ((uintptr_t)thr)&~(uintptr_t)1 ) {
diff --git a/src/tbb/src/rml/server/thread_monitor.h b/src/tbb/src/rml/server/thread_monitor.h
index e7ea79e4..5793cb2b 100644
--- a/src/tbb/src/rml/server/thread_monitor.h
+++ b/src/tbb/src/rml/server/thread_monitor.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 // All platform-specific threading support is encapsulated here. */
@@ -28,7 +24,7 @@
 #include <process.h>
 #include <malloc.h> //_alloca
 #include "tbb/tbb_misc.h" // support for processor groups
-#if __TBB_WIN8UI_SUPPORT
+#if __TBB_WIN8UI_SUPPORT && (_WIN32_WINNT < 0x0A00)
 #include <thread>
 #endif
 #elif USE_PTHREAD
@@ -78,7 +74,7 @@ class thread_monitor {
         friend class thread_monitor;
         tbb::atomic<size_t> my_epoch;
     };
-    thread_monitor() : spurious(false), my_sema() {
+    thread_monitor() : skipped_wakeup(false), my_sema() {
         my_cookie.my_epoch = 0;
         ITT_SYNC_CREATE(&my_sema, SyncType_RML, SyncObj_ThreadMonitor);
         in_wait = false;
@@ -129,9 +125,9 @@ class thread_monitor {
     //! Detach thread
     static void detach_thread(handle_type handle);
 private:
-    cookie my_cookie;
-    tbb::atomic<bool>   in_wait;
-    bool   spurious;
+    cookie my_cookie; // epoch counter
+    tbb::atomic<bool> in_wait;
+    bool skipped_wakeup;
     tbb::internal::binary_semaphore my_sema;
 #if USE_PTHREAD
     static void check( int error_code, const char* routine );
@@ -144,13 +140,14 @@ class thread_monitor {
 #define STACK_SIZE_PARAM_IS_A_RESERVATION 0x00010000
 #endif
 
-#if __TBB_WIN8UI_SUPPORT
+// _beginthreadex API is not available in Windows 8 Store* applications, so use std::thread instead
+#if __TBB_WIN8UI_SUPPORT && (_WIN32_WINNT < 0x0A00)
 inline thread_monitor::handle_type thread_monitor::launch( thread_routine_type thread_function, void* arg, size_t, const size_t*) {
 //TODO: check that exception thrown from std::thread is not swallowed silently
     std::thread* thread_tmp=new std::thread(thread_function, arg);
     return thread_tmp->native_handle();
 }
-#else //__TBB_WIN8UI_SUPPORT
+#else
 inline thread_monitor::handle_type thread_monitor::launch( thread_routine_type thread_routine, void* arg, size_t stack_size, const size_t* worker_index ) {
     unsigned thread_id;
     int number_of_processor_groups = ( worker_index ) ? tbb::internal::NumberOfProcessorGroups() : 0;
@@ -167,7 +164,7 @@ inline thread_monitor::handle_type thread_monitor::launch( thread_routine_type t
     }
     return h;
 }
-#endif //__TBB_WIN8UI_SUPPORT
+#endif //__TBB_WIN8UI_SUPPORT && (_WIN32_WINNT < 0x0A00)
 
 void thread_monitor::join(handle_type handle) {
 #if TBB_USE_ASSERT
@@ -192,10 +189,10 @@ void thread_monitor::detach_thread(handle_type handle) {
 
 inline void thread_monitor::yield() {
 // TODO: consider unification via __TBB_Yield or tbb::this_tbb_thread::yield
-#if !__TBB_WIN8UI_SUPPORT
-    SwitchToThread();
-#else
+#if __TBB_WIN8UI_SUPPORT && (_WIN32_WINNT < 0x0A00)
     std::this_thread::yield();
+#else
+    SwitchToThread();
 #endif
 }
 #endif /* USE_WINTHREAD */
@@ -244,24 +241,25 @@ inline void thread_monitor::notify() {
 }
 
 inline void thread_monitor::prepare_wait( cookie& c ) {
-    if( spurious ) {
-        spurious = false;
-        //  consumes a spurious posted signal. don't wait on my_sema.
-        my_sema.P();
+    if( skipped_wakeup ) {
+        // Lazily consume a signal that was skipped due to cancel_wait
+        skipped_wakeup = false;
+        my_sema.P(); // does not really wait on the semaphore
     }
     c = my_cookie;
-    in_wait = true;
-   __TBB_full_memory_fence();
+    in_wait.store<tbb::full_fence>( true );
 }
 
 inline void thread_monitor::commit_wait( cookie& c ) {
-    bool do_it = ( c.my_epoch == my_cookie.my_epoch);
+    bool do_it = ( c.my_epoch == my_cookie.my_epoch );
     if( do_it ) my_sema.P();
     else        cancel_wait();
 }
 
 inline void thread_monitor::cancel_wait() {
-    spurious = ! in_wait.fetch_and_store( false );
+    // if not in_wait, then some thread has sent us a signal;
+    // it will be consumed by the next prepare_wait call
+    skipped_wakeup = ! in_wait.fetch_and_store( false );
 }
 
 } // namespace internal
diff --git a/src/tbb/src/rml/server/wait_counter.h b/src/tbb/src/rml/server/wait_counter.h
index 3ddd8e03..df0535f9 100644
--- a/src/tbb/src/rml/server/wait_counter.h
+++ b/src/tbb/src/rml/server/wait_counter.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __RML_wait_counter_H
diff --git a/src/tbb/src/rml/server/win32-rml-export.def b/src/tbb/src/rml/server/win32-rml-export.def
index 2a550d0b..9723cca0 100644
--- a/src/tbb/src/rml/server/win32-rml-export.def
+++ b/src/tbb/src/rml/server/win32-rml-export.def
@@ -1,4 +1,4 @@
-; Copyright (c) 2005-2017 Intel Corporation
+; Copyright (c) 2005-2020 Intel Corporation
 ;
 ; Licensed under the Apache License, Version 2.0 (the "License");
 ; you may not use this file except in compliance with the License.
@@ -11,10 +11,6 @@
 ; 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.
-;
-;
-;
-;
 
 EXPORTS
 
diff --git a/src/tbb/src/rml/server/win64-rml-export.def b/src/tbb/src/rml/server/win64-rml-export.def
index 2a550d0b..9723cca0 100644
--- a/src/tbb/src/rml/server/win64-rml-export.def
+++ b/src/tbb/src/rml/server/win64-rml-export.def
@@ -1,4 +1,4 @@
-; Copyright (c) 2005-2017 Intel Corporation
+; Copyright (c) 2005-2020 Intel Corporation
 ;
 ; Licensed under the Apache License, Version 2.0 (the "License");
 ; you may not use this file except in compliance with the License.
@@ -11,10 +11,6 @@
 ; 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.
-;
-;
-;
-;
 
 EXPORTS
 
diff --git a/src/tbb/src/rml/test/rml_omp_stub.cpp b/src/tbb/src/rml/test/rml_omp_stub.cpp
index eb701b17..8a24ceb2 100644
--- a/src/tbb/src/rml/test/rml_omp_stub.cpp
+++ b/src/tbb/src/rml/test/rml_omp_stub.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 // This file is compiled with C++, but linked with a program written in C.
diff --git a/src/tbb/src/rml/test/test_job_automaton.cpp b/src/tbb/src/rml/test/test_job_automaton.cpp
index f416e58b..06b7acaf 100644
--- a/src/tbb/src/rml/test/test_job_automaton.cpp
+++ b/src/tbb/src/rml/test/test_job_automaton.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 "harness.h"
diff --git a/src/tbb/src/rml/test/test_rml_mixed.cpp b/src/tbb/src/rml/test/test_rml_mixed.cpp
index 0575df50..f54c20d5 100644
--- a/src/tbb/src/rml/test/test_rml_mixed.cpp
+++ b/src/tbb/src/rml/test/test_rml_mixed.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 <tbb/tbb_config.h>
diff --git a/src/tbb/src/rml/test/test_rml_omp.cpp b/src/tbb/src/rml/test/test_rml_omp.cpp
index 89096de5..daa91e5c 100644
--- a/src/tbb/src/rml/test/test_rml_omp.cpp
+++ b/src/tbb/src/rml/test/test_rml_omp.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 <tbb/tbb_config.h>
diff --git a/src/tbb/src/rml/test/test_rml_omp_c_linkage.c b/src/tbb/src/rml/test/test_rml_omp_c_linkage.c
index a59a5864..540559a3 100644
--- a/src/tbb/src/rml/test/test_rml_omp_c_linkage.c
+++ b/src/tbb/src/rml/test/test_rml_omp_c_linkage.c
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 void Cplusplus();
diff --git a/src/tbb/src/rml/test/test_rml_tbb.cpp b/src/tbb/src/rml/test/test_rml_tbb.cpp
index f679baeb..37e04adc 100644
--- a/src/tbb/src/rml/test/test_rml_tbb.cpp
+++ b/src/tbb/src/rml/test/test_rml_tbb.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 <tbb/tbb_config.h>
diff --git a/src/tbb/src/rml/test/test_server.h b/src/tbb/src/rml/test/test_server.h
index a72142fa..dcde2a7f 100644
--- a/src/tbb/src/rml/test/test_server.h
+++ b/src/tbb/src/rml/test/test_server.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,15 +12,11 @@
     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.
-
-
-
-
 */
 
 /* This header contains code shared by test_omp_server.cpp and test_tbb_server.cpp 
    There is no ifndef guard - test is supposed to include this file exactly once.
-   The test is also exected to have #include of rml_omp.h or rml_tbb.h before 
+   The test is also executed to have #include of rml_omp.h or rml_tbb.h before 
    including this header. 
 
    This header should not use any parts of TBB that require linking in the TBB run-time. 
@@ -93,7 +89,7 @@ class MyJob: public ::rml::job {
     }
     ~MyJob() {
         // Overwrite so that accidental use after destruction can be detected.
-        memset(this,-1,sizeof(*this));
+        memset(static_cast<void*>(this),-1,sizeof(*this));
     }
 };
 
diff --git a/src/tbb/src/rml/test/test_thread_monitor.cpp b/src/tbb/src/rml/test/test_thread_monitor.cpp
index ca632593..b3e59fb2 100644
--- a/src/tbb/src/rml/test/test_thread_monitor.cpp
+++ b/src/tbb/src/rml/test/test_thread_monitor.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 "harness.h"
diff --git a/src/tbb/src/tbb/arena.cpp b/src/tbb/src/tbb/arena.cpp
index abe4d35b..8e95460b 100644
--- a/src/tbb/src/tbb/arena.cpp
+++ b/src/tbb/src/tbb/arena.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 "tbb/global_control.h" // thread_stack_size
@@ -36,6 +32,50 @@
 namespace tbb {
 namespace internal {
 
+#if __TBB_NUMA_SUPPORT
+class numa_binding_observer : public tbb::task_scheduler_observer {
+    int my_numa_node_id;
+    binding_handler* binding_handler_ptr;
+public:
+    numa_binding_observer( task_arena* ta, int numa_id, int num_slots )
+        : task_scheduler_observer(*ta)
+        , my_numa_node_id(numa_id)
+        , binding_handler_ptr(tbb::internal::construct_binding_handler(num_slots))
+    {}
+
+    void on_scheduler_entry( bool ) __TBB_override {
+        tbb::internal::bind_thread_to_node(
+            binding_handler_ptr, this_task_arena::current_thread_index(), my_numa_node_id);
+    }
+
+    void on_scheduler_exit( bool ) __TBB_override {
+        tbb::internal::restore_affinity_mask(binding_handler_ptr, this_task_arena::current_thread_index());
+    }
+
+    ~numa_binding_observer(){
+        tbb::internal::destroy_binding_handler(binding_handler_ptr);
+    }
+};
+
+numa_binding_observer* construct_binding_observer( tbb::interface7::task_arena* ta,
+                                                   int numa_id, int num_slots ) {
+    numa_binding_observer* binding_observer = NULL;
+    // numa_topology initialization will be lazily performed inside nodes_count() call
+    if (numa_id >= 0 && numa_topology::nodes_count() > 1) {
+        binding_observer = new numa_binding_observer(ta, numa_id, num_slots);
+        __TBB_ASSERT(binding_observer, "Failure during NUMA binding observer allocation and construction");
+        binding_observer->observe(true);
+    }
+    return binding_observer;
+}
+
+void destroy_binding_observer( numa_binding_observer* binding_observer ) {
+    __TBB_ASSERT(binding_observer, "Trying to deallocate NULL pointer");
+    binding_observer->observe(false);
+    delete binding_observer;
+}
+#endif
+
 // put it here in order to enable compiler to inline it into arena::process and nested_arena_entry
 void generic_scheduler::attach_arena( arena* a, size_t index, bool is_master ) {
     __TBB_ASSERT( a->my_market == my_market, NULL );
@@ -143,11 +183,7 @@ void arena::process( generic_scheduler& s ) {
         __TBB_ASSERT( s.my_arena_slot->task_pool == EmptyTaskPool, "Empty task pool is not marked appropriately" );
         // This check prevents relinquishing more than necessary workers because
         // of the non-atomicity of the decision making procedure
-        if ( num_workers_active() > my_num_workers_allotted
-#if __TBB_ENQUEUE_ENFORCED_CONCURRENCY
-             || recall_by_mandatory_request()
-#endif
-            )
+        if ( is_recall_requested() )
             break;
         // Try to steal a task.
         // Passing reference count is technically unnecessary in this context,
@@ -207,6 +243,9 @@ arena::arena ( market& m, unsigned num_slots, unsigned num_reserved_slots ) {
     my_aba_epoch = m.my_arenas_aba_epoch;
 #if __TBB_ARENA_OBSERVER
     my_observers.my_arena = this;
+#endif
+#if __TBB_PREVIEW_RESUMABLE_TASKS
+    my_co_cache.init(4 * num_slots);
 #endif
     __TBB_ASSERT ( my_max_num_workers <= my_num_slots, NULL );
     // Construct slots. Mark internal synchronization elements for the tools.
@@ -214,18 +253,29 @@ arena::arena ( market& m, unsigned num_slots, unsigned num_reserved_slots ) {
         __TBB_ASSERT( !my_slots[i].my_scheduler && !my_slots[i].task_pool, NULL );
         __TBB_ASSERT( !my_slots[i].task_pool_ptr, NULL );
         __TBB_ASSERT( !my_slots[i].my_task_pool_size, NULL );
+#if __TBB_PREVIEW_RESUMABLE_TASKS
+        __TBB_ASSERT( !my_slots[i].my_scheduler_is_recalled, NULL );
+#endif
         ITT_SYNC_CREATE(my_slots + i, SyncType_Scheduler, SyncObj_WorkerTaskPool);
         mailbox(i+1).construct();
         ITT_SYNC_CREATE(&mailbox(i+1), SyncType_Scheduler, SyncObj_Mailbox);
         my_slots[i].hint_for_pop = i;
+#if __TBB_PREVIEW_CRITICAL_TASKS
+        my_slots[i].hint_for_critical = i;
+#endif
 #if __TBB_STATISTICS
         my_slots[i].my_counters = new ( NFS_Allocate(1, sizeof(statistics_counters), NULL) ) statistics_counters;
 #endif /* __TBB_STATISTICS */
     }
     my_task_stream.initialize(my_num_slots);
     ITT_SYNC_CREATE(&my_task_stream, SyncType_Scheduler, SyncObj_TaskStream);
+#if __TBB_PREVIEW_CRITICAL_TASKS
+    my_critical_task_stream.initialize(my_num_slots);
+    ITT_SYNC_CREATE(&my_critical_task_stream, SyncType_Scheduler, SyncObj_CriticalTaskStream);
+#endif
 #if __TBB_ENQUEUE_ENFORCED_CONCURRENCY
-    my_concurrency_mode = cm_normal;
+    my_local_concurrency_mode = false;
+    my_global_concurrency_mode = false;
 #endif
 #if !__TBB_FP_CONTEXT
     my_cpu_ctl_env.get_env();
@@ -249,7 +299,7 @@ void arena::free_arena () {
     __TBB_ASSERT( !my_num_workers_requested && !my_num_workers_allotted, "Dying arena requests workers" );
     __TBB_ASSERT( my_pool_state == SNAPSHOT_EMPTY || !my_max_num_workers, "Inconsistent state of a dying arena" );
 #if __TBB_ENQUEUE_ENFORCED_CONCURRENCY
-    __TBB_ASSERT( my_concurrency_mode != cm_enforced_global, NULL );
+    __TBB_ASSERT( !my_global_concurrency_mode, NULL );
 #endif
 #if !__TBB_STATISTICS_EARLY_DUMP
     GATHER_STATISTIC( dump_arena_statistics() );
@@ -268,6 +318,13 @@ void arena::free_arena () {
         drained += mailbox(i+1).drain();
     }
     __TBB_ASSERT( my_task_stream.drain()==0, "Not all enqueued tasks were executed");
+#if __TBB_PREVIEW_RESUMABLE_TASKS
+    // Cleanup coroutines/schedulers cache
+    my_co_cache.cleanup();
+#endif
+#if __TBB_PREVIEW_CRITICAL_TASKS
+    __TBB_ASSERT( my_critical_task_stream.drain()==0, "Not all critical tasks were executed");
+#endif
 #if __TBB_COUNT_TASK_NODES
     my_market->update_task_node_count( -drained );
 #endif /* __TBB_COUNT_TASK_NODES */
@@ -431,6 +488,10 @@ bool arena::is_out_of_work() {
                     }
                     __TBB_ASSERT( k <= n, NULL );
                     bool work_absent = k == n;
+#if __TBB_PREVIEW_CRITICAL_TASKS
+                    bool no_critical_tasks = my_critical_task_stream.empty(0);
+                    work_absent &= no_critical_tasks;
+#endif
 #if __TBB_TASK_PRIORITY
                     // Variable tasks_present indicates presence of tasks at any priority
                     // level, while work_absent refers only to the current priority.
@@ -497,17 +558,9 @@ bool arena::is_out_of_work() {
                                 // to avoid race with advertise_new_work.
                                 int current_demand = (int)my_max_num_workers;
                                 if( my_pool_state.compare_and_swap( SNAPSHOT_EMPTY, busy )==busy ) {
-#if __TBB_ENQUEUE_ENFORCED_CONCURRENCY
-                                    if( my_concurrency_mode==cm_enforced_global  ) {
-                                        // adjust_demand() called inside, if needed
-                                        my_market->mandatory_concurrency_disable( this );
-                                    } else
-#endif /* __TBB_ENQUEUE_ENFORCED_CONCURRENCY */
-                                    {
-                                        // This thread transitioned pool to empty state, and thus is
-                                        // responsible for telling the market that there is no work to do.
-                                        my_market->adjust_demand( *this, -current_demand );
-                                    }
+                                    // This thread transitioned pool to empty state, and thus is
+                                    // responsible for telling the market that there is no work to do.
+                                    my_market->adjust_demand( *this, -current_demand );
                                     restore_priority_if_need();
                                     return true;
                                 }
@@ -560,17 +613,55 @@ void arena::enqueue_task( task& t, intptr_t prio, FastRandom &random )
     }
     __TBB_ASSERT(t.prefix().affinity==affinity_id(0), "affinity is ignored for enqueued tasks");
 #endif /* TBB_USE_ASSERT */
+#if __TBB_PREVIEW_CRITICAL_TASKS
+
+#if __TBB_TASK_PRIORITY
+    bool is_critical =  internal::is_critical( t ) || prio == internal::priority_critical;
+#else /*!__TBB_TASK_PRIORITY*/
+    bool is_critical =  internal::is_critical( t );
+#endif /*!__TBB_TASK_PRIORITY*/
+
+    if( is_critical ) {
+        // TODO: consider using of 'scheduler::handled_as_critical'
+        internal::make_critical( t );
+        generic_scheduler* s = governor::local_scheduler_if_initialized();
+        ITT_NOTIFY(sync_releasing, &my_critical_task_stream);
+        if( s && s->my_arena_slot ) {
+            // Scheduler is  initialized and it is attached to the arena,
+            // propagate isolation level to critical task
+#if __TBB_TASK_ISOLATION
+            t.prefix().isolation = s->my_innermost_running_task->prefix().isolation;
+#endif
+            unsigned& lane = s->my_arena_slot->hint_for_critical;
+            my_critical_task_stream.push( &t, 0, tbb::internal::subsequent_lane_selector(lane) );
+        } else {
+            // Either scheduler is not initialized or it is not attached to the arena
+            // use random lane for the task
+            my_critical_task_stream.push( &t, 0, internal::random_lane_selector(random) );
+        }
+        advertise_new_work<work_spawned>();
+        return;
+    }
+#endif /* __TBB_PREVIEW_CRITICAL_TASKS */
 
     ITT_NOTIFY(sync_releasing, &my_task_stream);
 #if __TBB_TASK_PRIORITY
     intptr_t p = prio ? normalize_priority(priority_t(prio)) : normalized_normal_priority;
     assert_priority_valid(p);
+#if __TBB_PREVIEW_CRITICAL_TASKS && __TBB_CPF_BUILD
+    my_task_stream.push( &t, p, internal::random_lane_selector(random) );
+#else
     my_task_stream.push( &t, p, random );
+#endif
     if ( p != my_top_priority )
         my_market->update_arena_priority( *this, p );
 #else /* !__TBB_TASK_PRIORITY */
     __TBB_ASSERT_EX(prio == 0, "the library is not configured to respect the task priority");
+#if __TBB_PREVIEW_CRITICAL_TASKS && __TBB_CPF_BUILD
+    my_task_stream.push( &t, 0, internal::random_lane_selector(random) );
+#else
     my_task_stream.push( &t, 0, random );
+#endif
 #endif /* !__TBB_TASK_PRIORITY */
     advertise_new_work<work_enqueued>();
 #if __TBB_TASK_PRIORITY
@@ -589,6 +680,10 @@ class nested_arena_context : no_copy {
             mimic_outermost_level(a, type);
         } else {
             my_orig_state = *s;
+#if __TBB_PREVIEW_RESUMABLE_TASKS
+            my_scheduler.my_properties.genuine = true;
+            my_scheduler.my_current_is_recalled = NULL;
+#endif
             mimic_outermost_level(a, type);
             s->nested_arena_entry(a, slot_index);
         }
@@ -602,7 +697,7 @@ class nested_arena_context : no_copy {
             my_scheduler.my_innermost_running_task = my_orig_state.my_innermost_running_task;
         } else {
             my_scheduler.nested_arena_exit();
-            static_cast<scheduler_state&>(my_scheduler) = my_orig_state; // restore arena settings 
+            static_cast<scheduler_state&>(my_scheduler) = my_orig_state; // restore arena settings
 #if __TBB_TASK_PRIORITY
             my_scheduler.my_local_reload_epoch = *my_orig_state.my_ref_reload_epoch;
 #endif
@@ -620,6 +715,9 @@ class nested_arena_context : no_copy {
         my_scheduler.my_properties.outermost = true;
         my_scheduler.my_properties.type = type;
         my_scheduler.my_innermost_running_task = my_scheduler.my_dummy_task;
+#if __TBB_PREVIEW_CRITICAL_TASKS
+        my_scheduler.my_properties.has_taken_critical_task = false;
+#endif
 #if __TBB_TASK_GROUP_CONTEXT
         // Save dummy's context and replace it by arena's context
         my_orig_ctx = my_scheduler.my_dummy_task->prefix().context;
@@ -641,28 +739,30 @@ void generic_scheduler::nested_arena_entry(arena* a, size_t slot_index) {
     attach_arena( a, slot_index, /*is_master*/true );
     __TBB_ASSERT( my_arena == a, NULL );
     governor::assume_scheduler( this );
-#if __TBB_ARENA_OBSERVER
-    my_last_local_observer = 0; // TODO: try optimize number of calls
-    my_arena->my_observers.notify_entry_observers( my_last_local_observer, /*worker=*/false );
-#endif
     // TODO? ITT_NOTIFY(sync_acquired, a->my_slots + index);
     // TODO: it requires market to have P workers (not P-1)
     // TODO: a preempted worker should be excluded from assignment to other arenas e.g. my_slack--
     if( !is_worker() && slot_index >= my_arena->my_num_reserved_slots )
         my_arena->my_market->adjust_demand(*my_arena, -1);
+#if __TBB_ARENA_OBSERVER
+    my_last_local_observer = 0; // TODO: try optimize number of calls
+    my_arena->my_observers.notify_entry_observers( my_last_local_observer, /*worker=*/false );
+#endif
+#if __TBB_PREVIEW_RESUMABLE_TASKS
+    my_wait_task = NULL;
+#endif
 }
 
 void generic_scheduler::nested_arena_exit() {
-    if( !is_worker() && my_arena_index >= my_arena->my_num_reserved_slots )
-        my_arena->my_market->adjust_demand(*my_arena, 1);
 #if __TBB_ARENA_OBSERVER
     my_arena->my_observers.notify_exit_observers( my_last_local_observer, /*worker=*/false );
 #endif /* __TBB_ARENA_OBSERVER */
-
 #if __TBB_TASK_PRIORITY
     if ( my_offloaded_tasks )
         my_arena->orphan_offloaded_tasks( *this );
 #endif
+    if( !is_worker() && my_arena_index >= my_arena->my_num_reserved_slots )
+        my_arena->my_market->adjust_demand(*my_arena, 1);
     // Free the master slot.
     __TBB_ASSERT(my_arena->my_slots[my_arena_index].my_scheduler, "A slot is already empty");
     __TBB_store_with_release(my_arena->my_slots[my_arena_index].my_scheduler, (generic_scheduler*)NULL);
@@ -676,6 +776,80 @@ void generic_scheduler::wait_until_empty() {
     my_dummy_task->prefix().ref_count--;
 }
 
+#if __TBB_PREVIEW_RESUMABLE_TASKS
+class resume_task : public task {
+    generic_scheduler& my_target;
+public:
+    resume_task(generic_scheduler& target) : my_target(target) {}
+    task* execute() __TBB_override {
+        generic_scheduler* s = governor::local_scheduler_if_initialized();
+        __TBB_ASSERT(s, NULL);
+        if (s->prepare_resume(my_target)) {
+            s->resume(my_target);
+        } else {
+            __TBB_ASSERT(prefix().state == task::executing, NULL);
+            // Request the dispatch loop to exit (because we in a coroutine on the outermost level).
+            prefix().state = task::to_resume;
+        }
+        return NULL;
+    }
+};
+
+static generic_scheduler& create_coroutine(generic_scheduler& curr) {
+    // We may have some coroutines cached
+    generic_scheduler* co_sched = curr.my_arena->my_co_cache.pop();
+    if (!co_sched) {
+        // TODO: avoid setting/unsetting the scheduler.
+        governor::assume_scheduler(NULL);
+        co_sched = generic_scheduler::create_worker(*curr.my_market, curr.my_arena_index, /* genuine = */ false);
+        governor::assume_scheduler(&curr);
+        // Prepare newly created scheduler
+        co_sched->my_arena = curr.my_arena;
+    }
+    // Prepare scheduler (general)
+    co_sched->my_dummy_task->prefix().context = co_sched->my_arena->my_default_ctx;
+    // Prolong the arena's lifetime until all coroutines is alive
+    // (otherwise the arena can be destroyed while some tasks are suspended).
+    co_sched->my_arena->my_references += arena::ref_external;
+    return *co_sched;
+}
+
+void internal_suspend(void* suspend_callback, void* user_callback) {
+    generic_scheduler& s = *governor::local_scheduler();
+    __TBB_ASSERT(s.my_arena_slot->my_scheduler_is_recalled != NULL, NULL);
+    bool is_recalled = *s.my_arena_slot->my_scheduler_is_recalled;
+    generic_scheduler& target = is_recalled ? *s.my_arena_slot->my_scheduler : create_coroutine(s);
+
+    generic_scheduler::callback_t callback = {
+        (generic_scheduler::suspend_callback_t)suspend_callback, user_callback, &s };
+    target.set_post_resume_action(generic_scheduler::PRA_CALLBACK, &callback);
+    s.resume(target);
+}
+
+void internal_resume(task::suspend_point tag) {
+    generic_scheduler& s = *static_cast<generic_scheduler*>(tag);
+    task* t = new(&s.allocate_task(sizeof(resume_task), __TBB_CONTEXT_ARG(NULL, s.my_dummy_task->context()))) resume_task(s);
+    make_critical(*t);
+
+    // TODO: remove this work-around
+    // Prolong the arena's lifetime until all coroutines is alive
+    // (otherwise the arena can be destroyed while some tasks are suspended).
+    arena& a = *s.my_arena;
+    a.my_references += arena::ref_external;
+
+    a.my_critical_task_stream.push(t, 0, tbb::internal::random_lane_selector(s.my_random));
+    // Do not access 's' after that point.
+    a.advertise_new_work<arena::work_spawned>();
+
+    // Release our reference to my_arena.
+    a.on_thread_leaving<arena::ref_external>();
+}
+
+task::suspend_point internal_current_suspend_point() {
+    return governor::local_scheduler();
+}
+#endif /* __TBB_PREVIEW_RESUMABLE_TASKS */
+
 } // namespace internal
 } // namespace tbb
 
@@ -689,7 +863,11 @@ namespace internal {
 void task_arena_base::internal_initialize( ) {
     governor::one_time_init();
     if( my_max_concurrency < 1 )
+#if __TBB_NUMA_SUPPORT
+        my_max_concurrency = tbb::internal::numa_topology::default_concurrency(numa_id());
+#else /*__TBB_NUMA_SUPPORT*/
         my_max_concurrency = (int)governor::default_num_threads();
+#endif /*__TBB_NUMA_SUPPORT*/
     __TBB_ASSERT( my_master_slots <= (unsigned)my_max_concurrency, "Number of slots reserved for master should not exceed arena concurrency");
     arena* new_arena = market::create_arena( my_max_concurrency, my_master_slots, 0 );
     // add an internal market reference; a public reference was added in create_arena
@@ -710,17 +888,32 @@ void task_arena_base::internal_initialize( ) {
         new_arena->on_thread_leaving<arena::ref_external>(); // destroy unneeded arena
 #if __TBB_TASK_GROUP_CONTEXT
         spin_wait_while_eq(my_context, (task_group_context*)NULL);
+#endif /*__TBB_TASK_GROUP_CONTEXT*/
+#if __TBB_TASK_GROUP_CONTEXT || __TBB_NUMA_SUPPORT
     } else {
+#if __TBB_NUMA_SUPPORT
+        my_arena->my_numa_binding_observer = tbb::internal::construct_binding_observer(
+            static_cast<task_arena*>(this), numa_id(), my_arena->my_num_slots);
+#endif /*__TBB_NUMA_SUPPORT*/
+#if __TBB_TASK_GROUP_CONTEXT
         new_arena->my_default_ctx->my_version_and_traits |= my_version_and_traits & exact_exception_flag;
         as_atomic(my_context) = new_arena->my_default_ctx;
-#endif
+#endif /*__TBB_TASK_GROUP_CONTEXT*/
     }
+#endif /*__TBB_TASK_GROUP_CONTEXT || __TBB_NUMA_SUPPORT*/
+
     // TODO: should it trigger automatic initialization of this thread?
     governor::local_scheduler_weak();
 }
 
 void task_arena_base::internal_terminate( ) {
     if( my_arena ) {// task_arena was initialized
+#if __TBB_NUMA_SUPPORT
+        if( my_arena->my_numa_binding_observer != NULL ) {
+            tbb::internal::destroy_binding_observer(my_arena->my_numa_binding_observer);
+            my_arena->my_numa_binding_observer = NULL;
+        }
+#endif /*__TBB_NUMA_SUPPORT*/
         my_arena->my_market->release( /*is_public=*/true, /*blocking_terminate=*/false );
         my_arena->on_thread_leaving<arena::ref_external>();
         my_arena = 0;
@@ -753,11 +946,11 @@ void task_arena_base::internal_attach( ) {
 
 void task_arena_base::internal_enqueue( task& t, intptr_t prio ) const {
     __TBB_ASSERT(my_arena, NULL);
-    generic_scheduler* s = governor::local_scheduler_if_initialized();
+    generic_scheduler* s = governor::local_scheduler_weak();  // scheduler is only needed for FastRandom instance
     __TBB_ASSERT(s, "Scheduler is not initialized"); // we allocated a task so can expect the scheduler
 #if __TBB_TASK_GROUP_CONTEXT
-    __TBB_ASSERT(my_arena->my_default_ctx == t.prefix().context, NULL);
-    __TBB_ASSERT(!my_arena->my_default_ctx->is_group_execution_cancelled(), // TODO: any better idea?
+    // Is there a better place for checking the state of my_default_ctx?
+    __TBB_ASSERT(!(my_arena->my_default_ctx == t.prefix().context && my_arena->my_default_ctx->is_group_execution_cancelled()),
                  "The task will not be executed because default task_group_context of task_arena is cancelled. Has previously enqueued task thrown an exception?");
 #endif
     my_arena->enqueue_task( t, prio, s->my_random );
@@ -776,7 +969,7 @@ class delegated_task : public task {
             task * orig_dummy;
             task_group_context * orig_ctx;
             scheduler_properties orig_props;
-            outermost_context(delegated_task *_t, generic_scheduler &_s) 
+            outermost_context(delegated_task *_t, generic_scheduler &_s)
                 : t(_t), s(_s), orig_dummy(s.my_dummy_task), orig_props(s.my_properties) {
                 __TBB_ASSERT(s.my_innermost_running_task == t, NULL);
 #if __TBB_TASK_GROUP_CONTEXT
@@ -792,6 +985,7 @@ class delegated_task : public task {
                 // Restore context for sake of registering potential exception
                 t->prefix().context = orig_ctx;
 #endif
+                // Restore scheduler state
                 s.my_properties = orig_props;
                 s.my_dummy_task = orig_dummy;
             }
@@ -801,8 +995,19 @@ class delegated_task : public task {
     }
     ~delegated_task() {
         // potential exception was already registered. It must happen before the notification
-        __TBB_ASSERT(my_root->ref_count()==2, NULL);
-        __TBB_store_with_release(my_root->prefix().ref_count, 1); // must precede the wakeup
+        __TBB_ASSERT(my_root->ref_count() == 2, NULL);
+        task_prefix& prefix = my_root->prefix();
+#if __TBB_PREVIEW_RESUMABLE_TASKS
+        reference_count old_ref_count = __TBB_FetchAndStoreW(&prefix.ref_count, 1);
+        // Check if the scheduler was abandoned.
+        if (old_ref_count == internal::abandon_flag + 2) {
+            __TBB_ASSERT(prefix.abandoned_scheduler, NULL);
+            // The wait has been completed. Spawn a resume task.
+            tbb::task::resume(prefix.abandoned_scheduler);
+        }
+#else
+        __TBB_store_with_release(prefix.ref_count, 1); // must precede the wakeup
+#endif
         my_monitor.notify(*this); // do not relax, it needs a fence!
     }
 public:
@@ -835,12 +1040,12 @@ void task_arena_base::internal_execute(internal::delegate_base& d) const {
                     dynamic_cast< internal::delegated_function< graph_funct, void>* >(&d);
 
             if (deleg_funct) {
-                internal_enqueue(*new(task::allocate_root(*my_context)) 
+                internal_enqueue(*new(task::allocate_root(__TBB_CONTEXT_ARG1(*my_context)))
                     internal::function_task< internal::strip< graph_funct >::type >
                         (internal::forward< graph_funct >(deleg_funct->my_func)), 0);
                 return;
             } else {
-#endif
+#endif /*  __TBB_USE_OPTIONAL_RTTI */
                 concurrent_monitor::thread_context waiter;
 #if __TBB_TASK_GROUP_CONTEXT
                 task_group_context exec_context(task_group_context::isolated, my_version_and_traits & exact_exception_flag);
@@ -890,8 +1095,8 @@ void task_arena_base::internal_execute(internal::delegate_base& d) const {
         } // if (index1 == arena::out_of_arena)
     } // if (!same_arena)
 
-    cpu_ctl_env_helper cpu_ctl_helper;
-    cpu_ctl_helper.set_env(__TBB_CONTEXT_ARG1(my_context));
+    context_guard_helper</*report_tasks=*/false> context_guard;
+    context_guard.set_ctx(__TBB_CONTEXT_ARG1(my_context));
 #if TBB_USE_EXCEPTIONS
     try {
 #endif
@@ -901,7 +1106,7 @@ void task_arena_base::internal_execute(internal::delegate_base& d) const {
 #if TBB_USE_EXCEPTIONS
     }
     catch (...) {
-        cpu_ctl_helper.restore_default(); // TODO: is it needed on Windows?
+        context_guard.restore_default(); // TODO: is it needed on Windows?
         if (my_version_and_traits & exact_exception_flag) throw;
         else {
             task_group_context exception_container(task_group_context::isolated,
@@ -981,8 +1186,7 @@ class isolation_guard : tbb::internal::no_copy {
     }
 };
 
-void isolate_within_arena( delegate_base& d, intptr_t reserved ) {
-    __TBB_ASSERT( reserved == 0, NULL );
+void isolate_within_arena( delegate_base& d, intptr_t isolation ) {
     // TODO: Decide what to do if the scheduler is not initialized. Is there a use case for it?
     generic_scheduler* s = governor::local_scheduler_weak();
     __TBB_ASSERT( s, "this_task_arena::isolate() needs an initialized scheduler" );
@@ -991,7 +1195,7 @@ void isolate_within_arena( delegate_base& d, intptr_t reserved ) {
     isolation_tag& current_isolation = s->my_innermost_running_task->prefix().isolation;
     // We temporarily change the isolation tag of the currently running task. It will be restored in the destructor of the guard.
     isolation_guard guard( current_isolation );
-    current_isolation = reinterpret_cast<isolation_tag>(&d);
+    current_isolation = isolation? isolation : reinterpret_cast<isolation_tag>(&d);
     d();
 }
 #endif /* __TBB_TASK_ISOLATION */
diff --git a/src/tbb/src/tbb/arena.h b/src/tbb/src/tbb/arena.h
index 2bc23c4b..a24aba86 100644
--- a/src/tbb/src/tbb/arena.h
+++ b/src/tbb/src/tbb/arena.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef _TBB_arena_H
@@ -28,7 +24,11 @@
 
 #include "scheduler_common.h"
 #include "intrusive_list.h"
+#if __TBB_PREVIEW_CRITICAL_TASKS && __TBB_CPF_BUILD
+#include "task_stream_extended.h"
+#else
 #include "task_stream.h"
+#endif
 #include "../rml/include/rml_tbb.h"
 #include "mailbox.h"
 #include "observer_proxy.h"
@@ -36,6 +36,10 @@
 #include "governor.h"
 #include "concurrent_monitor.h"
 
+#if __TBB_PREVIEW_RESUMABLE_TASKS
+#include "tbb/spin_mutex.h"
+#endif
+
 namespace tbb {
 
 class task_group_context;
@@ -43,6 +47,98 @@ class allocate_root_with_context_proxy;
 
 namespace internal {
 
+#if __TBB_NUMA_SUPPORT
+class numa_binding_observer;
+#endif /*__TBB_NUMA_SUPPORT*/
+
+#if __TBB_PREVIEW_RESUMABLE_TASKS
+//! Bounded coroutines cache LIFO ring buffer
+class arena_co_cache {
+    //! Ring buffer storage
+    generic_scheduler** my_co_scheduler_cache;
+    //! Current cache index
+    unsigned my_head;
+    //! Cache capacity for arena
+    unsigned my_max_index;
+    //! Accessor lock for modification operations
+    tbb::spin_mutex my_co_cache_mutex;
+
+    unsigned next_index() {
+        return ( my_head == my_max_index ) ? 0 : my_head + 1;
+    }
+
+    unsigned prev_index() {
+        return ( my_head == 0 ) ? my_max_index : my_head - 1;
+    }
+
+    bool internal_empty() {
+        return my_co_scheduler_cache[prev_index()] == NULL;
+    }
+
+    void internal_scheduler_cleanup(generic_scheduler* to_cleanup) {
+        to_cleanup->my_arena_slot = NULL;
+        // Needed by cleanup_worker function, as well as arena slot clearing
+        governor::assume_scheduler(to_cleanup);
+        generic_scheduler::cleanup_worker(to_cleanup, true);
+    }
+
+public:
+    void init(unsigned cache_capacity) {
+        size_t alloc_size = cache_capacity * sizeof(generic_scheduler*);
+        my_co_scheduler_cache = (generic_scheduler**)NFS_Allocate(1, alloc_size, NULL);
+        memset( my_co_scheduler_cache, 0, alloc_size );
+        my_head = 0;
+        my_max_index = cache_capacity - 1;
+    }
+
+    void cleanup() {
+        generic_scheduler* current = governor::local_scheduler_if_initialized();
+        while (generic_scheduler* to_cleanup = pop()) {
+            internal_scheduler_cleanup(to_cleanup);
+        }
+        governor::assume_scheduler(current);
+        NFS_Free(my_co_scheduler_cache);
+    }
+
+    //! Insert scheduler to the current available place.
+    //! Replace an old value, if necessary.
+    void push(generic_scheduler* s) {
+        generic_scheduler* to_cleanup = NULL;
+        {
+            tbb::spin_mutex::scoped_lock lock(my_co_cache_mutex);
+            // Check if we are replacing some existing buffer entrance
+            if (my_co_scheduler_cache[my_head] != NULL) {
+                to_cleanup = my_co_scheduler_cache[my_head];
+            }
+            // Store the cached value
+            my_co_scheduler_cache[my_head] = s;
+            // Move head index to the next slot
+            my_head = next_index();
+        }
+        // Cleanup replaced buffer if any
+        if (to_cleanup) {
+            generic_scheduler* current = governor::local_scheduler_if_initialized();
+            internal_scheduler_cleanup(to_cleanup);
+            governor::assume_scheduler(current);
+        }
+    }
+
+    //! Get a cached scheduler if any
+    generic_scheduler* pop() {
+        tbb::spin_mutex::scoped_lock lock(my_co_cache_mutex);
+        // No cached coroutine
+        if (internal_empty()) return NULL;
+        // Move head index to the currently available value
+        my_head = prev_index();
+        // Retrieve the value from the buffer
+        generic_scheduler* to_return = my_co_scheduler_cache[my_head];
+        // Clear the previous entrance value
+        my_co_scheduler_cache[my_head] = NULL;
+        return to_return;
+    }
+};
+#endif // __TBB_PREVIEW_RESUMABLE_TASKS
+
 //! The structure of an arena, except the array of slots.
 /** Separated in order to simplify padding.
     Intrusive list node base class is used by market to form a list of arenas. **/
@@ -70,7 +166,20 @@ struct arena_base : padded<intrusive_list_node> {
           relaxed FIFO order);
         - the enqueuing thread does not call any of wait_for_all methods.
         Depending on __TBB_TASK_PRIORITY, num_priority_levels can be 1 or more. **/
+#if __TBB_PREVIEW_CRITICAL_TASKS && __TBB_CPF_BUILD
+    task_stream<num_priority_levels, front_accessor> my_task_stream; // heavy use in stealing loop
+#else
     task_stream<num_priority_levels> my_task_stream; // heavy use in stealing loop
+#endif
+
+#if __TBB_PREVIEW_CRITICAL_TASKS
+    //! Task pool for the tasks with critical property set.
+    /** Critical tasks are scheduled for execution ahead of other sources (including local task pool
+        and even bypassed tasks) unless the thread already executes a critical task in an outer
+        dispatch loop **/
+    // used on the hot path of the task dispatch loop
+    task_stream<1, back_nonnull_accessor> my_critical_task_stream;
+#endif
 
     //! The number of workers requested by the master thread owning the arena.
     unsigned my_max_num_workers;
@@ -90,6 +199,11 @@ struct arena_base : padded<intrusive_list_node> {
     observer_list my_observers;
 #endif
 
+#if __TBB_NUMA_SUPPORT
+    //! Pointer to internal observer that allows to bind threads in arena to certain NUMA node.
+    numa_binding_observer* my_numa_binding_observer;
+#endif /*__TBB_NUMA_SUPPORT*/
+
 #if __TBB_TASK_PRIORITY
     //! The lowest normalized priority of available spawned or enqueued tasks.
     intptr_t my_bottom_priority;
@@ -139,20 +253,20 @@ struct arena_base : padded<intrusive_list_node> {
     unsigned my_num_reserved_slots;
 
 #if __TBB_ENQUEUE_ENFORCED_CONCURRENCY
-    //! Possible states for the concurrency mode of an arena.
-    enum concurrency_mode {
-        cm_normal =  0,     // arena is served by workers as usual
-        cm_enforced_local,  // arena needs an extra worker despite the arena limit
-        cm_enforced_global  // arena needs an extra worker despite a global limit
-    };
-
-    //! The concurrency mode of an arena.
-    concurrency_mode my_concurrency_mode;
+    // arena needs an extra worker despite the arena limit
+    bool my_local_concurrency_mode;
+    // arena needs an extra worker despite a global limit
+    bool my_global_concurrency_mode;
 #endif /* __TBB_ENQUEUE_ENFORCED_CONCURRENCY */
 
     //! Waiting object for master threads that cannot join the arena.
     concurrent_monitor my_exit_monitors;
 
+#if __TBB_PREVIEW_RESUMABLE_TASKS
+    //! Coroutines cache buffer
+    arena_co_cache my_co_cache;
+#endif
+
 #if TBB_USE_ASSERT
     //! Used to trap accesses to the object after its destruction.
     uintptr_t my_guard;
@@ -217,10 +331,15 @@ class arena: public padded<arena_base>
     static bool is_busy_or_empty( pool_state_t s ) { return s < SNAPSHOT_FULL; }
 
     //! The number of workers active in the arena.
-    unsigned num_workers_active( ) {
+    unsigned num_workers_active() const {
         return my_references >> ref_external_bits;
     }
 
+    //! Check if the recall is requested by the market.
+    bool is_recall_requested() const {
+        return num_workers_active() > my_num_workers_allotted;
+    }
+
     //! If necessary, raise a flag that there is new job in arena.
     template<arena::new_work_type work_type> void advertise_new_work();
 
@@ -260,18 +379,6 @@ class arena: public padded<arena_base>
     //! Check for the presence of enqueued tasks at all priority levels
     bool has_enqueued_tasks();
 
-#if __TBB_ENQUEUE_ENFORCED_CONCURRENCY
-    //! Recall worker if global mandatory is enabled, but not for this arena
-    bool recall_by_mandatory_request() const {
-        return my_market->my_mandatory_num_requested && my_concurrency_mode==cm_normal;
-    }
-
-    //! The arena is currently in an enforced concurrency mode
-    bool must_have_concurrency() const {
-        return my_num_workers_requested &&
-               ( my_concurrency_mode==cm_enforced_local || my_concurrency_mode==cm_enforced_global );
-    }
-#endif
     static const size_t out_of_arena = ~size_t(0);
     //! Tries to occupy a slot in the arena. On success, returns the slot index; if no slot is available, returns out_of_arena.
     template <bool as_worker>
@@ -355,8 +462,9 @@ inline void arena::on_thread_leaving ( ) {
     // TODO: consider more strict conditions for the cleanup,
     // because it can create the demand of workers,
     // but the arena can be already empty (and so ready for destroying)
+    // TODO: Fix the race: while we check soft limit and it might be changed.
     if( ref_param==ref_external && my_num_slots != my_num_reserved_slots
-        && 0 == m->my_num_workers_soft_limit && my_concurrency_mode==cm_normal ) {
+        && 0 == m->my_num_workers_soft_limit && !my_global_concurrency_mode ) {
         bool is_out = false;
         for (int i=0; i<num_priority_levels; i++) {
             is_out = is_out_of_work();
@@ -364,7 +472,7 @@ inline void arena::on_thread_leaving ( ) {
                 break;
         }
         // We expect, that in worst case it's enough to have num_priority_levels-1
-        // calls to restore priorities and and yet another is_out_of_work() to conform
+        // calls to restore priorities and yet another is_out_of_work() to conform
         // that no work was found. But as market::set_active_num_workers() can be called
         // concurrently, can't guarantee last is_out_of_work() return true.
     }
@@ -376,19 +484,15 @@ inline void arena::on_thread_leaving ( ) {
 template<arena::new_work_type work_type> void arena::advertise_new_work() {
     if( work_type == work_enqueued ) {
 #if __TBB_ENQUEUE_ENFORCED_CONCURRENCY
-        if( my_market->my_num_workers_soft_limit == 0 ) {
-            if( my_concurrency_mode!=cm_enforced_global ) {
-                if( my_market->mandatory_concurrency_enable( this ) ) {
-                    my_pool_state = SNAPSHOT_FULL;
-                    return;
-                }
-            }
-        } else if( my_max_num_workers==0 && my_num_reserved_slots==1 ) {
-            my_max_num_workers = 1;
-            __TBB_ASSERT(my_concurrency_mode==cm_normal, NULL);
-            my_concurrency_mode = cm_enforced_local;
+        if ( as_atomic(my_market->my_num_workers_soft_limit) == 0 && as_atomic(my_global_concurrency_mode) == false )
+            my_market->enable_mandatory_concurrency(this);
+
+        if ( my_max_num_workers == 0 && my_num_reserved_slots == 1 ) {
+            __TBB_ASSERT(!my_local_concurrency_mode, NULL);
+            my_local_concurrency_mode = true;
             my_pool_state = SNAPSHOT_FULL;
-            my_market->adjust_demand( *this, 1 );
+            my_max_num_workers = 1;
+            my_market->adjust_demand(*this, my_max_num_workers);
             return;
         }
 #endif /* __TBB_ENQUEUE_ENFORCED_CONCURRENCY */
@@ -425,29 +529,22 @@ template<arena::new_work_type work_type> void arena::advertise_new_work() {
             // telling the market that there is work to do.
 #if __TBB_ENQUEUE_ENFORCED_CONCURRENCY
             if( work_type == work_spawned ) {
-                if( my_concurrency_mode!=cm_normal ) {
-                    switch( my_concurrency_mode ) {
-                    case cm_enforced_local:
-                        __TBB_ASSERT(my_max_num_workers==1, "");
-                        __TBB_ASSERT(!governor::local_scheduler()->is_worker(), "");
-                        // There was deliberate oversubscription on 1 core for sake of starvation-resistant tasks.
-                        // Now a single active thread (must be the master) supposedly starts a new parallel region
-                        // with relaxed sequential semantics, and oversubscription should be avoided.
-                        // Demand for workers has been decreased to 0 during SNAPSHOT_EMPTY, so just keep it.
-                        my_max_num_workers = 0;
-                        my_concurrency_mode = cm_normal;
-                        break;
-                    case cm_enforced_global:
-                        my_market->mandatory_concurrency_disable( this );
-                        restore_priority_if_need();
-                        break;
-                    default:
-                        break;
-                    }
+                if( my_local_concurrency_mode ) {
+                    __TBB_ASSERT(my_max_num_workers==1, "");
+                    __TBB_ASSERT(!governor::local_scheduler()->is_worker(), "");
+                    // There was deliberate oversubscription on 1 core for sake of starvation-resistant tasks.
+                    // Now a single active thread (must be the master) supposedly starts a new parallel region
+                    // with relaxed sequential semantics, and oversubscription should be avoided.
+                    // Demand for workers has been decreased to 0 during SNAPSHOT_EMPTY, so just keep it.
+                    my_max_num_workers = 0;
+                    my_local_concurrency_mode = false;
                     return;
                 }
+                if ( as_atomic(my_global_concurrency_mode) == true )
+                    my_market->mandatory_concurrency_disable( this );
             }
 #endif /* __TBB_ENQUEUE_ENFORCED_CONCURRENCY */
+            // TODO: investigate adjusting of arena's demand by a single worker.
             my_market->adjust_demand( *this, my_max_num_workers );
         }
     }
diff --git a/src/tbb/src/tbb/cache_aligned_allocator.cpp b/src/tbb/src/tbb/cache_aligned_allocator.cpp
index e1e87132..4267014b 100644
--- a/src/tbb/src/tbb/cache_aligned_allocator.cpp
+++ b/src/tbb/src/tbb/cache_aligned_allocator.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 "tbb/tbb_config.h"
@@ -32,8 +28,6 @@
 #include <dlfcn.h>
 #endif /* _WIN32||_WIN64 */
 
-using namespace std;
-
 #if __TBB_WEAK_SYMBOLS_PRESENT
 
 #pragma weak scalable_malloc
@@ -104,7 +98,7 @@ static const dynamic_link_descriptor MallocLinkTable[] = {
 #define MALLOCLIB_NAME "tbbmalloc" DEBUG_SUFFIX ".dll"
 #elif __APPLE__
 #define MALLOCLIB_NAME "libtbbmalloc" DEBUG_SUFFIX ".dylib"
-#elif __FreeBSD__ || __NetBSD__ || __sun || _AIX || __ANDROID__
+#elif __FreeBSD__ || __NetBSD__ || __OpenBSD__ || __sun || _AIX || __ANDROID__
 #define MALLOCLIB_NAME "libtbbmalloc" DEBUG_SUFFIX ".so"
 #elif __linux__  // Note that order of these #elif's is important!
 #define MALLOCLIB_NAME "libtbbmalloc" DEBUG_SUFFIX  __TBB_STRING(.so.TBB_COMPATIBLE_INTERFACE_VERSION)
@@ -124,8 +118,8 @@ void initialize_handler_pointers() {
         // This must be done now, and not before FillDynamicLinks runs, because if other
         // threads call the handlers, we want them to go through the DoOneTimeInitializations logic,
         // which forces them to wait.
-        FreeHandler = &free;
-        MallocHandler = &malloc;
+        FreeHandler = &std::free;
+        MallocHandler = &std::malloc;
         padded_allocate_handler = &padded_allocate;
         padded_free_handler = &padded_free;
     }
@@ -207,7 +201,7 @@ void NFS_Free( void* p ) {
 
 static void* padded_allocate( size_t bytes, size_t alignment ) {
     unsigned char* result = NULL;
-    unsigned char* base = (unsigned char*)malloc(alignment+bytes);
+    unsigned char* base = (unsigned char*)std::malloc(alignment+bytes);
     if( base ) {
         // Round up to the next line
         result = (unsigned char*)((uintptr_t)(base+alignment)&-alignment);
@@ -223,7 +217,7 @@ static void padded_free( void* p ) {
         // Recover where block actually starts
         unsigned char* base = ((unsigned char**)p)[-1];
         __TBB_ASSERT( (void*)((uintptr_t)(base+NFS_LineSize)&-NFS_LineSize)==p, "not allocated by NFS_Allocate?" );
-        free(base);
+        std::free(base);
     }
 }
 
@@ -248,9 +242,9 @@ bool __TBB_EXPORTED_FUNC is_malloc_used_v3() {
     }
     __TBB_ASSERT( MallocHandler!=&DummyMalloc && FreeHandler!=&DummyFree, NULL );
     // Cast to void avoids type mismatch errors on some compilers (e.g. __IBMCPP__)
-    __TBB_ASSERT( !(((void*)MallocHandler==(void*)&malloc) ^ ((void*)FreeHandler==(void*)&free)),
+    __TBB_ASSERT( !(((void*)MallocHandler==(void*)&std::malloc) ^ ((void*)FreeHandler==(void*)&std::free)),
                   "Both shim pointers must refer to routines from the same package (either TBB or CRT)" );
-    return (void*)MallocHandler == (void*)&malloc;
+    return (void*)MallocHandler == (void*)&std::malloc;
 }
 
 } // namespace internal
diff --git a/src/tbb/src/tbb/cilk-tbb-interop.h b/src/tbb/src/tbb/cilk-tbb-interop.h
index 19db6ea9..a7d535bf 100644
--- a/src/tbb/src/tbb/cilk-tbb-interop.h
+++ b/src/tbb/src/tbb/cilk-tbb-interop.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 /* The API to enable interoperability between Intel(R) Cilk(TM) Plus and
diff --git a/src/tbb/src/tbb/co_context.h b/src/tbb/src/tbb/co_context.h
new file mode 100644
index 00000000..19e49390
--- /dev/null
+++ b/src/tbb/src/tbb/co_context.h
@@ -0,0 +1,217 @@
+/*
+    Copyright (c) 2005-2020 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.
+*/
+
+#ifndef _TBB_co_context_H
+#define _TBB_co_context_H
+
+#if _WIN32
+#include <windows.h>
+namespace tbb {
+namespace internal {
+    typedef LPVOID coroutine_type;
+}}
+#else // !_WIN32
+// ucontext.h API is deprecated since macOS 10.6
+#if __APPLE__
+    #if __INTEL_COMPILER
+        #pragma warning(push)
+        #pragma warning(disable:1478)
+    #elif __clang__
+        #pragma clang diagnostic push
+        #pragma clang diagnostic ignored "-Wdeprecated-declarations"
+    #endif
+#endif // __APPLE__
+
+#include <ucontext.h>
+#include <sys/mman.h> // mprotect
+
+#include "governor.h" // default_page_size()
+
+#ifndef MAP_STACK
+// macOS* does not define MAP_STACK
+#define MAP_STACK 0
+#endif
+#ifndef MAP_ANONYMOUS
+// macOS* defines MAP_ANON, which is deprecated in Linux*.
+#define MAP_ANONYMOUS MAP_ANON
+#endif
+
+namespace tbb {
+namespace internal {
+    struct coroutine_type {
+        coroutine_type() : my_context(), my_stack(), my_stack_size() {}
+        ucontext_t my_context;
+        void* my_stack;
+        size_t my_stack_size;
+    };
+}}
+#endif // _WIN32
+
+namespace tbb {
+namespace internal {
+
+    // Forward declaration of the coroutine API.
+    void create_coroutine(coroutine_type& c, size_t stack_size, void* arg);
+    void current_coroutine(coroutine_type& c);
+    void swap_coroutine(coroutine_type& prev_coroutine, coroutine_type& new_coroutine);
+    void destroy_coroutine(coroutine_type& c);
+
+class co_context {
+    enum co_state {
+        co_invalid,
+        co_suspended,
+        co_executing,
+        co_destroyed
+    };
+    coroutine_type      my_coroutine;
+    co_state            my_state;
+
+public:
+    co_context(size_t stack_size, void* arg)
+        : my_state(arg ? co_suspended : co_executing)
+    {
+        if (arg) {
+            create_coroutine(my_coroutine, stack_size, arg);
+        } else {
+            current_coroutine(my_coroutine);
+        }
+    }
+
+    ~co_context() {
+        __TBB_ASSERT(1 << my_state & (1 << co_suspended | 1 << co_executing), NULL);
+        if (my_state == co_suspended)
+            destroy_coroutine(my_coroutine);
+        my_state = co_destroyed;
+    }
+
+    void resume(co_context& target) {
+        // Do not create non-trivial objects on the stack of this function. They might never be destroyed.
+        __TBB_ASSERT(my_state == co_executing, NULL);
+        __TBB_ASSERT(target.my_state == co_suspended, NULL);
+
+        my_state = co_suspended;
+        target.my_state = co_executing;
+
+        // 'target' can reference an invalid object after swap_coroutine. Do not access it.
+        swap_coroutine(my_coroutine, target.my_coroutine);
+
+        __TBB_ASSERT(my_state == co_executing, NULL);
+    }
+#if !_WIN32
+    void* get_stack_limit() {
+        return my_coroutine.my_stack;
+    }
+#endif
+};
+
+// Defined in scheduler.h
+#if _WIN32
+void __stdcall co_local_wait_for_all(void*);
+#else
+void co_local_wait_for_all(void*);
+#endif
+
+#if _WIN32
+inline void create_coroutine(coroutine_type& c, size_t stack_size, void* arg) {
+    __TBB_ASSERT(arg, NULL);
+    c = CreateFiber(stack_size, co_local_wait_for_all, arg);
+    __TBB_ASSERT(c, NULL);
+}
+
+inline void current_coroutine(coroutine_type& c) {
+    c = IsThreadAFiber() ? GetCurrentFiber() :
+        ConvertThreadToFiberEx(nullptr, FIBER_FLAG_FLOAT_SWITCH);
+    __TBB_ASSERT(c, NULL);
+}
+
+inline void swap_coroutine(coroutine_type& prev_coroutine, coroutine_type& new_coroutine) {
+    __TBB_ASSERT(IsThreadAFiber(), NULL);
+    __TBB_ASSERT(new_coroutine, NULL);
+    prev_coroutine = GetCurrentFiber();
+    __TBB_ASSERT(prev_coroutine, NULL);
+    SwitchToFiber(new_coroutine);
+}
+
+inline void destroy_coroutine(coroutine_type& c) {
+    __TBB_ASSERT(c, NULL);
+    DeleteFiber(c);
+}
+#else // !_WIN32
+
+inline void create_coroutine(coroutine_type& c, size_t stack_size, void* arg) {
+    const size_t REG_PAGE_SIZE = governor::default_page_size();
+    const size_t page_aligned_stack_size = (stack_size + (REG_PAGE_SIZE - 1)) & ~(REG_PAGE_SIZE - 1);
+    const size_t protected_stack_size = page_aligned_stack_size + 2 * REG_PAGE_SIZE;
+
+    // Allocate the stack with protection property
+    uintptr_t stack_ptr = (uintptr_t)mmap(NULL, protected_stack_size, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_STACK, -1, 0);
+    __TBB_ASSERT((void*)stack_ptr != MAP_FAILED, NULL);
+
+    // Allow read write on our stack (guarded pages are still protected)
+    int err = mprotect((void*)(stack_ptr + REG_PAGE_SIZE), page_aligned_stack_size, PROT_READ | PROT_WRITE);
+    __TBB_ASSERT_EX(!err, NULL);
+
+    // Remember the stack state
+    c.my_stack = (void*)(stack_ptr + REG_PAGE_SIZE);
+    c.my_stack_size = page_aligned_stack_size;
+
+    err = getcontext(&c.my_context);
+    __TBB_ASSERT_EX(!err, NULL);
+
+    c.my_context.uc_link = 0;
+    // cast to char* to disable FreeBSD clang-3.4.1 'incompatible type' error
+    c.my_context.uc_stack.ss_sp = (char*)c.my_stack;
+    c.my_context.uc_stack.ss_size = c.my_stack_size;
+    c.my_context.uc_stack.ss_flags = 0;
+
+    typedef void(*coroutine_func_t)();
+    makecontext(&c.my_context, (coroutine_func_t)co_local_wait_for_all, sizeof(arg) / sizeof(int), arg);
+}
+
+inline void current_coroutine(coroutine_type& c) {
+    int err = getcontext(&c.my_context);
+    __TBB_ASSERT_EX(!err, NULL);
+}
+
+inline void swap_coroutine(coroutine_type& prev_coroutine, coroutine_type& new_coroutine) {
+    int err = swapcontext(&prev_coroutine.my_context, &new_coroutine.my_context);
+    __TBB_ASSERT_EX(!err, NULL);
+}
+
+inline void destroy_coroutine(coroutine_type& c) {
+    const size_t REG_PAGE_SIZE = governor::default_page_size();
+    // Free stack memory with guarded pages
+    munmap((void*)((uintptr_t)c.my_stack - REG_PAGE_SIZE), c.my_stack_size + 2 * REG_PAGE_SIZE);
+    // Clear the stack state afterwards
+    c.my_stack = NULL;
+    c.my_stack_size = 0;
+}
+
+#if __APPLE__
+    #if __INTEL_COMPILER
+        #pragma warning(pop) // 1478 warning
+    #elif __clang__
+        #pragma clang diagnostic pop // "-Wdeprecated-declarations"
+    #endif
+#endif
+
+#endif // _WIN32
+
+} // namespace internal
+} // namespace tbb
+
+#endif /* _TBB_co_context_H */
+
diff --git a/src/tbb/src/tbb/concurrent_hash_map.cpp b/src/tbb/src/tbb/concurrent_hash_map.cpp
index d2dcb23d..7ba5c8f8 100644
--- a/src/tbb/src/tbb/concurrent_hash_map.cpp
+++ b/src/tbb/src/tbb/concurrent_hash_map.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 "tbb/concurrent_hash_map.h"
diff --git a/src/tbb/src/tbb/concurrent_monitor.cpp b/src/tbb/src/tbb/concurrent_monitor.cpp
index 5ae3784c..648f314b 100644
--- a/src/tbb/src/tbb/concurrent_monitor.cpp
+++ b/src/tbb/src/tbb/concurrent_monitor.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 "concurrent_monitor.h"
@@ -36,9 +32,9 @@ concurrent_monitor::~concurrent_monitor() {
 void concurrent_monitor::prepare_wait( thread_context& thr, uintptr_t ctx ) {
     if( !thr.ready )
         thr.init();
-    // this is good place to pump previous spurious wakeup
-    else if( thr.spurious ) {
-        thr.spurious = false;
+    // this is good place to pump previous skipped wakeup
+    else if( thr.skipped_wakeup ) {
+        thr.skipped_wakeup = false;
         thr.semaphore().P();
     }
     thr.context = ctx;
@@ -52,18 +48,17 @@ void concurrent_monitor::prepare_wait( thread_context& thr, uintptr_t ctx ) {
 }
 
 void concurrent_monitor::cancel_wait( thread_context& thr ) {
-    // spurious wakeup will be pumped in the following prepare_wait()
-    thr.spurious = true;
+    // possible skipped wakeup will be pumped in the following prepare_wait()
+    thr.skipped_wakeup = true;
     // try to remove node from waitset
     bool th_in_waitset = thr.in_waitset;
     if( th_in_waitset ) {
         tbb::spin_mutex::scoped_lock l( mutex_ec );
         if (thr.in_waitset) {
-            // successfully removed from waitset,
-            // so there will be no spurious wakeup
-            thr.in_waitset = false;
-            thr.spurious = false;
             waitset_ec.remove( (waitset_t::node_t&)thr );
+            // node is removed from waitset, so there will be no wakeup
+            thr.in_waitset = false;
+            thr.skipped_wakeup = false;
         }
     }
 }
diff --git a/src/tbb/src/tbb/concurrent_monitor.h b/src/tbb/src/tbb/concurrent_monitor.h
index 55c4dc92..28479771 100644
--- a/src/tbb/src/tbb/concurrent_monitor.h
+++ b/src/tbb/src/tbb/concurrent_monitor.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_concurrent_monitor_H
@@ -100,13 +96,13 @@ class concurrent_monitor : no_copy {
     class thread_context : waitset_node_t, no_copy {
         friend class concurrent_monitor;
     public:
-        thread_context() : spurious(false), aborted(false), ready(false), context(0) {
+        thread_context() : skipped_wakeup(false), aborted(false), ready(false), context(0) {
             epoch = 0;
             in_waitset = false;
         }
         ~thread_context() {
             if (ready) {
-                if( spurious ) semaphore().P();
+                if( skipped_wakeup ) semaphore().P();
                 semaphore().~binary_semaphore();
             }
         }
@@ -119,7 +115,7 @@ class concurrent_monitor : no_copy {
         tbb::aligned_space<binary_semaphore> sema;
         __TBB_atomic unsigned epoch;
         tbb::atomic<bool> in_waitset;
-        bool  spurious;
+        bool  skipped_wakeup;
         bool  aborted;
         bool  ready;
         uintptr_t context;
diff --git a/src/tbb/src/tbb/concurrent_queue.cpp b/src/tbb/src/tbb/concurrent_queue.cpp
index 2047bacb..ebdda73f 100644
--- a/src/tbb/src/tbb/concurrent_queue.cpp
+++ b/src/tbb/src/tbb/concurrent_queue.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 "tbb/tbb_stddef.h"
@@ -29,8 +25,6 @@
 #include <new>
 #include <cstring>   // for memset()
 
-using namespace std;
-
 #if defined(_MSC_VER) && defined(_Wp64)
     // Workaround for overzealous compiler warnings in /Wp64 mode
     #pragma warning (disable: 4267)
@@ -353,7 +347,7 @@ concurrent_queue_base_v3::concurrent_queue_base_v3( size_t item_sz ) {
     __TBB_ASSERT( is_aligned(&my_rep->head_counter, NFS_GetLineSize()), "alignment error" );
     __TBB_ASSERT( is_aligned(&my_rep->tail_counter, NFS_GetLineSize()), "alignment error" );
     __TBB_ASSERT( is_aligned(&my_rep->array, NFS_GetLineSize()), "alignment error" );
-    memset((void*) my_rep, 0, sizeof(concurrent_queue_rep));
+    std::memset(static_cast<void*>(my_rep),0,sizeof(concurrent_queue_rep));
     new ( &my_rep->items_avail ) concurrent_monitor();
     new ( &my_rep->slots_avail ) concurrent_monitor();
     this->item_size = item_sz;
diff --git a/src/tbb/src/tbb/concurrent_vector.cpp b/src/tbb/src/tbb/concurrent_vector.cpp
index 4ecf0990..660aff15 100644
--- a/src/tbb/src/tbb/concurrent_vector.cpp
+++ b/src/tbb/src/tbb/concurrent_vector.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 (_MSC_VER)
@@ -38,12 +34,10 @@
     #pragma warning (disable: 4267)
 #endif
 
-using namespace std;
-
 namespace tbb {
 
 namespace internal {
-    class concurrent_vector_base_v3::helper :no_assign {
+class concurrent_vector_base_v3::helper :no_assign {
 public:
     //! memory page size
     static const size_type page_size = 4096;
@@ -197,7 +191,7 @@ namespace internal {
                 func( begin, n );
         }
     };
-};
+}; // class helper
 
 void concurrent_vector_base_v3::helper::extend_segment_table(concurrent_vector_base_v3 &v, concurrent_vector_base_v3::size_type start) {
     if( start > segment_size(pointers_per_short_table) ) start = segment_size(pointers_per_short_table);
@@ -337,11 +331,9 @@ concurrent_vector_base_v3::size_type concurrent_vector_base_v3::internal_capacit
 }
 
 void concurrent_vector_base_v3::internal_throw_exception(size_type t) const {
-    switch(t) {
-        case 0: throw_exception(eid_out_of_range);
-        case 1: throw_exception(eid_segment_range_error);
-        case 2: throw_exception(eid_index_range_error);
-    }
+    exception_id ids[] = { eid_out_of_range, eid_segment_range_error, eid_index_range_error };
+    __TBB_ASSERT(t < sizeof(ids) / sizeof(exception_id), NULL);
+    throw_exception(ids[t]);
 }
 
 void concurrent_vector_base_v3::internal_reserve( size_type n, size_type element_size, size_type max_size ) {
diff --git a/src/tbb/src/tbb/condition_variable.cpp b/src/tbb/src/tbb/condition_variable.cpp
index 49ed609f..369a7f77 100644
--- a/src/tbb/src/tbb/condition_variable.cpp
+++ b/src/tbb/src/tbb/condition_variable.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 "tbb/tbb_config.h"
@@ -141,8 +137,18 @@ static const dynamic_link_descriptor CondVarLinkTable[] = {
 void init_condvar_module()
 {
     __TBB_ASSERT( (uintptr_t)__TBB_init_condvar==(uintptr_t)&init_condvar_using_event, NULL );
-    if( dynamic_link( "Kernel32.dll", CondVarLinkTable, 4 ) )
+#if __TBB_WIN8UI_SUPPORT
+    // We expect condition variables to be always available for Windows* store applications,
+    // so there is no need to check presence and use alternative implementation.
+    __TBB_init_condvar = (void (WINAPI *)(PCONDITION_VARIABLE))&InitializeConditionVariable;
+    __TBB_condvar_wait = (BOOL(WINAPI *)(PCONDITION_VARIABLE, LPCRITICAL_SECTION, DWORD))&SleepConditionVariableCS;
+    __TBB_condvar_notify_one = (void (WINAPI *)(PCONDITION_VARIABLE))&WakeConditionVariable;
+    __TBB_condvar_notify_all = (void (WINAPI *)(PCONDITION_VARIABLE))&WakeAllConditionVariable;
+    __TBB_destroy_condvar = (void (WINAPI *)(PCONDITION_VARIABLE))&destroy_condvar_noop;
+#else
+    if (dynamic_link("Kernel32.dll", CondVarLinkTable, 4))
         __TBB_destroy_condvar = (void (WINAPI *)(PCONDITION_VARIABLE))&destroy_condvar_noop;
+#endif
 }
 #endif /* _WIN32||_WIN64 */
 
diff --git a/src/tbb/src/tbb/critical_section.cpp b/src/tbb/src/tbb/critical_section.cpp
index 4b32fb17..9dbb9fa3 100644
--- a/src/tbb/src/tbb/critical_section.cpp
+++ b/src/tbb/src/tbb/critical_section.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 "tbb/critical_section.h"
diff --git a/src/tbb/src/tbb/custom_scheduler.h b/src/tbb/src/tbb/custom_scheduler.h
index c6511b27..f43a3862 100644
--- a/src/tbb/src/tbb/custom_scheduler.h
+++ b/src/tbb/src/tbb/custom_scheduler.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef _TBB_custom_scheduler_H
@@ -56,7 +52,7 @@ template<typename SchedulerTraits>
 class custom_scheduler: private generic_scheduler {
     typedef custom_scheduler<SchedulerTraits> scheduler_type;
 
-    custom_scheduler( market& m ) : generic_scheduler(m) {}
+    custom_scheduler( market& m, bool genuine ) : generic_scheduler(m, genuine) {}
 
     //! Scheduler loop that dispatches tasks.
     /** If child is non-NULL, it is dispatched first.
@@ -75,13 +71,27 @@ class custom_scheduler: private generic_scheduler {
         When changing, remember that this is a hot path function. */
     void tally_completion_of_predecessor( task& s, __TBB_ISOLATION_ARG( task*& bypass_slot, isolation_tag isolation ) ) {
         task_prefix& p = s.prefix();
+        __TBB_ASSERT(p.ref_count > 0, NULL);
         if( SchedulerTraits::itt_possible )
             ITT_NOTIFY(sync_releasing, &p.ref_count);
         if( SchedulerTraits::has_slow_atomic && p.ref_count==1 )
             p.ref_count=0;
-        else if( __TBB_FetchAndDecrementWrelease(&p.ref_count) > 1 ) {// more references exist
-            // '__TBB_cl_evict(&p)' degraded performance of parallel_preorder example
-            return;
+        else {
+            reference_count old_ref_count = __TBB_FetchAndDecrementWrelease(&p.ref_count);
+#if __TBB_PREVIEW_RESUMABLE_TASKS
+            if (old_ref_count == internal::abandon_flag + 2) {
+                // Remove the abandon flag.
+                p.ref_count = 1;
+                // The wait has been completed. Spawn a resume task.
+                tbb::task::resume(p.abandoned_scheduler);
+                return;
+            }
+#endif
+            if (old_ref_count > 1) {
+                // more references exist
+                // '__TBB_cl_evict(&p)' degraded performance of parallel_preorder example
+                return;
+            }
         }
 
         // Ordering on p.ref_count (superfluous if SchedulerTraits::has_slow_atomic)
@@ -109,15 +119,25 @@ class custom_scheduler: private generic_scheduler {
 #endif /*__TBB_RECYCLE_TO_ENQUEUE*/
         if( bypass_slot==NULL )
             bypass_slot = &s;
+#if __TBB_PREVIEW_CRITICAL_TASKS
+        else if( internal::is_critical( s ) ) {
+            local_spawn( bypass_slot, bypass_slot->prefix().next );
+            bypass_slot = &s;
+        }
+#endif /* __TBB_PREVIEW_CRITICAL_TASKS */
         else
             local_spawn( &s, s.prefix().next );
     }
 
+    //! Implements the bypass loop of the dispatch loop (local_wait_for_all).
+    bool process_bypass_loop( context_guard_helper</*report_tasks=*/SchedulerTraits::itt_possible>& context_guard,
+        __TBB_ISOLATION_ARG(task* t, isolation_tag isolation) );
+
 public:
-    static generic_scheduler* allocate_scheduler( market& m ) {
+    static generic_scheduler* allocate_scheduler( market& m, bool genuine ) {
         void* p = NFS_Allocate(1, sizeof(scheduler_type), NULL);
         std::memset(p, 0, sizeof(scheduler_type));
-        scheduler_type* s = new( p ) scheduler_type( m );
+        scheduler_type* s = new( p ) scheduler_type( m, genuine );
         s->assert_task_pool_valid();
         ITT_SYNC_CREATE(s, SyncType_Scheduler, SyncObj_TaskPoolSpinning);
         return s;
@@ -138,6 +158,10 @@ task* custom_scheduler<SchedulerTraits>::receive_or_steal_task( __TBB_ISOLATION_
     bool outermost_worker_level = worker_outermost_level();
     bool outermost_dispatch_level = outermost_worker_level || master_outermost_level();
     bool can_steal_here = can_steal();
+    bool outermost_current_worker_level = outermost_worker_level;
+#if __TBB_PREVIEW_RESUMABLE_TASKS
+    outermost_current_worker_level &= my_properties.genuine;
+#endif
     my_inbox.set_is_idle( true );
 #if __TBB_HOARD_NONLOCAL_TASKS
     __TBB_ASSERT(!my_nonlocal_free_list, NULL);
@@ -165,7 +189,7 @@ task* custom_scheduler<SchedulerTraits>::receive_or_steal_task( __TBB_ISOLATION_
     for( int failure_count = -static_cast<int>(SchedulerTraits::itt_possible);; ++failure_count) {
         __TBB_ASSERT( my_arena->my_limit > 0, NULL );
         __TBB_ASSERT( my_arena_index <= n, NULL );
-        if( completion_ref_count==1 ) {
+        if( completion_ref_count == 1 ) {
             if( SchedulerTraits::itt_possible ) {
                 if( failure_count!=-1 ) {
                     ITT_NOTIFY(sync_prepare, &completion_ref_count);
@@ -182,15 +206,21 @@ task* custom_scheduler<SchedulerTraits>::receive_or_steal_task( __TBB_ISOLATION_
             break; // exit stealing loop and return;
         }
         // Check if the resource manager requires our arena to relinquish some threads
-        if ( outermost_worker_level && (my_arena->my_num_workers_allotted < my_arena->num_workers_active()
-#if __TBB_ENQUEUE_ENFORCED_CONCURRENCY
-                 || my_arena->recall_by_mandatory_request()
-#endif
-                 ) ) {
-            if( SchedulerTraits::itt_possible && failure_count != -1 )
-                ITT_NOTIFY(sync_cancel, this);
+        if ( outermost_current_worker_level ) {
+            if ( ( my_arena->my_num_workers_allotted < my_arena->num_workers_active() ) ) {
+                if ( SchedulerTraits::itt_possible && failure_count != -1 )
+                    ITT_NOTIFY(sync_cancel, this);
+                return NULL;
+            }
+        }
+#if __TBB_PREVIEW_RESUMABLE_TASKS
+        else if ( *my_arena_slot->my_scheduler_is_recalled ) {
+            // Original scheduler was requested, return from stealing loop and recall.
+            if ( my_inbox.is_idle_state(true) )
+                my_inbox.set_is_idle(false);
             return NULL;
         }
+#endif
 #if __TBB_TASK_PRIORITY
         const int p = int(my_arena->my_top_priority);
 #else /* !__TBB_TASK_PRIORITY */
@@ -216,9 +246,15 @@ task* custom_scheduler<SchedulerTraits>::receive_or_steal_task( __TBB_ISOLATION_
             GATHER_STATISTIC( ++my_counters.mails_received );
         }
         // Check if there are tasks in starvation-resistant stream.
-        // Only allowed at the outermost dispatch level.
-        else if ( outermost_dispatch_level && !my_arena->my_task_stream.empty(p)
-                  && (t = my_arena->my_task_stream.pop( p, my_arena_slot->hint_for_pop)) ) {
+        // Only allowed at the outermost dispatch level without isolation.
+        else if (__TBB_ISOLATION_EXPR(isolation == no_isolation &&) outermost_dispatch_level &&
+                 !my_arena->my_task_stream.empty(p) && (
+#if __TBB_PREVIEW_CRITICAL_TASKS && __TBB_CPF_BUILD
+                     t = my_arena->my_task_stream.pop( p, subsequent_lane_selector(my_arena_slot->hint_for_pop) )
+#else
+                     t = my_arena->my_task_stream.pop( p, my_arena_slot->hint_for_pop )
+#endif
+                 ) ) {
             ITT_NOTIFY(sync_acquired, &my_arena->my_task_stream);
             // just proceed with the obtained task
         }
@@ -229,38 +265,16 @@ task* custom_scheduler<SchedulerTraits>::receive_or_steal_task( __TBB_ISOLATION_
             // just proceed with the obtained task
         }
 #endif /* __TBB_TASK_PRIORITY */
-        else if ( can_steal_here && n ) {
-            // Try to steal a task from a random victim.
-            size_t k = my_random.get() % n;
-            arena_slot* victim = &my_arena->my_slots[k];
-            // The following condition excludes the master that might have
-            // already taken our previous place in the arena from the list .
-            // of potential victims. But since such a situation can take
-            // place only in case of significant oversubscription, keeping
-            // the checks simple seems to be preferable to complicating the code.
-            if( k >= my_arena_index )
-                ++victim;               // Adjusts random distribution to exclude self
-            task **pool = victim->task_pool;
-            if( pool == EmptyTaskPool || !(t = steal_task( __TBB_ISOLATION_ARG(*victim, isolation) )) )
-                goto fail;
-            if( is_proxy(*t) ) {
-                task_proxy &tp = *(task_proxy*)t;
-                t = tp.extract_task<task_proxy::pool_bit>();
-                if ( !t ) {
-                    // Proxy was empty, so it's our responsibility to free it
-                    free_task<no_cache_small_task>(tp);
-                    goto fail;
-                }
-                GATHER_STATISTIC( ++my_counters.proxies_stolen );
-            }
-            t->prefix().extra_state |= es_task_is_stolen;
-            if( is_version_3_task(*t) ) {
-                my_innermost_running_task = t;
-                t->prefix().owner = this;
-                t->note_affinity( my_affinity_id );
-            }
-            GATHER_STATISTIC( ++my_counters.steals_committed );
-        } // end of stealing branch
+        else if ( can_steal_here && n && (t = steal_task( __TBB_ISOLATION_EXPR(isolation) )) ) {
+            // just proceed with the obtained task
+        }
+#if __TBB_PREVIEW_CRITICAL_TASKS
+        else if( (t = get_critical_task( __TBB_ISOLATION_EXPR(isolation) )) ) {
+            __TBB_ASSERT( internal::is_critical(*t), "Received task must be critical one" );
+            ITT_NOTIFY(sync_acquired, &my_arena->my_critical_task_stream);
+            // just proceed with the obtained task
+        }
+#endif // __TBB_PREVIEW_CRITICAL_TASKS
         else
             goto fail;
         // A task was successfully obtained somewhere
@@ -324,15 +338,20 @@ task* custom_scheduler<SchedulerTraits>::receive_or_steal_task( __TBB_ISOLATION_
                 }
             }
 #endif /* __TBB_TASK_PRIORITY */
+#if __APPLE__
+            // threshold value tuned separately for macOS due to high cost of sched_yield there
+            const int yield_threshold = 10;
+#else
             const int yield_threshold = 100;
+#endif
             if( yield_count++ >= yield_threshold ) {
                 // When a worker thread has nothing to do, return it to RML.
                 // For purposes of affinity support, the thread is considered idle while in RML.
 #if __TBB_TASK_PRIORITY
-                if( outermost_worker_level || my_arena->my_top_priority > my_arena->my_bottom_priority ) {
-                    if ( my_arena->is_out_of_work() && outermost_worker_level ) {
+                if( outermost_current_worker_level || my_arena->my_top_priority > my_arena->my_bottom_priority ) {
+                    if ( my_arena->is_out_of_work() && outermost_current_worker_level ) {
 #else /* !__TBB_TASK_PRIORITY */
-                    if ( outermost_worker_level && my_arena->is_out_of_work() ) {
+                    if ( outermost_current_worker_level && my_arena->is_out_of_work() ) {
 #endif /* !__TBB_TASK_PRIORITY */
                         if( SchedulerTraits::itt_possible )
                             ITT_NOTIFY(sync_cancel, this);
@@ -367,105 +386,44 @@ task* custom_scheduler<SchedulerTraits>::receive_or_steal_task( __TBB_ISOLATION_
 }
 
 template<typename SchedulerTraits>
-void custom_scheduler<SchedulerTraits>::local_wait_for_all( task& parent, task* child ) {
-    __TBB_ASSERT( governor::is_set(this), NULL );
-    __TBB_ASSERT( parent.ref_count() >= (child && child->parent() == &parent ? 2 : 1), "ref_count is too small" );
-    __TBB_ASSERT( my_innermost_running_task, NULL );
-    assert_task_pool_valid();
-    // Using parent's refcount in sync_prepare (in the stealing loop below) is
-    // a workaround for TP. We need to name it here to display correctly in Ampl.
-    if( SchedulerTraits::itt_possible )
-        ITT_SYNC_CREATE(&parent.prefix().ref_count, SyncType_Scheduler, SyncObj_TaskStealingLoop);
-#if __TBB_TASK_GROUP_CONTEXT
-    __TBB_ASSERT( parent.prefix().context, "parent task does not have context" );
-#endif /* __TBB_TASK_GROUP_CONTEXT */
-    task* t = child;
-    // Constant all_local_work_done is an unreachable refcount value that prevents
-    // early quitting the dispatch loop. It is defined to be in the middle of the range
-    // of negative values representable by the reference_count type.
-    static const reference_count
-        // For normal dispatch loops
-        parents_work_done = 1,
-        // For termination dispatch loops in masters
-        all_local_work_done = (reference_count)3 << (sizeof(reference_count) * 8 - 2);
-    reference_count quit_point;
-#if __TBB_TASK_PRIORITY
-    __TBB_ASSERT( (uintptr_t)*my_ref_top_priority < (uintptr_t)num_priority_levels, NULL );
-    volatile intptr_t *old_ref_top_priority = my_ref_top_priority;
-    // When entering nested parallelism level market level counter
-    // must be replaced with the one local to this arena.
-    volatile uintptr_t *old_ref_reload_epoch = my_ref_reload_epoch;
-#endif /* __TBB_TASK_PRIORITY */
-    task* old_innermost_running_task = my_innermost_running_task;
-    scheduler_properties old_properties = my_properties;
-    // Remove outermost property to indicate nested level.
-    __TBB_ASSERT( my_properties.outermost || my_innermost_running_task!=my_dummy_task, "The outermost property should be set out of a dispatch loop" );
-    my_properties.outermost &= my_innermost_running_task==my_dummy_task;
-#if __TBB_TASK_ISOLATION
-    isolation_tag isolation = my_innermost_running_task->prefix().isolation;
-#endif /* __TBB_TASK_ISOLATION */
-    if( master_outermost_level() ) {
-        // We are in the outermost task dispatch loop of a master thread or a worker which mimics master
-        quit_point = &parent == my_dummy_task ? all_local_work_done : parents_work_done;
-    } else {
-        quit_point = parents_work_done;
-#if __TBB_TASK_PRIORITY
-        if ( &parent != my_dummy_task ) {
-            // We are in a nested dispatch loop.
-            // Market or arena priority must not prevent child tasks from being
-            // executed so that dynamic priority changes did not cause deadlock.
-            my_ref_top_priority = &parent.prefix().context->my_priority;
-            my_ref_reload_epoch = &my_arena->my_reload_epoch;
-            if(my_ref_reload_epoch != old_ref_reload_epoch)
-                my_local_reload_epoch = *my_ref_reload_epoch-1;
-        }
-#endif /* __TBB_TASK_PRIORITY */
-    }
-
-    cpu_ctl_env_helper cpu_ctl_helper;
-    if ( t ) {
-        cpu_ctl_helper.set_env( __TBB_CONTEXT_ARG1(t->prefix().context) );
-#if __TBB_TASK_ISOLATION
-        if ( isolation != no_isolation ) {
-            __TBB_ASSERT( t->prefix().isolation == no_isolation, NULL );
-            // Propagate the isolation to the task executed without spawn.
-            t->prefix().isolation = isolation;
-        }
-#endif /* __TBB_TASK_ISOLATION */
-    }
-
-#if TBB_USE_EXCEPTIONS
-    // Infinite safeguard EH loop
-    for (;;) {
-    try {
-#endif /* TBB_USE_EXCEPTIONS */
-    // Outer loop receives tasks from global environment (via mailbox, FIFO queue(s),
-    // and by  stealing from other threads' task pools).
-    // All exit points from the dispatch loop are located in its immediate scope.
-    for(;;) {
-        // Middle loop retrieves tasks from the local task pool.
-        for(;;) {
-            // Inner loop evaluates tasks coming from nesting loops and those returned
-            // by just executed tasks (bypassing spawn or enqueue calls).
-            while(t) {
-                __TBB_ASSERT( my_inbox.is_idle_state(false), NULL );
-                __TBB_ASSERT(!is_proxy(*t),"unexpected proxy");
-                __TBB_ASSERT( t->prefix().owner, NULL );
+bool custom_scheduler<SchedulerTraits>::process_bypass_loop(
+            context_guard_helper</*report_tasks=*/SchedulerTraits::itt_possible>& context_guard,
+            __TBB_ISOLATION_ARG(task* t, isolation_tag isolation) )
+{
+    while ( t ) {
+        __TBB_ASSERT( my_inbox.is_idle_state(false), NULL );
+        __TBB_ASSERT(!is_proxy(*t),"unexpected proxy");
+        __TBB_ASSERT( t->prefix().owner, NULL );
 #if __TBB_TASK_ISOLATION
-                __TBB_ASSERT( isolation == no_isolation || isolation == t->prefix().isolation,
-                    "A task from another isolated region is going to be executed" );
+        __TBB_ASSERT_EX( isolation == no_isolation || isolation == t->prefix().isolation,
+            "A task from another isolated region is going to be executed" );
 #endif /* __TBB_TASK_ISOLATION */
-                assert_task_valid(t);
+        assert_task_valid(t);
 #if __TBB_TASK_GROUP_CONTEXT && TBB_USE_ASSERT
-                assert_context_valid(t->prefix().context);
-                if ( !t->prefix().context->my_cancellation_requested )
+        assert_context_valid(t->prefix().context);
+        if ( !t->prefix().context->my_cancellation_requested )
 #endif
-                // TODO: make the assert stronger by prohibiting allocated state.
-                __TBB_ASSERT( 1L<<t->state() & (1L<<task::allocated|1L<<task::ready|1L<<task::reexecute), NULL );
-                assert_task_pool_valid();
+        // TODO: make the assert stronger by prohibiting allocated state.
+        __TBB_ASSERT( 1L<<t->state() & (1L<<task::allocated|1L<<task::ready|1L<<task::reexecute), NULL );
+        assert_task_pool_valid();
+#if __TBB_PREVIEW_CRITICAL_TASKS
+        // TODO: check performance and optimize if needed for added conditions on the
+        // hot-path.
+        if( !internal::is_critical(*t) && !t->is_enqueued_task() ) {
+            if( task* critical_task = get_critical_task( __TBB_ISOLATION_EXPR(isolation) ) ) {
+                __TBB_ASSERT( internal::is_critical(*critical_task),
+                              "Received task must be critical one" );
+                ITT_NOTIFY(sync_acquired, &my_arena->my_critical_task_stream);
+                t->prefix().state = task::allocated;
+                my_innermost_running_task = t; // required during spawn to propagate isolation
+                local_spawn(t, t->prefix().next);
+                t = critical_task;
+            } else {
+#endif /* __TBB_PREVIEW_CRITICAL_TASKS */
 #if __TBB_TASK_PRIORITY
                 intptr_t p = priority(*t);
-                if ( p != *my_ref_top_priority && (t->prefix().extra_state & es_task_enqueued) == 0) {
+                if ( p != *my_ref_top_priority
+                     && !t->is_enqueued_task() ) {
                     assert_priority_valid(p);
                     if ( p != my_arena->my_top_priority ) {
                         my_market->update_arena_priority( *my_arena, p );
@@ -473,10 +431,12 @@ void custom_scheduler<SchedulerTraits>::local_wait_for_all( task& parent, task*
                     if ( p < effective_reference_priority() ) {
                         if ( !my_offloaded_tasks ) {
                             my_offloaded_task_list_tail_link = &t->prefix().next_offloaded;
-                            // Erase possible reference to the owner scheduler (next_offloaded is a union member)
+                            // Erase possible reference to the owner scheduler
+                            // (next_offloaded is a union member)
                             *my_offloaded_task_list_tail_link = NULL;
                         }
                         offload_task( *t, p );
+                        t = NULL;
                         if ( is_task_pool_published() ) {
                             t = winnow_task_pool( __TBB_ISOLATION_EXPR( isolation ) );
                             if ( t )
@@ -486,116 +446,237 @@ void custom_scheduler<SchedulerTraits>::local_wait_for_all( task& parent, task*
                             // by arena::is_out_of_work(), and ensure worker's presence.
                             my_arena->advertise_new_work<arena::wakeup>();
                         }
-                        goto stealing_ground;
+                        break; /* exit bypass loop */
                     }
                 }
 #endif /* __TBB_TASK_PRIORITY */
-                task* t_next = NULL;
-                my_innermost_running_task = t;
-                t->prefix().owner = this;
-                t->prefix().state = task::executing;
+#if __TBB_PREVIEW_CRITICAL_TASKS
+            }
+        } // if is not critical
+#endif
+        task* t_next = NULL;
+        my_innermost_running_task = t;
+        t->prefix().owner = this;
+        t->prefix().state = task::executing;
 #if __TBB_TASK_GROUP_CONTEXT
-                if ( !t->prefix().context->my_cancellation_requested )
+        context_guard.set_ctx( t->prefix().context );
+        if ( !t->prefix().context->my_cancellation_requested )
 #endif
-                {
-                    GATHER_STATISTIC( ++my_counters.tasks_executed );
-                    GATHER_STATISTIC( my_counters.avg_arena_concurrency += my_arena->num_workers_active() );
-                    GATHER_STATISTIC( my_counters.avg_assigned_workers += my_arena->my_num_workers_allotted );
+        {
+            GATHER_STATISTIC( ++my_counters.tasks_executed );
+            GATHER_STATISTIC( my_counters.avg_arena_concurrency += my_arena->num_workers_active() );
+            GATHER_STATISTIC( my_counters.avg_assigned_workers += my_arena->my_num_workers_allotted );
 #if __TBB_TASK_PRIORITY
-                    GATHER_STATISTIC( my_counters.avg_arena_prio += p );
-                    GATHER_STATISTIC( my_counters.avg_market_prio += my_market->my_global_top_priority );
+            GATHER_STATISTIC( my_counters.avg_arena_prio += p );
+            GATHER_STATISTIC( my_counters.avg_market_prio += my_market->my_global_top_priority );
 #endif /* __TBB_TASK_PRIORITY */
-                    ITT_STACK(SchedulerTraits::itt_possible, callee_enter, t->prefix().context->itt_caller);
-                    t_next = t->execute();
-                    ITT_STACK(SchedulerTraits::itt_possible, callee_leave, t->prefix().context->itt_caller);
-                    if (t_next) {
-                        __TBB_ASSERT( t_next->state()==task::allocated,
-                                "if task::execute() returns task, it must be marked as allocated" );
-                        reset_extra_state(t_next);
-                        __TBB_ISOLATION_EXPR( t_next->prefix().isolation = t->prefix().isolation );
+            ITT_STACK(SchedulerTraits::itt_possible, callee_enter, t->prefix().context->itt_caller);
+            t_next = t->execute();
+            ITT_STACK(SchedulerTraits::itt_possible, callee_leave, t->prefix().context->itt_caller);
+            if (t_next) {
+                assert_task_valid(t_next);
+                __TBB_ASSERT( t_next->state()==task::allocated,
+                              "if task::execute() returns task, it must be marked as allocated" );
+                reset_extra_state(t_next);
+                __TBB_ISOLATION_EXPR( t_next->prefix().isolation = t->prefix().isolation );
 #if TBB_USE_ASSERT
-                        affinity_id next_affinity=t_next->prefix().affinity;
-                        if (next_affinity != 0 && next_affinity != my_affinity_id)
-                            GATHER_STATISTIC( ++my_counters.affinity_ignored );
+                affinity_id next_affinity=t_next->prefix().affinity;
+                if (next_affinity != 0 && next_affinity != my_affinity_id)
+                    GATHER_STATISTIC( ++my_counters.affinity_ignored );
 #endif
-                    }
-                }
+            } // if there is bypassed task
+        }
+        assert_task_pool_valid();
+        switch( t->state() ) {
+            case task::executing: {
+                task* s = t->parent();
+                __TBB_ASSERT( my_innermost_running_task==t, NULL );
+                __TBB_ASSERT( t->prefix().ref_count==0, "Task still has children after it has been executed" );
+                t->~task();
+                if( s )
+                    tally_completion_of_predecessor( *s, __TBB_ISOLATION_ARG( t_next, t->prefix().isolation ) );
+                free_task<no_hint>( *t );
+                poison_pointer( my_innermost_running_task );
                 assert_task_pool_valid();
-                switch( t->state() ) {
-                    case task::executing: {
-                        task* s = t->parent();
-                        __TBB_ASSERT( my_innermost_running_task==t, NULL );
-                        __TBB_ASSERT( t->prefix().ref_count==0, "Task still has children after it has been executed" );
-                        t->~task();
-                        if( s )
-                            tally_completion_of_predecessor( *s, __TBB_ISOLATION_ARG( t_next, t->prefix().isolation ) );
-                        free_task<no_hint>( *t );
-                        poison_pointer( my_innermost_running_task );
-                        assert_task_pool_valid();
-                        break;
-                    }
+                break;
+            }
 
-                    case task::recycle: // set by recycle_as_safe_continuation()
-                        t->prefix().state = task::allocated;
+            case task::recycle: // set by recycle_as_safe_continuation()
+                t->prefix().state = task::allocated;
 #if __TBB_RECYCLE_TO_ENQUEUE
-                    case task::to_enqueue: // set by recycle_to_enqueue()
+                __TBB_fallthrough;
+            case task::to_enqueue: // set by recycle_to_enqueue()
+#endif
+                __TBB_ASSERT( t_next != t, "a task returned from method execute() can not be recycled in another way" );
+                reset_extra_state(t);
+                // for safe continuation, need atomically decrement ref_count;
+                tally_completion_of_predecessor(*t, __TBB_ISOLATION_ARG( t_next, t->prefix().isolation ) );
+                assert_task_pool_valid();
+                break;
+
+            case task::reexecute: // set by recycle_to_reexecute()
+                __TBB_ASSERT( t_next, "reexecution requires that method execute() return another task" );
+                __TBB_ASSERT( t_next != t, "a task returned from method execute() can not be recycled in another way" );
+                t->prefix().state = task::allocated;
+                reset_extra_state(t);
+                local_spawn( t, t->prefix().next );
+                assert_task_pool_valid();
+                break;
+            case task::allocated:
+                reset_extra_state(t);
+                break;
+#if __TBB_PREVIEW_RESUMABLE_TASKS
+            case task::to_resume:
+                __TBB_ASSERT(my_innermost_running_task == t, NULL);
+                __TBB_ASSERT(t->prefix().ref_count == 0, "Task still has children after it has been executed");
+                t->~task();
+                free_task<no_hint>(*t);
+                __TBB_ASSERT(!my_properties.genuine && my_properties.outermost,
+                    "Only a coroutine on outermost level can be left.");
+                // Leave the outermost coroutine
+                return false;
 #endif
-                        __TBB_ASSERT( t_next != t, "a task returned from method execute() can not be recycled in another way" );
-                        reset_extra_state(t);
-                        // for safe continuation, need atomically decrement ref_count;
-                        tally_completion_of_predecessor(*t, __TBB_ISOLATION_ARG( t_next, t->prefix().isolation ) );
-                        assert_task_pool_valid();
-                        break;
-
-                    case task::reexecute: // set by recycle_to_reexecute()
-                        __TBB_ASSERT( t_next, "reexecution requires that method execute() return another task" );
-                        __TBB_ASSERT( t_next != t, "a task returned from method execute() can not be recycled in another way" );
-                        t->prefix().state = task::allocated;
-                        reset_extra_state(t);
-                        local_spawn( t, t->prefix().next );
-                        assert_task_pool_valid();
-                        break;
-                    case task::allocated:
-                        reset_extra_state(t);
-                        break;
 #if TBB_USE_ASSERT
-                    case task::ready:
-                        __TBB_ASSERT( false, "task is in READY state upon return from method execute()" );
-                        break;
-                    default:
-                        __TBB_ASSERT( false, "illegal state" );
-#else
-                    default: // just to shut up some compilation warnings
-                        break;
-#endif /* TBB_USE_ASSERT */
-                }
-                GATHER_STATISTIC( t_next ? ++my_counters.spawns_bypassed : 0 );
-                t = t_next;
-            } // end of scheduler bypass loop
+            case task::ready:
+                __TBB_ASSERT( false, "task is in READY state upon return from method execute()" );
+                break;
+#endif
+            default:
+                __TBB_ASSERT( false, "illegal state" );
+                break;
+        }
+        GATHER_STATISTIC( t_next ? ++my_counters.spawns_bypassed : 0 );
+        t = t_next;
+    } // end of scheduler bypass loop
+    return true;
+}
 
-            assert_task_pool_valid();
-            if ( parent.prefix().ref_count == quit_point ) {
-                __TBB_ASSERT( quit_point != all_local_work_done, NULL );
+// TODO: Rename args 'parent' into 'controlling_task' and 'child' into 't' or consider introducing
+// a wait object (a la task_handle) to replace the 'parent' logic.
+template<typename SchedulerTraits>
+void custom_scheduler<SchedulerTraits>::local_wait_for_all( task& parent, task* child ) {
+    __TBB_ASSERT( governor::is_set(this), NULL );
+    __TBB_ASSERT( parent.ref_count() >= (child && child->parent() == &parent ? 2 : 1), "ref_count is too small" );
+    __TBB_ASSERT( my_innermost_running_task, NULL );
+#if __TBB_TASK_GROUP_CONTEXT
+    __TBB_ASSERT( parent.prefix().context, "parent task does not have context" );
+#endif /* __TBB_TASK_GROUP_CONTEXT */
+    assert_task_pool_valid();
+    // Using parent's refcount in sync_prepare (in the stealing loop below) is
+    // a workaround for TP. We need to name it here to display correctly in Ampl.
+    if( SchedulerTraits::itt_possible )
+        ITT_SYNC_CREATE(&parent.prefix().ref_count, SyncType_Scheduler, SyncObj_TaskStealingLoop);
+
+    // TODO: consider extending the "context" guard to a "dispatch loop" guard to additionally
+    // guard old_innermost_running_task and old_properties states.
+    context_guard_helper</*report_tasks=*/SchedulerTraits::itt_possible> context_guard;
+    task* old_innermost_running_task = my_innermost_running_task;
+    scheduler_properties old_properties = my_properties;
+
+    task* t = child;
+    bool cleanup = !is_worker() && &parent==my_dummy_task;
+    // Remove outermost property to indicate nested level.
+    __TBB_ASSERT(my_properties.outermost || my_innermost_running_task!=my_dummy_task, "The outermost property should be set out of a dispatch loop");
+    my_properties.outermost &= my_innermost_running_task==my_dummy_task;
+#if __TBB_PREVIEW_CRITICAL_TASKS
+    my_properties.has_taken_critical_task |= is_critical(*my_innermost_running_task);
+#endif
+#if __TBB_TASK_PRIORITY
+    __TBB_ASSERT( (uintptr_t)*my_ref_top_priority < (uintptr_t)num_priority_levels, NULL );
+    volatile intptr_t *old_ref_top_priority = my_ref_top_priority;
+    // When entering nested parallelism level market level counter
+    // must be replaced with the one local to this arena.
+    volatile uintptr_t *old_ref_reload_epoch = my_ref_reload_epoch;
+    if ( !outermost_level() ) {
+        // We are in a nested dispatch loop.
+        // Market or arena priority must not prevent child tasks from being
+        // executed so that dynamic priority changes did not cause deadlock.
+        my_ref_top_priority = &parent.prefix().context->my_priority;
+        my_ref_reload_epoch = &my_arena->my_reload_epoch;
+        if (my_ref_reload_epoch != old_ref_reload_epoch)
+            my_local_reload_epoch = *my_ref_reload_epoch - 1;
+    }
+#endif /* __TBB_TASK_PRIORITY */
+#if __TBB_TASK_ISOLATION
+    isolation_tag isolation = my_innermost_running_task->prefix().isolation;
+    if (t && isolation != no_isolation) {
+        __TBB_ASSERT(t->prefix().isolation == no_isolation, NULL);
+        // Propagate the isolation to the task executed without spawn.
+        t->prefix().isolation = isolation;
+    }
+#endif /* __TBB_TASK_ISOLATION */
+#if __TBB_PREVIEW_RESUMABLE_TASKS
+    // The recall flag for the original owner of this scheduler.
+    // It is used only on outermost level of currently attached arena slot.
+    tbb::atomic<bool> recall_flag;
+    recall_flag = false;
+    if (outermost_level() && my_wait_task == NULL && my_properties.genuine) {
+        __TBB_ASSERT(my_arena_slot->my_scheduler == this, NULL);
+        __TBB_ASSERT(my_arena_slot->my_scheduler_is_recalled == NULL, NULL);
+        my_arena_slot->my_scheduler_is_recalled = &recall_flag;
+        my_current_is_recalled = &recall_flag;
+    }
+    __TBB_ASSERT(my_arena_slot->my_scheduler_is_recalled != NULL, NULL);
+    task* old_wait_task = my_wait_task;
+    my_wait_task = &parent;
+#endif
+#if TBB_USE_EXCEPTIONS
+    // Infinite safeguard EH loop
+    for (;;) {
+    try {
+#endif /* TBB_USE_EXCEPTIONS */
+    // Outer loop receives tasks from global environment (via mailbox, FIFO queue(s),
+    // and by  stealing from other threads' task pools).
+    // All exit points from the dispatch loop are located in its immediate scope.
+    for(;;) {
+        // Middle loop retrieves tasks from the local task pool.
+        for(;;) {
+            // Inner loop evaluates tasks coming from nesting loops and those returned
+            // by just executed tasks (bypassing spawn or enqueue calls).
+            if ( !process_bypass_loop( context_guard, __TBB_ISOLATION_ARG(t, isolation) ) ) {
+#if __TBB_PREVIEW_RESUMABLE_TASKS
+                // Restore the old properties for the coroutine reusage (leave in a valid state)
+                my_innermost_running_task = old_innermost_running_task;
+                my_properties = old_properties;
+                my_wait_task = old_wait_task;
+#endif
+                return;
+            }
+
+            // Check "normal" exit condition when parent's work is done.
+            if ( parent.prefix().ref_count == 1 ) {
+                __TBB_ASSERT( !cleanup, NULL );
                 __TBB_control_consistency_helper(); // on ref_count
-                ITT_NOTIFY(sync_acquired, &parent.prefix().ref_count);
+                ITT_NOTIFY( sync_acquired, &parent.prefix().ref_count );
                 goto done;
             }
-            if ( is_task_pool_published() ) {
-                t = get_task( __TBB_ISOLATION_EXPR( isolation ) );
-            } else {
-                __TBB_ASSERT( is_quiescent_local_task_pool_reset(), NULL );
-                break;
+#if __TBB_PREVIEW_RESUMABLE_TASKS
+            // The thread may be otside of its original scheduler. Check the recall request.
+            if ( &recall_flag != my_arena_slot->my_scheduler_is_recalled ) {
+                __TBB_ASSERT( my_arena_slot->my_scheduler_is_recalled != NULL, "A broken recall flag" );
+                if ( *my_arena_slot->my_scheduler_is_recalled ) {
+                    if ( !resume_original_scheduler() ) {
+                        // We are requested to finish the current coroutine before the resume.
+                        __TBB_ASSERT( !my_properties.genuine && my_properties.outermost,
+                            "Only a coroutine on outermost level can be left." );
+                        // Restore the old properties for the coroutine reusage (leave in a valid state)
+                        my_innermost_running_task = old_innermost_running_task;
+                        my_properties = old_properties;
+                        my_wait_task = old_wait_task;
+                        return;
+                    }
+                }
             }
+#endif
+            // Retrieve the task from local task pool.
+            __TBB_ASSERT( is_task_pool_published() || is_quiescent_local_task_pool_reset(), NULL );
+            t = is_task_pool_published() ? get_task( __TBB_ISOLATION_EXPR( isolation ) ) : NULL;
             assert_task_pool_valid();
 
-            if ( !t ) break;
-
-            cpu_ctl_helper.set_env( __TBB_CONTEXT_ARG1(t->prefix().context) );
+            if ( !t ) // No tasks in the local task pool. Go to stealing loop.
+                break;
         }; // end of local task pool retrieval loop
 
-#if __TBB_TASK_PRIORITY
-stealing_ground:
-#endif /* __TBB_TASK_PRIORITY */
 #if __TBB_HOARD_NONLOCAL_TASKS
         // before stealing, previously stolen task objects are returned
         for (; my_nonlocal_free_list; my_nonlocal_free_list = t ) {
@@ -603,7 +684,7 @@ void custom_scheduler<SchedulerTraits>::local_wait_for_all( task& parent, task*
             free_nonlocal_small_task( *my_nonlocal_free_list );
         }
 #endif
-        if ( quit_point == all_local_work_done ) {
+        if ( cleanup ) {
             __TBB_ASSERT( !is_task_pool_published() && is_quiescent_local_task_pool_reset(), NULL );
             __TBB_ASSERT( !worker_outermost_level(), NULL );
             my_innermost_running_task = old_innermost_running_task;
@@ -614,22 +695,45 @@ void custom_scheduler<SchedulerTraits>::local_wait_for_all( task& parent, task*
                 my_local_reload_epoch = *old_ref_reload_epoch-1;
             my_ref_reload_epoch = old_ref_reload_epoch;
 #endif /* __TBB_TASK_PRIORITY */
+#if __TBB_PREVIEW_RESUMABLE_TASKS
+            if (&recall_flag != my_arena_slot->my_scheduler_is_recalled) {
+                // The recall point
+                __TBB_ASSERT(!recall_flag, NULL);
+                tbb::task::suspend(recall_functor(&recall_flag));
+                if (my_inbox.is_idle_state(true))
+                    my_inbox.set_is_idle(false);
+                continue;
+            }
+            __TBB_ASSERT(&recall_flag == my_arena_slot->my_scheduler_is_recalled, NULL);
+            __TBB_ASSERT(!(my_wait_task->prefix().ref_count & internal::abandon_flag), NULL);
+            my_wait_task = old_wait_task;
+#endif
             return;
         }
-        
         t = receive_or_steal_task( __TBB_ISOLATION_ARG( parent.prefix().ref_count, isolation ) );
-        if ( !t )
+        if ( !t ) {
+#if __TBB_PREVIEW_RESUMABLE_TASKS
+            if ( *my_arena_slot->my_scheduler_is_recalled )
+                continue;
+            // Done if either original thread enters or we are on the nested level or attached the same arena
+            if ( &recall_flag == my_arena_slot->my_scheduler_is_recalled || old_wait_task != NULL )
+                goto done;
+            // The recall point. Continue dispatch loop because recalled thread may have tasks in it's task pool.
+            __TBB_ASSERT(!recall_flag, NULL);
+            tbb::task::suspend( recall_functor(&recall_flag) );
+            if ( my_inbox.is_idle_state(true) )
+                my_inbox.set_is_idle(false);
+#else
+            // Just exit dispatch loop
             goto done;
-
-        // The user can capture another the FPU settings to the context so the
-        // cached data in the helper can be out-of-date and we cannot do fast
-        // check.
-        cpu_ctl_helper.set_env( __TBB_CONTEXT_ARG1(t->prefix().context) );
+#endif
+        }
     } // end of infinite stealing loop
 #if TBB_USE_EXCEPTIONS
     __TBB_ASSERT( false, "Must never get here" );
     } // end of try-block
-    TbbCatchAll( t->prefix().context );
+    TbbCatchAll( my_innermost_running_task->prefix().context );
+    t = my_innermost_running_task;
     // Complete post-processing ...
     if( t->state() == task::recycle
 #if __TBB_RECYCLE_TO_ENQUEUE
@@ -652,6 +756,25 @@ void custom_scheduler<SchedulerTraits>::local_wait_for_all( task& parent, task*
     __TBB_ASSERT( false, "Must never get here too" );
 #endif /* TBB_USE_EXCEPTIONS */
 done:
+#if __TBB_PREVIEW_RESUMABLE_TASKS
+    __TBB_ASSERT(!(parent.prefix().ref_count & internal::abandon_flag), NULL);
+    my_wait_task = old_wait_task;
+    if (my_wait_task == NULL) {
+        __TBB_ASSERT(outermost_level(), "my_wait_task could be NULL only on outermost level");
+        if (&recall_flag != my_arena_slot->my_scheduler_is_recalled) {
+            // The recall point.
+            __TBB_ASSERT(my_properties.genuine, NULL);
+            __TBB_ASSERT(!recall_flag, NULL);
+            tbb::task::suspend(recall_functor(&recall_flag));
+            if (my_inbox.is_idle_state(true))
+                my_inbox.set_is_idle(false);
+        }
+        __TBB_ASSERT(my_arena_slot->my_scheduler == this, NULL);
+        my_arena_slot->my_scheduler_is_recalled = NULL;
+        my_current_is_recalled = NULL;
+    }
+
+#endif /* __TBB_PREVIEW_RESUMABLE_TASKS */
     my_innermost_running_task = old_innermost_running_task;
     my_properties = old_properties;
 #if __TBB_TASK_PRIORITY
@@ -661,7 +784,7 @@ void custom_scheduler<SchedulerTraits>::local_wait_for_all( task& parent, task*
     my_ref_reload_epoch = old_ref_reload_epoch;
 #endif /* __TBB_TASK_PRIORITY */
     if ( !ConcurrentWaitsEnabled(parent) ) {
-        if ( parent.prefix().ref_count != parents_work_done ) {
+        if ( parent.prefix().ref_count != 1) {
             // This is a worker that was revoked by the market.
             __TBB_ASSERT( worker_outermost_level(),
                 "Worker thread exits nested dispatch loop prematurely" );
@@ -688,7 +811,7 @@ void custom_scheduler<SchedulerTraits>::local_wait_for_all( task& parent, task*
             // On Windows, FPU control settings changed in the helper destructor are not visible
             // outside a catch block. So restore the default settings manually before rethrowing
             // the exception.
-            cpu_ctl_helper.restore_default();
+            context_guard.restore_default();
             TbbRethrowException( pe );
         }
     }
diff --git a/src/tbb/src/tbb/dynamic_link.cpp b/src/tbb/src/tbb/dynamic_link.cpp
index b51280d0..d17f042b 100644
--- a/src/tbb/src/tbb/dynamic_link.cpp
+++ b/src/tbb/src/tbb/dynamic_link.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 "dynamic_link.h"
@@ -54,7 +50,7 @@
     #pragma weak dlclose
 #endif /* __TBB_WEAK_SYMBOLS_PRESENT && !__TBB_DYNAMIC_LOAD_ENABLED */
 
-#include "tbb/tbb_misc.h"
+#include "tbb_misc.h"
 
 #define __USE_TBB_ATOMICS       ( !(__linux__&&__ia64__) || __TBB_BUILD )
 #define __USE_STATIC_DL_INIT    ( !__ANDROID__ )
@@ -362,21 +358,20 @@ OPEN_INTERNAL_NAMESPACE
         in  len  -- Size of buffer.
         ret      -- 0         -- Error occurred.
                     > len     -- Buffer too short, required size returned.
-                    otherwise -- Ok, number of characters (not counting terminating null) written to
-                    buffer.
+                    otherwise -- Ok, number of characters (incl. terminating null) written to buffer.
     */
     static size_t abs_path( char const * name, char * path, size_t len ) {
-        if ( !ap_data._len )
+        if ( ap_data._len == 0 )
             return 0;
 
         size_t name_len = strlen( name );
         size_t full_len = name_len+ap_data._len;
         if ( full_len < len ) {
-            strncpy( path, ap_data._path, ap_data._len );
-            memcpy( path+ap_data._len, name, name_len );
-            path[full_len] = 0;
+            __TBB_ASSERT(ap_data._path[ap_data._len] == 0, NULL);
+            strcpy( path, ap_data._path );
+            strcat( path, name );
         }
-        return full_len;
+        return full_len+1; // +1 for null character
     }
 #endif  // __TBB_DYNAMIC_LOAD_ENABLED
 
@@ -512,37 +507,37 @@ OPEN_INTERNAL_NAMESPACE
     }
 
     dynamic_link_handle dynamic_load( const char* library, const dynamic_link_descriptor descriptors[], size_t required ) {
-    ::tbb::internal::suppress_unused_warning( library, descriptors, required );
-    #if __TBB_DYNAMIC_LOAD_ENABLED
+        ::tbb::internal::suppress_unused_warning( library, descriptors, required );
+#if __TBB_DYNAMIC_LOAD_ENABLED
 
-    size_t const len = PATH_MAX + 1;
-    char path[ len ];
-    size_t rc = abs_path( library, path, len );
-    if ( 0 < rc && rc < len ) {
+        size_t const len = PATH_MAX + 1;
+        char path[ len ];
+        size_t rc = abs_path( library, path, len );
+        if ( 0 < rc && rc <= len ) {
 #if _WIN32
-        // Prevent Windows from displaying silly message boxes if it fails to load library
-        // (e.g. because of MS runtime problems - one of those crazy manifest related ones)
-        UINT prev_mode = SetErrorMode (SEM_FAILCRITICALERRORS);
+            // Prevent Windows from displaying silly message boxes if it fails to load library
+            // (e.g. because of MS runtime problems - one of those crazy manifest related ones)
+            UINT prev_mode = SetErrorMode (SEM_FAILCRITICALERRORS);
 #endif /* _WIN32 */
-        dynamic_link_handle library_handle = dlopen( path, RTLD_LAZY );
+            dynamic_link_handle library_handle = dlopen( path, RTLD_LAZY );
 #if _WIN32
-        SetErrorMode (prev_mode);
+            SetErrorMode (prev_mode);
 #endif /* _WIN32 */
-        if( library_handle ) {
-            if( !resolve_symbols( library_handle, descriptors, required ) ) {
-                // The loaded library does not contain all the expected entry points
-                dynamic_unlink( library_handle );
-                library_handle = NULL;
-            }
-        } else
-            DYNAMIC_LINK_WARNING( dl_lib_not_found, path, dlerror() );
-        return library_handle;
-    } else if ( rc>=len )
-            DYNAMIC_LINK_WARNING( dl_buff_too_small );
-            // rc == 0 means failing of init_ap_data so the warning has already been issued.
+            if( library_handle ) {
+                if( !resolve_symbols( library_handle, descriptors, required ) ) {
+                    // The loaded library does not contain all the expected entry points
+                    dynamic_unlink( library_handle );
+                    library_handle = NULL;
+                }
+            } else
+                DYNAMIC_LINK_WARNING( dl_lib_not_found, path, dlerror() );
+            return library_handle;
+        } else if ( rc>len )
+                DYNAMIC_LINK_WARNING( dl_buff_too_small );
+                // rc == 0 means failing of init_ap_data so the warning has already been issued.
 
-    #endif /* __TBB_DYNAMIC_LOAD_ENABLED */
-        return 0;
+#endif /* __TBB_DYNAMIC_LOAD_ENABLED */
+            return 0;
     }
 
     bool dynamic_link( const char* library, const dynamic_link_descriptor descriptors[], size_t required, dynamic_link_handle *handle, int flags ) {
diff --git a/src/tbb/src/tbb/dynamic_link.h b/src/tbb/src/tbb/dynamic_link.h
index cff51180..15b8410e 100644
--- a/src/tbb/src/tbb/dynamic_link.h
+++ b/src/tbb/src/tbb/dynamic_link.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_dynamic_link
@@ -55,8 +51,10 @@ typedef void (*pointer_to_handler)();
 // prevent warnings from some compilers (g++ 4.1)
 #if __TBB_WEAK_SYMBOLS_PRESENT
 #define DLD(s,h) {#s, (pointer_to_handler*)(void*)(&h), (pointer_to_handler)&s}
+#define DLD_NOWEAK(s,h) {#s, (pointer_to_handler*)(void*)(&h), NULL}
 #else
 #define DLD(s,h) {#s, (pointer_to_handler*)(void*)(&h)}
+#define DLD_NOWEAK(s,h) DLD(s,h)
 #endif /* __TBB_WEAK_SYMBOLS_PRESENT */
 //! Association between a handler name and location of pointer to it.
 struct dynamic_link_descriptor {
diff --git a/src/tbb/src/tbb/governor.cpp b/src/tbb/src/tbb/governor.cpp
index b492e8ac..49502451 100644
--- a/src/tbb/src/tbb/governor.cpp
+++ b/src/tbb/src/tbb/governor.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 <stdio.h>
@@ -52,7 +48,7 @@ static __cilk_tbb_retcode (*watch_stack_handler)(struct __cilk_tbb_unwatch_thunk
 
 //! Table describing how to link the handlers.
 static const dynamic_link_descriptor CilkLinkTable[] = {
-    { "__cilkrts_watch_stack", (pointer_to_handler*)(void*)(&watch_stack_handler) }
+    DLD_NOWEAK(__cilkrts_watch_stack, watch_stack_handler)
 };
 
 static atomic<do_once_state> cilkrts_load_state;
@@ -184,7 +180,9 @@ generic_scheduler* governor::init_scheduler( int num_threads, stack_size_type st
             s->attach_arena( market::create_arena( default_num_threads(), 1, 0 ), 0, /*is_master*/true );
             __TBB_ASSERT( s->my_arena_index == 0, "Master thread must occupy the first slot in its arena" );
             s->my_arena_slot->my_scheduler = s;
+#if __TBB_TASK_GROUP_CONTEXT
             s->my_arena->my_default_ctx = s->default_context(); // it also transfers implied ownership
+#endif
             // Mark the scheduler as fully initialized
             assume_scheduler( s );
         }
@@ -204,7 +202,7 @@ generic_scheduler* governor::init_scheduler( int num_threads, stack_size_type st
     return s;
 }
 
-bool governor::terminate_scheduler( generic_scheduler* s, const task_scheduler_init* tsi_ptr, bool blocking ) {
+bool governor::terminate_scheduler( generic_scheduler* s, bool blocking ) {
     bool ok = false;
     __TBB_ASSERT( is_set(s), "Attempt to terminate non-local scheduler instance" );
     if (0 == --(s->my_ref_count)) {
@@ -257,11 +255,8 @@ __cilk_tbb_retcode governor::stack_op_handler( __cilk_tbb_stack_op op, void* dat
 #else
     uintptr_t thread_id = uintptr_t(pthread_self());
 #endif
-
 #endif /* TBB_USE_ASSERT */
     switch( op ) {
-        default:
-            __TBB_ASSERT( 0, "invalid op" );
         case CILK_TBB_STACK_ADOPT: {
             __TBB_ASSERT( !current && s->my_cilk_state==generic_scheduler::cs_limbo ||
                           current==s && s->my_cilk_state==generic_scheduler::cs_running, "invalid adoption" );
@@ -289,12 +284,187 @@ __cilk_tbb_retcode governor::stack_op_handler( __cilk_tbb_stack_op op, void* dat
 #endif /* TBB_USE_ASSERT */
             s->my_cilk_unwatch_thunk.routine = NULL;
             auto_terminate( s );
+            break;
         }
+        default:
+            __TBB_ASSERT(0, "invalid op");
     }
     return 0;
 }
 #endif /* __TBB_SURVIVE_THREAD_SWITCH */
 
+#if __TBB_NUMA_SUPPORT
+
+#if __TBB_WEAK_SYMBOLS_PRESENT
+#pragma weak initialize_numa_topology
+#pragma weak allocate_binding_handler
+#pragma weak deallocate_binding_handler
+#pragma weak bind_to_node
+#pragma weak restore_affinity
+
+extern "C" {
+void initialize_numa_topology(
+    size_t groups_num, int& nodes_count, int*& indexes_list, int*& concurrency_list );
+
+binding_handler* allocate_binding_handler( int slot_num );
+void deallocate_binding_handler( binding_handler* handler_ptr );
+
+void bind_to_node( binding_handler* handler_ptr, int slot_num, int numa_id );
+void restore_affinity( binding_handler* handler_ptr, int slot_num );
+}
+#endif /* __TBB_WEAK_SYMBOLS_PRESENT */
+
+// Handlers for communication with TBBbind
+#if _WIN32 || _WIN64 || __linux__
+static void (*initialize_numa_topology_ptr)(
+    size_t groups_num, int& nodes_count, int*& indexes_list, int*& concurrency_list ) = NULL;
+#endif /* _WIN32 || _WIN64 || __linux__ */
+
+static binding_handler* (*allocate_binding_handler_ptr)( int slot_num ) = NULL;
+static void (*deallocate_binding_handler_ptr)( binding_handler* handler_ptr ) = NULL;
+
+static void (*bind_to_node_ptr)( binding_handler* handler_ptr, int slot_num, int numa_id ) = NULL;
+static void (*restore_affinity_ptr)( binding_handler* handler_ptr, int slot_num ) = NULL;
+
+#if _WIN32 || _WIN64 || __linux__
+// Table describing how to link the handlers.
+static const dynamic_link_descriptor TbbBindLinkTable[] = {
+    DLD(initialize_numa_topology, initialize_numa_topology_ptr),
+    DLD(allocate_binding_handler, allocate_binding_handler_ptr),
+    DLD(deallocate_binding_handler, deallocate_binding_handler_ptr),
+    DLD(bind_to_node, bind_to_node_ptr),
+    DLD(restore_affinity, restore_affinity_ptr)
+};
+
+static const unsigned LinkTableSize = 5;
+
+#if TBB_USE_DEBUG
+#define DEBUG_SUFFIX "_debug"
+#else
+#define DEBUG_SUFFIX
+#endif /* TBB_USE_DEBUG */
+
+#if _WIN32 || _WIN64
+#define TBBBIND_NAME "tbbbind" DEBUG_SUFFIX ".dll"
+#elif __linux__
+#define TBBBIND_NAME "libtbbbind" DEBUG_SUFFIX  __TBB_STRING(.so.TBB_COMPATIBLE_INTERFACE_VERSION)
+#endif /* __linux__ */
+#endif /* _WIN32 || _WIN64 || __linux__ */
+
+// Stubs that will be used if TBBbind library is unavailable.
+static binding_handler* dummy_allocate_binding_handler ( int ) { return NULL; }
+static void dummy_deallocate_binding_handler ( binding_handler* ) { }
+static void dummy_bind_to_node ( binding_handler*, int, int ) { }
+static void dummy_restore_affinity ( binding_handler*, int ) { }
+
+// Representation of NUMA topology information on the TBB side.
+// NUMA topology may be initialized by third-party component (e.g. hwloc)
+// or just filled by default stubs (1 NUMA node with 0 index and
+// default_num_threads value as default_concurrency).
+namespace numa_topology {
+namespace {
+int  numa_nodes_count = 0;
+int* numa_indexes = NULL;
+int* default_concurrency_list = NULL;
+static tbb::atomic<do_once_state> numa_topology_init_state;
+} // internal namespace
+
+// Tries to load TBBbind library API, if success, gets NUMA topology information from it,
+// in another case, fills NUMA topology by stubs.
+// TODO: Add TBBbind loading status if TBB_VERSION is set.
+void initialization_impl() {
+    governor::one_time_init();
+
+#if _WIN32 || _WIN64 || __linux__
+    bool load_tbbbind = true;
+#if _WIN32 && !_WIN64
+    // For 32-bit Windows applications, process affinity masks can only support up to 32 logical CPUs.
+    SYSTEM_INFO si;
+    GetNativeSystemInfo(&si);
+    load_tbbbind = si.dwNumberOfProcessors <= 32;
+#endif /* _WIN32 && !_WIN64 */
+
+    if (load_tbbbind && dynamic_link(TBBBIND_NAME, TbbBindLinkTable, LinkTableSize)) {
+        int number_of_groups = 1;
+#if _WIN32 || _WIN64
+        number_of_groups = NumberOfProcessorGroups();
+#endif /* _WIN32 || _WIN64 */
+        initialize_numa_topology_ptr(
+            number_of_groups, numa_nodes_count, numa_indexes, default_concurrency_list);
+
+        if (numa_nodes_count==1 && numa_indexes[0] >= 0) {
+            __TBB_ASSERT(default_concurrency_list[numa_indexes[0]] == (int)governor::default_num_threads(),
+                "default_concurrency() should be equal to governor::default_num_threads() on single"
+                "NUMA node systems.");
+        }
+        return;
+    }
+#endif /* _WIN32 || _WIN64 || __linux__ */
+
+    static int dummy_index = -1;
+    static int dummy_concurrency = governor::default_num_threads();
+
+    numa_nodes_count = 1;
+    numa_indexes = &dummy_index;
+    default_concurrency_list = &dummy_concurrency;
+
+    allocate_binding_handler_ptr = dummy_allocate_binding_handler;
+    deallocate_binding_handler_ptr = dummy_deallocate_binding_handler;
+
+    bind_to_node_ptr = dummy_bind_to_node;
+    restore_affinity_ptr = dummy_restore_affinity;
+}
+
+void initialize() {
+    atomic_do_once(initialization_impl, numa_topology_init_state);
+}
+
+unsigned nodes_count() {
+    initialize();
+    return numa_nodes_count;
+}
+
+void fill( int* indexes_array ) {
+    initialize();
+    for ( int i = 0; i < numa_nodes_count; i++ ) {
+        indexes_array[i] = numa_indexes[i];
+    }
+}
+
+int default_concurrency( int node_id ) {
+    if (node_id >= 0) {
+        initialize();
+        return default_concurrency_list[node_id];
+    }
+    return governor::default_num_threads();
+}
+
+} // namespace numa_topology
+
+binding_handler* construct_binding_handler(int slot_num) {
+    __TBB_ASSERT(allocate_binding_handler_ptr, "tbbbind loading was not perfromed");
+    return allocate_binding_handler_ptr(slot_num);
+}
+
+void destroy_binding_handler(binding_handler* handler_ptr) {
+    __TBB_ASSERT(deallocate_binding_handler_ptr, "tbbbind loading was not perfromed");
+    deallocate_binding_handler_ptr(handler_ptr);
+}
+
+void bind_thread_to_node(binding_handler* handler_ptr, int slot_num , int numa_id) {
+    __TBB_ASSERT(slot_num >= 0, "Negative thread index");
+    __TBB_ASSERT(bind_to_node_ptr, "tbbbind loading was not perfromed");
+    bind_to_node_ptr(handler_ptr, slot_num, numa_id);
+}
+
+void restore_affinity_mask(binding_handler* handler_ptr, int slot_num) {
+    __TBB_ASSERT(slot_num >= 0, "Negative thread index");
+    __TBB_ASSERT(restore_affinity_ptr, "tbbbind loading was not perfromed");
+    restore_affinity_ptr(handler_ptr, slot_num);
+}
+
+#endif /* __TBB_NUMA_SUPPORT */
+
 } // namespace internal
 
 //------------------------------------------------------------------------
@@ -352,7 +522,7 @@ bool task_scheduler_init::internal_terminate( bool blocking ) {
                                         : vt & ~task_group_context::exact_exception;
     }
 #endif /* __TBB_TASK_GROUP_CONTEXT && TBB_USE_EXCEPTIONS */
-    return governor::terminate_scheduler(s, this, blocking);
+    return governor::terminate_scheduler(s, blocking);
 }
 
 void task_scheduler_init::terminate() {
diff --git a/src/tbb/src/tbb/governor.h b/src/tbb/src/tbb/governor.h
index 92f98bb4..8cecdf2e 100644
--- a/src/tbb/src/tbb/governor.h
+++ b/src/tbb/src/tbb/governor.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef _TBB_governor_H
@@ -60,6 +56,9 @@ class governor {
     //! Caches the maximal level of parallelism supported by the hardware
     static unsigned DefaultNumberOfThreads;
 
+    //! Caches the size of OS regular memory page
+    static size_t DefaultPageSize;
+
     static rml::tbb_factory theRMLServerFactory;
 
     static bool UsePrivateRML;
@@ -87,6 +86,10 @@ class governor {
         return DefaultNumberOfThreads ? DefaultNumberOfThreads :
                                         DefaultNumberOfThreads = AvailableHwConcurrency();
     }
+    static size_t default_page_size () {
+        return DefaultPageSize ? DefaultPageSize :
+                                 DefaultPageSize = DefaultSystemPageSize();
+    }
     static void one_time_init();
     //! Processes scheduler initialization request (possibly nested) in a master thread
     /** If necessary creates new instance of arena and/or local scheduler.
@@ -97,7 +100,7 @@ class governor {
     static generic_scheduler* init_scheduler_weak();
 
     //! Processes scheduler termination request (possibly nested) in a master thread
-    static bool terminate_scheduler( generic_scheduler* s, const task_scheduler_init *tsi_ptr, bool blocking );
+    static bool terminate_scheduler( generic_scheduler* s, bool blocking );
 
     //! Register TBB scheduler instance in thread-local storage.
     static void sign_on( generic_scheduler* s );
diff --git a/src/tbb/src/tbb/ia32-masm/atomic_support.asm b/src/tbb/src/tbb/ia32-masm/atomic_support.asm
index 3cb82b97..3c196231 100644
--- a/src/tbb/src/tbb/ia32-masm/atomic_support.asm
+++ b/src/tbb/src/tbb/ia32-masm/atomic_support.asm
@@ -1,4 +1,4 @@
-; Copyright (c) 2005-2017 Intel Corporation
+; Copyright (c) 2005-2020 Intel Corporation
 ;
 ; Licensed under the Apache License, Version 2.0 (the "License");
 ; you may not use this file except in compliance with the License.
@@ -11,10 +11,6 @@
 ; 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.
-;
-;
-;
-;
 
 .686
 .model flat,c
diff --git a/src/tbb/src/tbb/ia32-masm/itsx.asm b/src/tbb/src/tbb/ia32-masm/itsx.asm
index 10e08357..d89da227 100644
--- a/src/tbb/src/tbb/ia32-masm/itsx.asm
+++ b/src/tbb/src/tbb/ia32-masm/itsx.asm
@@ -1,4 +1,4 @@
-; Copyright (c) 2005-2017 Intel Corporation
+; Copyright (c) 2005-2020 Intel Corporation
 ;
 ; Licensed under the Apache License, Version 2.0 (the "License");
 ; you may not use this file except in compliance with the License.
@@ -11,10 +11,6 @@
 ; 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.
-;
-;
-;
-;
 
 .686
 .model flat,c
diff --git a/src/tbb/src/tbb/ia32-masm/lock_byte.asm b/src/tbb/src/tbb/ia32-masm/lock_byte.asm
index daad5198..7baeec21 100644
--- a/src/tbb/src/tbb/ia32-masm/lock_byte.asm
+++ b/src/tbb/src/tbb/ia32-masm/lock_byte.asm
@@ -1,4 +1,4 @@
-; Copyright (c) 2005-2017 Intel Corporation
+; Copyright (c) 2005-2020 Intel Corporation
 ;
 ; Licensed under the Apache License, Version 2.0 (the "License");
 ; you may not use this file except in compliance with the License.
@@ -11,10 +11,6 @@
 ; 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.
-;
-;
-;
-;
 
 ; DO NOT EDIT - AUTOMATICALLY GENERATED FROM .s FILE
 .686
diff --git a/src/tbb/src/tbb/ia64-gas/atomic_support.s b/src/tbb/src/tbb/ia64-gas/atomic_support.s
index cf800dbc..4c49fedf 100644
--- a/src/tbb/src/tbb/ia64-gas/atomic_support.s
+++ b/src/tbb/src/tbb/ia64-gas/atomic_support.s
@@ -1,4 +1,4 @@
-// Copyright (c) 2005-2017 Intel Corporation
+// Copyright (c) 2005-2020 Intel Corporation
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -11,10 +11,6 @@
 // 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.
-//
-//
-//
-//
 
 // DO NOT EDIT - AUTOMATICALLY GENERATED FROM tools/generate_atomic/ipf_generate.sh
 # 1 "<stdin>"
diff --git a/src/tbb/src/tbb/ia64-gas/ia64_misc.s b/src/tbb/src/tbb/ia64-gas/ia64_misc.s
index b62ce393..73554a7e 100644
--- a/src/tbb/src/tbb/ia64-gas/ia64_misc.s
+++ b/src/tbb/src/tbb/ia64-gas/ia64_misc.s
@@ -1,4 +1,4 @@
-// Copyright (c) 2005-2017 Intel Corporation
+// Copyright (c) 2005-2020 Intel Corporation
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -11,10 +11,6 @@
 // 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.
-//
-//
-//
-//
 
 	// RSE backing store pointer retrieval
     .section .text
diff --git a/src/tbb/src/tbb/ia64-gas/lock_byte.s b/src/tbb/src/tbb/ia64-gas/lock_byte.s
index 551ac330..ee9c240b 100644
--- a/src/tbb/src/tbb/ia64-gas/lock_byte.s
+++ b/src/tbb/src/tbb/ia64-gas/lock_byte.s
@@ -1,4 +1,4 @@
-// Copyright (c) 2005-2017 Intel Corporation
+// Copyright (c) 2005-2020 Intel Corporation
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -11,10 +11,6 @@
 // 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.
-//
-//
-//
-//
 
 	// Support for class TinyLock
 	.section .text
diff --git a/src/tbb/src/tbb/ia64-gas/log2.s b/src/tbb/src/tbb/ia64-gas/log2.s
index d4ad9e2b..be3f2be6 100644
--- a/src/tbb/src/tbb/ia64-gas/log2.s
+++ b/src/tbb/src/tbb/ia64-gas/log2.s
@@ -1,4 +1,4 @@
-// Copyright (c) 2005-2017 Intel Corporation
+// Copyright (c) 2005-2020 Intel Corporation
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -11,10 +11,6 @@
 // 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.
-//
-//
-//
-//
 
 	.section .text
 	.align 16
diff --git a/src/tbb/src/tbb/ia64-gas/pause.s b/src/tbb/src/tbb/ia64-gas/pause.s
index a22b4203..e4dfeb47 100644
--- a/src/tbb/src/tbb/ia64-gas/pause.s
+++ b/src/tbb/src/tbb/ia64-gas/pause.s
@@ -1,4 +1,4 @@
-// Copyright (c) 2005-2017 Intel Corporation
+// Copyright (c) 2005-2020 Intel Corporation
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -11,10 +11,6 @@
 // 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.
-//
-//
-//
-//
 
 	.section .text
 	.align 16
diff --git a/src/tbb/src/tbb/ibm_aix51/atomic_support.c b/src/tbb/src/tbb/ibm_aix51/atomic_support.c
index 0aa08a1e..24850b8a 100644
--- a/src/tbb/src/tbb/ibm_aix51/atomic_support.c
+++ b/src/tbb/src/tbb/ibm_aix51/atomic_support.c
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 <stdint.h>
diff --git a/src/tbb/src/tbb/index.html b/src/tbb/src/tbb/index.html
index 9ba7f57e..e6fe3afb 100644
--- a/src/tbb/src/tbb/index.html
+++ b/src/tbb/src/tbb/index.html
@@ -21,7 +21,7 @@ <H2>Directories</H2>
 <HR>
 <A HREF="../index.html">Up to parent directory</A>
 <p></p>
-Copyright &copy; 2005-2017 Intel Corporation.  All Rights Reserved.
+Copyright &copy; 2005-2020 Intel Corporation.  All Rights Reserved.
 <P></P>
 Intel is a registered trademark or trademark of Intel Corporation
 or its subsidiaries in the United States and other countries.
diff --git a/src/tbb/src/tbb/intel64-masm/atomic_support.asm b/src/tbb/src/tbb/intel64-masm/atomic_support.asm
index d3c7f698..c34538e9 100644
--- a/src/tbb/src/tbb/intel64-masm/atomic_support.asm
+++ b/src/tbb/src/tbb/intel64-masm/atomic_support.asm
@@ -1,4 +1,4 @@
-; Copyright (c) 2005-2017 Intel Corporation
+; Copyright (c) 2005-2020 Intel Corporation
 ;
 ; Licensed under the Apache License, Version 2.0 (the "License");
 ; you may not use this file except in compliance with the License.
@@ -11,10 +11,6 @@
 ; 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.
-;
-;
-;
-;
 
 ; DO NOT EDIT - AUTOMATICALLY GENERATED FROM .s FILE
 .code 
diff --git a/src/tbb/src/tbb/intel64-masm/intel64_misc.asm b/src/tbb/src/tbb/intel64-masm/intel64_misc.asm
index 4fe75152..dc05c8f3 100644
--- a/src/tbb/src/tbb/intel64-masm/intel64_misc.asm
+++ b/src/tbb/src/tbb/intel64-masm/intel64_misc.asm
@@ -1,4 +1,4 @@
-; Copyright (c) 2005-2017 Intel Corporation
+; Copyright (c) 2005-2020 Intel Corporation
 ;
 ; Licensed under the Apache License, Version 2.0 (the "License");
 ; you may not use this file except in compliance with the License.
@@ -11,10 +11,6 @@
 ; 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.
-;
-;
-;
-;
 
 .code
 	ALIGN 8
diff --git a/src/tbb/src/tbb/intel64-masm/itsx.asm b/src/tbb/src/tbb/intel64-masm/itsx.asm
index 1a5958fb..3c75dcef 100644
--- a/src/tbb/src/tbb/intel64-masm/itsx.asm
+++ b/src/tbb/src/tbb/intel64-masm/itsx.asm
@@ -1,4 +1,4 @@
-; Copyright (c) 2005-2017 Intel Corporation
+; Copyright (c) 2005-2020 Intel Corporation
 ;
 ; Licensed under the Apache License, Version 2.0 (the "License");
 ; you may not use this file except in compliance with the License.
@@ -11,10 +11,6 @@
 ; 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.
-;
-;
-;
-;
 
 .code
         ALIGN 8
diff --git a/src/tbb/src/tbb/intrusive_list.h b/src/tbb/src/tbb/intrusive_list.h
index cb2190af..add58e72 100644
--- a/src/tbb/src/tbb/intrusive_list.h
+++ b/src/tbb/src/tbb/intrusive_list.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,16 +12,13 @@
     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.
-
-
-
-
 */
 
 #ifndef _TBB_intrusive_list_H
 #define _TBB_intrusive_list_H
 
 #include "tbb/tbb_stddef.h"
+#include "tbb/internal/_template_helpers.h"
 
 namespace tbb {
 namespace internal {
@@ -53,63 +50,75 @@ class intrusive_list_base {
 
     static T& item ( intrusive_list_node* node ) { return List::item(node); }
 
-    template<class Iterator>
-    class iterator_impl {
-        Iterator& self () { return *static_cast<Iterator*>(this); }
+    static const T& item( const intrusive_list_node* node ) { return List::item(node); }
 
-        //! Node the iterator points to at the moment
-        intrusive_list_node *my_pos;
+    template <typename DereferenceType>
+    class iterator_impl {
+        __TBB_STATIC_ASSERT((tbb::internal::is_same_type<DereferenceType, T>::value ||
+                            tbb::internal::is_same_type<DereferenceType, const T>::value),
+                            "Incorrect DereferenceType in iterator_impl");
+        typedef typename tbb::internal::conditional<tbb::internal::is_same_type<DereferenceType, T>::value,
+                                                    intrusive_list_node*,
+                                                    const intrusive_list_node*>::type pointer_type;
+    public:
+        iterator_impl() : my_pos(NULL) {}
 
-    protected:
-        iterator_impl (intrusive_list_node* pos )
-            :  my_pos(pos)
-        {}
+        iterator_impl( pointer_type pos ) : my_pos(pos) {}
 
-        T& item () const {
-            return intrusive_list_base::item(my_pos);
+        iterator_impl& operator=( const iterator_impl& other ) {
+            if (this != &other) {
+                my_pos = other.my_pos;
+            }
+            return *this;
         }
 
-    public:
-        iterator_impl () :  my_pos(NULL) {}
+        iterator_impl& operator=( const T& val ) {
+            my_pos = &node(val);
+            return *this;
+        }
 
-        Iterator& operator = ( const Iterator& it ) {
-            return my_pos = it.my_pos;
+        iterator_impl& operator++() {
+            my_pos = my_pos->my_next_node;
+            return *this;
         }
 
-        Iterator& operator = ( const T& val ) {
-            return my_pos = &node(val);
+        iterator_impl operator++( int ) {
+            iterator_impl it(*this);
+            ++*this;
+            return it;
         }
 
-        bool operator == ( const Iterator& it ) const {
-            return my_pos == it.my_pos;
+        iterator_impl& operator--() {
+            my_pos = my_pos->my_prev_node;
+            return *this;
         }
 
-        bool operator != ( const Iterator& it ) const {
-            return my_pos != it.my_pos;
+        iterator_impl operator--( int ) {
+            iterator_impl it(*this);
+            --*this;
+            return it;
         }
 
-        Iterator& operator++ () {
-            my_pos = my_pos->my_next_node;
-            return self();
+        bool operator==( const iterator_impl& rhs ) const {
+            return my_pos == rhs.my_pos;
         }
 
-        Iterator& operator-- () {
-            my_pos = my_pos->my_prev_node;
-            return self();
+        bool operator!=( const iterator_impl& rhs ) const {
+            return my_pos != rhs.my_pos;
         }
 
-        Iterator operator++ ( int ) {
-            Iterator result = self();
-            ++(*this);
-            return result;
+        DereferenceType& operator*() const {
+            return intrusive_list_base::item(my_pos);
         }
 
-        Iterator operator-- ( int ) {
-            Iterator result = self();
-            --(*this);
-            return result;
+        DereferenceType* operator->() const {
+            return &intrusive_list_base::item(my_pos);
         }
-    }; // intrusive_list_base::iterator_impl
+
+    private:
+        // Node the iterator points to at the moment
+        pointer_type my_pos;
+    }; // class iterator_impl
 
     void assert_ok () const {
         __TBB_ASSERT( (my_head.my_prev_node == &my_head && !my_size) ||
@@ -123,31 +132,8 @@ class intrusive_list_base {
     }
 
 public:
-    class iterator : public iterator_impl<iterator> {
-        template <class U, class V> friend class intrusive_list_base;
-    public:
-        iterator (intrusive_list_node* pos )
-            : iterator_impl<iterator>(pos )
-        {}
-        iterator () {}
-
-        T* operator-> () const { return &this->item(); }
-
-        T& operator* () const { return this->item(); }
-    }; // class iterator
-
-    class const_iterator : public iterator_impl<const_iterator> {
-        template <class U, class V> friend class intrusive_list_base;
-    public:
-        const_iterator (const intrusive_list_node* pos )
-            : iterator_impl<const_iterator>(const_cast<intrusive_list_node*>(pos) )
-        {}
-        const_iterator () {}
-
-        const T* operator-> () const { return &this->item(); }
-
-        const T& operator* () const { return this->item(); }
-    }; // class iterator
+    typedef iterator_impl<T> iterator;
+    typedef iterator_impl<const T> const_iterator;
 
     intrusive_list_base () : my_size(0) {
         my_head.my_prev_node = &my_head;
@@ -223,6 +209,10 @@ class memptr_intrusive_list : public intrusive_list_base<memptr_intrusive_list<T
         // __TBB_offsetof implementation breaks operations with normal member names.
         return *reinterpret_cast<T*>((char*)node - ((ptrdiff_t)&(reinterpret_cast<T*>(0x1000)->*NodePtr) - 0x1000));
     }
+
+    static const T& item( const intrusive_list_node* node ) {
+        return item(const_cast<intrusive_list_node*>(node));
+    }
 }; // intrusive_list<T, U, NodePtr>
 
 //! Double linked list of items of type T that is derived from intrusive_list_node class.
@@ -238,6 +228,7 @@ class intrusive_list : public intrusive_list_base<intrusive_list<T>, T>
     static intrusive_list_node& node ( T& val ) { return val; }
 
     static T& item ( intrusive_list_node* node ) { return *static_cast<T*>(node); }
+    static const T& item( const intrusive_list_node* node ) { return *static_cast<const T*>(node); }
 }; // intrusive_list<T>
 
 } // namespace internal
diff --git a/src/tbb/src/tbb/itt_notify.cpp b/src/tbb/src/tbb/itt_notify.cpp
index 670c84d9..ac505344 100644
--- a/src/tbb/src/tbb/itt_notify.cpp
+++ b/src/tbb/src/tbb/itt_notify.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 DO_ITT_NOTIFY
@@ -59,9 +55,7 @@ int __TBB_load_ittnotify() {
       (__itt_group_id)(__itt_group_sync     // prepare/cancel/acquired/releasing
                        | __itt_group_thread // name threads
                        | __itt_group_stitch // stack stitching
-#if __TBB_CPF_BUILD
                        | __itt_group_structure
-#endif
                            ));
 }
 
@@ -90,6 +84,9 @@ namespace tbb {
             *SyncObj_Mailbox = _T("TBB Scheduler"),
             *SyncObj_TaskReturnList = _T("TBB Scheduler"),
             *SyncObj_TaskStream = _T("TBB Scheduler"),
+#if __TBB_PREVIEW_CRITICAL_TASKS
+            *SyncObj_CriticalTaskStream = _T("TBB Scheduler"),
+#endif
             *SyncObj_ContextsList = _T("TBB Scheduler")
             ;
 #endif /* DO_ITT_NOTIFY */
diff --git a/src/tbb/src/tbb/itt_notify.h b/src/tbb/src/tbb/itt_notify.h
index 529437c8..699e1086 100644
--- a/src/tbb/src/tbb/itt_notify.h
+++ b/src/tbb/src/tbb/itt_notify.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef _TBB_ITT_NOTIFY
@@ -41,11 +37,8 @@ extern "C" void __itt_fini_ittlib(void);
 
 #if _WIN32||_WIN64
     #undef _T
-    #undef __itt_event_create
-    #define __itt_event_create __itt_event_createA
 #endif /* WIN */
 
-
 #endif /* DO_ITT_NOTIFY */
 
 #if !ITT_CALLER_NULL
@@ -85,6 +78,9 @@ namespace tbb {
             *SyncObj_Mailbox,
             *SyncObj_TaskReturnList,
             *SyncObj_TaskStream,
+#if __TBB_PREVIEW_CRITICAL_TASKS
+            *SyncObj_CriticalTaskStream,
+#endif
             *SyncObj_ContextsList
             ;
 
@@ -92,11 +88,10 @@ namespace tbb {
         void __TBB_EXPORTED_FUNC itt_set_sync_name_v3( void* obj, const tchar* name);
 
     } // namespace internal
-
 } // namespace tbb
 
 // const_cast<void*>() is necessary to cast off volatility
-#define ITT_NOTIFY(name,obj)            __itt_notify_##name(const_cast<void*>(static_cast<volatile void*>(obj)))
+#define ITT_NOTIFY(name,obj)            __itt_##name(const_cast<void*>(static_cast<volatile void*>(obj)))
 #define ITT_THREAD_SET_NAME(name)       __itt_thread_set_name(name)
 #define ITT_FINI_ITTLIB()               __itt_fini_ittlib()
 #define ITT_SYNC_CREATE(obj, type, name) __itt_sync_create((void*)(obj), type, name, 2)
@@ -108,6 +103,10 @@ namespace tbb {
 #define ITT_STACK(precond, name, obj)      ((void)0)
 #endif /* !__TBB_TASK_GROUP_CONTEXT */
 
+#define ITT_TASK_GROUP(obj,name,parent)     itt_make_task_group_v7(internal::ITT_DOMAIN_MAIN,(void*)(obj),ALGORITHM,(void*)(parent),(parent!=NULL) ? ALGORITHM : FLOW_NULL,name)
+#define ITT_TASK_BEGIN(obj,name,id)         itt_task_begin_v7(internal::ITT_DOMAIN_MAIN,(void*)(id),ALGORITHM,(void*)(obj),ALGORITHM,name)
+#define ITT_TASK_END                        itt_task_end_v7(internal::ITT_DOMAIN_MAIN)
+
 #else /* !DO_ITT_NOTIFY */
 
 #define ITT_NOTIFY(name,obj)            ((void)0)
@@ -118,6 +117,10 @@ namespace tbb {
 #define ITT_STACK_CREATE(obj)           ((void)0)
 #define ITT_STACK(precond, name, obj)   ((void)0)
 
+#define ITT_TASK_GROUP(type,name,parent)    ((void)0)
+#define ITT_TASK_BEGIN(type,name,id)        ((void)0)
+#define ITT_TASK_END                        ((void)0)
+
 #endif /* !DO_ITT_NOTIFY */
 
 namespace tbb {
diff --git a/src/tbb/src/tbb/lin32-tbb-export.def b/src/tbb/src/tbb/lin32-tbb-export.def
index d1f7c9c4..2df55ce5 100644
--- a/src/tbb/src/tbb/lin32-tbb-export.def
+++ b/src/tbb/src/tbb/lin32-tbb-export.def
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 {
diff --git a/src/tbb/src/tbb/lin32-tbb-export.lst b/src/tbb/src/tbb/lin32-tbb-export.lst
index 10f27266..3026a4d5 100644
--- a/src/tbb/src/tbb/lin32-tbb-export.lst
+++ b/src/tbb/src/tbb/lin32-tbb-export.lst
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 "tbb/tbb_config.h"
@@ -72,6 +68,11 @@ __TBB_SYMBOL( _ZNK3tbb10interface78internal15task_arena_base16internal_executeER
 __TBB_SYMBOL( _ZNK3tbb10interface78internal15task_arena_base13internal_waitEv )
 __TBB_SYMBOL( _ZN3tbb10interface78internal15task_arena_base21internal_current_slotEv )
 __TBB_SYMBOL( _ZN3tbb10interface78internal15task_arena_base24internal_max_concurrencyEPKNS0_10task_arenaE )
+#if __TBB_NUMA_SUPPORT
+__TBB_SYMBOL( _ZN3tbb8internal13numa_topology11nodes_countEv )
+__TBB_SYMBOL( _ZN3tbb8internal13numa_topology4fillEPi )
+__TBB_SYMBOL( _ZN3tbb8internal13numa_topology19default_concurrencyEi )
+#endif /*__TBB_NUMA_SUPPORT*/
 #if __TBB_TASK_ISOLATION
 __TBB_SYMBOL( _ZN3tbb10interface78internal20isolate_within_arenaERNS1_13delegate_baseEi )
 #endif /* __TBB_TASK_ISOLATION */
@@ -170,7 +171,6 @@ __TBB_SYMBOL( _ZN3tbb8internal33itt_store_pointer_with_release_v3EPvS1_ )
 __TBB_SYMBOL( _ZN3tbb8internal18call_itt_notify_v5EiPv )
 __TBB_SYMBOL( _ZN3tbb8internal20itt_set_sync_name_v3EPvPKc )
 __TBB_SYMBOL( _ZN3tbb8internal19itt_load_pointer_v3EPKv )
-#if __TBB_ITT_STRUCTURE_API
 __TBB_SYMBOL( _ZN3tbb8internal22itt_make_task_group_v7ENS0_15itt_domain_enumEPvyS2_yNS0_12string_indexE )
 __TBB_SYMBOL( _ZN3tbb8internal23itt_metadata_str_add_v7ENS0_15itt_domain_enumEPvyNS0_12string_indexEPKc )
 __TBB_SYMBOL( _ZN3tbb8internal19itt_relation_add_v7ENS0_15itt_domain_enumEPvyNS0_12itt_relationES2_y )
@@ -178,7 +178,7 @@ __TBB_SYMBOL( _ZN3tbb8internal17itt_task_begin_v7ENS0_15itt_domain_enumEPvyS2_yN
 __TBB_SYMBOL( _ZN3tbb8internal15itt_task_end_v7ENS0_15itt_domain_enumE )
 __TBB_SYMBOL( _ZN3tbb8internal19itt_region_begin_v9ENS0_15itt_domain_enumEPvyS2_yNS0_12string_indexE )
 __TBB_SYMBOL( _ZN3tbb8internal17itt_region_end_v9ENS0_15itt_domain_enumEPvy )
-#endif
+__TBB_SYMBOL( _ZN3tbb8internal24itt_metadata_ptr_add_v11ENS0_15itt_domain_enumEPvyNS0_12string_indexES2_ )
 
 /* pipeline.cpp */
 __TBB_SYMBOL( _ZTIN3tbb6filterE )
@@ -401,4 +401,10 @@ __TBB_SYMBOL( _ZN3tbb10interface914global_control12active_valueEi )
 __TBB_SYMBOL( _ZN3tbb10interface914global_control15internal_createEv )
 __TBB_SYMBOL( _ZN3tbb10interface914global_control16internal_destroyEv )
 
+#if __TBB_PREVIEW_RESUMABLE_TASKS
+__TBB_SYMBOL( _ZN3tbb8internal16internal_suspendEPvS1_ )
+__TBB_SYMBOL( _ZN3tbb8internal15internal_resumeEPv )
+__TBB_SYMBOL( _ZN3tbb8internal30internal_current_suspend_pointEv )
+#endif
+
 #undef __TBB_SYMBOL
diff --git a/src/tbb/src/tbb/lin32-tbbbind-export.def b/src/tbb/src/tbb/lin32-tbbbind-export.def
new file mode 100644
index 00000000..efec2cb9
--- /dev/null
+++ b/src/tbb/src/tbb/lin32-tbbbind-export.def
@@ -0,0 +1,24 @@
+/*
+    Copyright (c) 2005-2020 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.
+*/
+
+{
+global:
+initialize_numa_topology;
+bind_to_node;
+restore_affinity;
+allocate_binding_handler;
+deallocate_binding_handler;
+};
diff --git a/src/tbb/src/tbb/lin64-tbb-export.def b/src/tbb/src/tbb/lin64-tbb-export.def
index 1f3cac3a..d2e54ea1 100644
--- a/src/tbb/src/tbb/lin64-tbb-export.def
+++ b/src/tbb/src/tbb/lin64-tbb-export.def
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 {
diff --git a/src/tbb/src/tbb/lin64-tbb-export.lst b/src/tbb/src/tbb/lin64-tbb-export.lst
index f05e68b7..758ef224 100644
--- a/src/tbb/src/tbb/lin64-tbb-export.lst
+++ b/src/tbb/src/tbb/lin64-tbb-export.lst
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 "tbb/tbb_config.h"
@@ -72,6 +68,11 @@ __TBB_SYMBOL( _ZNK3tbb10interface78internal15task_arena_base16internal_executeER
 __TBB_SYMBOL( _ZNK3tbb10interface78internal15task_arena_base13internal_waitEv )
 __TBB_SYMBOL( _ZN3tbb10interface78internal15task_arena_base21internal_current_slotEv )
 __TBB_SYMBOL( _ZN3tbb10interface78internal15task_arena_base24internal_max_concurrencyEPKNS0_10task_arenaE )
+#if __TBB_NUMA_SUPPORT
+__TBB_SYMBOL( _ZN3tbb8internal13numa_topology11nodes_countEv )
+__TBB_SYMBOL( _ZN3tbb8internal13numa_topology4fillEPi )
+__TBB_SYMBOL( _ZN3tbb8internal13numa_topology19default_concurrencyEi )
+#endif /*__TBB_NUMA_SUPPORT*/
 #if __TBB_TASK_ISOLATION
 __TBB_SYMBOL( _ZN3tbb10interface78internal20isolate_within_arenaERNS1_13delegate_baseEl )
 #endif
@@ -165,7 +166,6 @@ __TBB_SYMBOL( _ZN3tbb8internal33itt_store_pointer_with_release_v3EPvS1_ )
 __TBB_SYMBOL( _ZN3tbb8internal18call_itt_notify_v5EiPv )
 __TBB_SYMBOL( _ZN3tbb8internal20itt_set_sync_name_v3EPvPKc )
 __TBB_SYMBOL( _ZN3tbb8internal19itt_load_pointer_v3EPKv )
-#if __TBB_ITT_STRUCTURE_API
 __TBB_SYMBOL( _ZN3tbb8internal23itt_metadata_str_add_v7ENS0_15itt_domain_enumEPvyNS0_12string_indexEPKc )
 __TBB_SYMBOL( _ZN3tbb8internal22itt_make_task_group_v7ENS0_15itt_domain_enumEPvyS2_yNS0_12string_indexE )
 __TBB_SYMBOL( _ZN3tbb8internal17itt_task_begin_v7ENS0_15itt_domain_enumEPvyS2_yNS0_12string_indexE )
@@ -173,7 +173,7 @@ __TBB_SYMBOL( _ZN3tbb8internal19itt_relation_add_v7ENS0_15itt_domain_enumEPvyNS0
 __TBB_SYMBOL( _ZN3tbb8internal15itt_task_end_v7ENS0_15itt_domain_enumE )
 __TBB_SYMBOL( _ZN3tbb8internal19itt_region_begin_v9ENS0_15itt_domain_enumEPvyS2_yNS0_12string_indexE )
 __TBB_SYMBOL( _ZN3tbb8internal17itt_region_end_v9ENS0_15itt_domain_enumEPvy )
-#endif
+__TBB_SYMBOL( _ZN3tbb8internal24itt_metadata_ptr_add_v11ENS0_15itt_domain_enumEPvyNS0_12string_indexES2_ )
 
 /* pipeline.cpp */
 __TBB_SYMBOL( _ZTIN3tbb6filterE )
@@ -382,4 +382,10 @@ __TBB_SYMBOL( _ZN3tbb8internal15thread_sleep_v3ERKNS_10tick_count10interval_tE )
 __TBB_SYMBOL( _ZN3tbb10interface914global_control12active_valueEi )
 __TBB_SYMBOL( _ZN3tbb10interface914global_control15internal_createEv )
 __TBB_SYMBOL( _ZN3tbb10interface914global_control16internal_destroyEv )
+
+#if __TBB_PREVIEW_RESUMABLE_TASKS
+__TBB_SYMBOL( _ZN3tbb8internal16internal_suspendEPvS1_ )
+__TBB_SYMBOL( _ZN3tbb8internal15internal_resumeEPv )
+__TBB_SYMBOL( _ZN3tbb8internal30internal_current_suspend_pointEv )
+#endif
 #undef __TBB_SYMBOL
diff --git a/src/tbb/src/tbb/lin64-tbbbind-export.def b/src/tbb/src/tbb/lin64-tbbbind-export.def
new file mode 100644
index 00000000..efec2cb9
--- /dev/null
+++ b/src/tbb/src/tbb/lin64-tbbbind-export.def
@@ -0,0 +1,24 @@
+/*
+    Copyright (c) 2005-2020 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.
+*/
+
+{
+global:
+initialize_numa_topology;
+bind_to_node;
+restore_affinity;
+allocate_binding_handler;
+deallocate_binding_handler;
+};
diff --git a/src/tbb/src/tbb/lin64ipf-tbb-export.def b/src/tbb/src/tbb/lin64ipf-tbb-export.def
index c2111c1e..2b37d75b 100644
--- a/src/tbb/src/tbb/lin64ipf-tbb-export.def
+++ b/src/tbb/src/tbb/lin64ipf-tbb-export.def
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 {
diff --git a/src/tbb/src/tbb/lin64ipf-tbb-export.lst b/src/tbb/src/tbb/lin64ipf-tbb-export.lst
index 49f8cee7..678553bd 100644
--- a/src/tbb/src/tbb/lin64ipf-tbb-export.lst
+++ b/src/tbb/src/tbb/lin64ipf-tbb-export.lst
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 "tbb/tbb_config.h"
@@ -166,6 +162,14 @@ __TBB_SYMBOL( _ZN3tbb8internal33itt_store_pointer_with_release_v3EPvS1_ )
 __TBB_SYMBOL( _ZN3tbb8internal18call_itt_notify_v5EiPv )
 __TBB_SYMBOL( _ZN3tbb8internal20itt_set_sync_name_v3EPvPKc )
 __TBB_SYMBOL( _ZN3tbb8internal19itt_load_pointer_v3EPKv )
+__TBB_SYMBOL( _ZN3tbb8internal23itt_metadata_str_add_v7ENS0_15itt_domain_enumEPvyNS0_12string_indexEPKc )
+__TBB_SYMBOL( _ZN3tbb8internal22itt_make_task_group_v7ENS0_15itt_domain_enumEPvyS2_yNS0_12string_indexE )
+__TBB_SYMBOL( _ZN3tbb8internal17itt_task_begin_v7ENS0_15itt_domain_enumEPvyS2_yNS0_12string_indexE )
+__TBB_SYMBOL( _ZN3tbb8internal19itt_relation_add_v7ENS0_15itt_domain_enumEPvyNS0_12itt_relationES2_y )
+__TBB_SYMBOL( _ZN3tbb8internal15itt_task_end_v7ENS0_15itt_domain_enumE )
+__TBB_SYMBOL( _ZN3tbb8internal19itt_region_begin_v9ENS0_15itt_domain_enumEPvyS2_yNS0_12string_indexE )
+__TBB_SYMBOL( _ZN3tbb8internal17itt_region_end_v9ENS0_15itt_domain_enumEPvy )
+__TBB_SYMBOL( _ZN3tbb8internal24itt_metadata_ptr_add_v11ENS0_15itt_domain_enumEPvyNS0_12string_indexES2_ )
 
 /* pipeline.cpp */
 __TBB_SYMBOL( _ZTIN3tbb6filterE )
@@ -414,4 +418,10 @@ __TBB_SYMBOL( _ZN3tbb10interface914global_control12active_valueEi )
 __TBB_SYMBOL( _ZN3tbb10interface914global_control15internal_createEv )
 __TBB_SYMBOL( _ZN3tbb10interface914global_control16internal_destroyEv )
 
+#if __TBB_PREVIEW_RESUMABLE_TASKS
+__TBB_SYMBOL( _ZN3tbb8internal16internal_suspendEPvS1_ )
+__TBB_SYMBOL( _ZN3tbb8internal15internal_resumeEPv )
+__TBB_SYMBOL( _ZN3tbb8internal30internal_current_suspend_pointEv )
+#endif
+
 #undef __TBB_SYMBOL
diff --git a/src/tbb/src/tbb/mac32-tbb-export.def b/src/tbb/src/tbb/mac32-tbb-export.def
index 5ed01b1a..f4dbcca4 100644
--- a/src/tbb/src/tbb/mac32-tbb-export.def
+++ b/src/tbb/src/tbb/mac32-tbb-export.def
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #define __TBB_SYMBOL( sym ) _##sym
diff --git a/src/tbb/src/tbb/mac32-tbb-export.lst b/src/tbb/src/tbb/mac32-tbb-export.lst
index 8ce79f2d..0e2e32cc 100644
--- a/src/tbb/src/tbb/mac32-tbb-export.lst
+++ b/src/tbb/src/tbb/mac32-tbb-export.lst
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 "tbb/tbb_config.h"
@@ -24,7 +20,7 @@
     Sometimes macOS* requires leading underscore (e. g. in export list file), but sometimes not
     (e. g. when searching symbol in a dynamic library via dlsym()). Symbols in this file SHOULD
     be listed WITHOUT one leading underscore. __TBB_SYMBOL macro should add underscore when
-    necessary, depending on the indended usage.
+    necessary, depending on the intended usage.
 */
 
 // cache_aligned_allocator.cpp
@@ -80,6 +76,11 @@ __TBB_SYMBOL( _ZNK3tbb10interface78internal15task_arena_base16internal_executeER
 __TBB_SYMBOL( _ZNK3tbb10interface78internal15task_arena_base13internal_waitEv )
 __TBB_SYMBOL( _ZN3tbb10interface78internal15task_arena_base21internal_current_slotEv )
 __TBB_SYMBOL( _ZN3tbb10interface78internal15task_arena_base24internal_max_concurrencyEPKNS0_10task_arenaE )
+#if __TBB_NUMA_SUPPORT
+__TBB_SYMBOL( _ZN3tbb8internal13numa_topology11nodes_countEv )
+__TBB_SYMBOL( _ZN3tbb8internal13numa_topology4fillEPi )
+__TBB_SYMBOL( _ZN3tbb8internal13numa_topology19default_concurrencyEi )
+#endif /*__TBB_NUMA_SUPPORT*/
 #if __TBB_TASK_ISOLATION
 __TBB_SYMBOL( _ZN3tbb10interface78internal20isolate_within_arenaERNS1_13delegate_baseEl )
 #endif /* __TBB_TASK_ISOLATION */
@@ -191,6 +192,14 @@ __TBB_SYMBOL( _ZN3tbb8internal33itt_store_pointer_with_release_v3EPvS1_ )
 __TBB_SYMBOL( _ZN3tbb8internal18call_itt_notify_v5EiPv )
 __TBB_SYMBOL( _ZN3tbb8internal19itt_load_pointer_v3EPKv )
 __TBB_SYMBOL( _ZN3tbb8internal20itt_set_sync_name_v3EPvPKc )
+__TBB_SYMBOL( _ZN3tbb8internal22itt_make_task_group_v7ENS0_15itt_domain_enumEPvyS2_yNS0_12string_indexE )
+__TBB_SYMBOL( _ZN3tbb8internal23itt_metadata_str_add_v7ENS0_15itt_domain_enumEPvyNS0_12string_indexEPKc )
+__TBB_SYMBOL( _ZN3tbb8internal19itt_relation_add_v7ENS0_15itt_domain_enumEPvyNS0_12itt_relationES2_y )
+__TBB_SYMBOL( _ZN3tbb8internal17itt_task_begin_v7ENS0_15itt_domain_enumEPvyS2_yNS0_12string_indexE )
+__TBB_SYMBOL( _ZN3tbb8internal15itt_task_end_v7ENS0_15itt_domain_enumE )
+__TBB_SYMBOL( _ZN3tbb8internal19itt_region_begin_v9ENS0_15itt_domain_enumEPvyS2_yNS0_12string_indexE )
+__TBB_SYMBOL( _ZN3tbb8internal17itt_region_end_v9ENS0_15itt_domain_enumEPvy )
+__TBB_SYMBOL( _ZN3tbb8internal24itt_metadata_ptr_add_v11ENS0_15itt_domain_enumEPvyNS0_12string_indexES2_ )
 
 // pipeline.cpp
 __TBB_SYMBOL( _ZTIN3tbb6filterE )
@@ -400,4 +409,10 @@ __TBB_SYMBOL( _ZN3tbb10interface914global_control12active_valueEi )
 __TBB_SYMBOL( _ZN3tbb10interface914global_control15internal_createEv )
 __TBB_SYMBOL( _ZN3tbb10interface914global_control16internal_destroyEv )
 
+#if __TBB_PREVIEW_RESUMABLE_TASKS
+__TBB_SYMBOL( _ZN3tbb8internal16internal_suspendEPvS1_ )
+__TBB_SYMBOL( _ZN3tbb8internal15internal_resumeEPv )
+__TBB_SYMBOL( _ZN3tbb8internal30internal_current_suspend_pointEv )
+#endif
+
 #undef __TBB_SYMBOL
diff --git a/src/tbb/src/tbb/mac64-tbb-export.def b/src/tbb/src/tbb/mac64-tbb-export.def
index e2c03705..21a77ad7 100644
--- a/src/tbb/src/tbb/mac64-tbb-export.def
+++ b/src/tbb/src/tbb/mac64-tbb-export.def
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #define __TBB_SYMBOL( sym ) _##sym
diff --git a/src/tbb/src/tbb/mac64-tbb-export.lst b/src/tbb/src/tbb/mac64-tbb-export.lst
index 67d3676d..3b45e88f 100644
--- a/src/tbb/src/tbb/mac64-tbb-export.lst
+++ b/src/tbb/src/tbb/mac64-tbb-export.lst
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 "tbb/tbb_config.h"
@@ -24,7 +20,7 @@
     Sometimes macOS* requires leading underscore (e. g. in export list file), but sometimes not
     (e. g. when searching symbol in a dynamic library via dlsym()). Symbols in this file SHOULD
     be listed WITHOUT one leading underscore. __TBB_SYMBOL macro should add underscore when
-    necessary, depending on the indended usage.
+    necessary, depending on the intended usage.
 */
 
 // cache_aligned_allocator.cpp
@@ -80,6 +76,11 @@ __TBB_SYMBOL( _ZNK3tbb10interface78internal15task_arena_base16internal_executeER
 __TBB_SYMBOL( _ZNK3tbb10interface78internal15task_arena_base13internal_waitEv )
 __TBB_SYMBOL( _ZN3tbb10interface78internal15task_arena_base21internal_current_slotEv )
 __TBB_SYMBOL( _ZN3tbb10interface78internal15task_arena_base24internal_max_concurrencyEPKNS0_10task_arenaE )
+#if __TBB_NUMA_SUPPORT
+__TBB_SYMBOL( _ZN3tbb8internal13numa_topology11nodes_countEv )
+__TBB_SYMBOL( _ZN3tbb8internal13numa_topology4fillEPi )
+__TBB_SYMBOL( _ZN3tbb8internal13numa_topology19default_concurrencyEi )
+#endif /*__TBB_NUMA_SUPPORT*/
 #if __TBB_TASK_ISOLATION
 __TBB_SYMBOL( _ZN3tbb10interface78internal20isolate_within_arenaERNS1_13delegate_baseEl )
 #endif /* __TBB_TASK_ISOLATION */
@@ -188,6 +189,14 @@ __TBB_SYMBOL( _ZN3tbb8internal33itt_store_pointer_with_release_v3EPvS1_ )
 __TBB_SYMBOL( _ZN3tbb8internal18call_itt_notify_v5EiPv )
 __TBB_SYMBOL( _ZN3tbb8internal19itt_load_pointer_v3EPKv )
 __TBB_SYMBOL( _ZN3tbb8internal20itt_set_sync_name_v3EPvPKc )
+__TBB_SYMBOL( _ZN3tbb8internal23itt_metadata_str_add_v7ENS0_15itt_domain_enumEPvyNS0_12string_indexEPKc )
+__TBB_SYMBOL( _ZN3tbb8internal22itt_make_task_group_v7ENS0_15itt_domain_enumEPvyS2_yNS0_12string_indexE )
+__TBB_SYMBOL( _ZN3tbb8internal17itt_task_begin_v7ENS0_15itt_domain_enumEPvyS2_yNS0_12string_indexE )
+__TBB_SYMBOL( _ZN3tbb8internal19itt_relation_add_v7ENS0_15itt_domain_enumEPvyNS0_12itt_relationES2_y )
+__TBB_SYMBOL( _ZN3tbb8internal15itt_task_end_v7ENS0_15itt_domain_enumE )
+__TBB_SYMBOL( _ZN3tbb8internal19itt_region_begin_v9ENS0_15itt_domain_enumEPvyS2_yNS0_12string_indexE )
+__TBB_SYMBOL( _ZN3tbb8internal17itt_region_end_v9ENS0_15itt_domain_enumEPvy )
+__TBB_SYMBOL( _ZN3tbb8internal24itt_metadata_ptr_add_v11ENS0_15itt_domain_enumEPvyNS0_12string_indexES2_ )
 
 // pipeline.cpp
 __TBB_SYMBOL( _ZTIN3tbb6filterE )
@@ -397,4 +406,10 @@ __TBB_SYMBOL( _ZN3tbb10interface914global_control12active_valueEi )
 __TBB_SYMBOL( _ZN3tbb10interface914global_control15internal_createEv )
 __TBB_SYMBOL( _ZN3tbb10interface914global_control16internal_destroyEv )
 
+#if __TBB_PREVIEW_RESUMABLE_TASKS
+__TBB_SYMBOL( _ZN3tbb8internal16internal_suspendEPvS1_ )
+__TBB_SYMBOL( _ZN3tbb8internal15internal_resumeEPv )
+__TBB_SYMBOL( _ZN3tbb8internal30internal_current_suspend_pointEv )
+#endif
+
 #undef __TBB_SYMBOL
diff --git a/src/tbb/src/tbb/mailbox.h b/src/tbb/src/tbb/mailbox.h
index f651589e..795f01b8 100644
--- a/src/tbb/src/tbb/mailbox.h
+++ b/src/tbb/src/tbb/mailbox.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef _TBB_mailbox_H
@@ -91,6 +87,9 @@ class unpadded_mail_outbox {
     //! Pointer to pointer that will point to next item in the queue.  Never NULL.
     proxy_ptr* __TBB_atomic my_last;
 
+    //! Approximate number of tasks in mailbox to prevent an unlimited grow when the owner is not available.
+    tbb::atomic<int> my_task_count;
+
     //! Owner of mailbox is not executing a task, and has drained its own task pool.
     bool my_is_idle;
 };
@@ -98,6 +97,7 @@ class unpadded_mail_outbox {
 //! Class representing where mail is put.
 /** Padded to occupy a cache line. */
 class mail_outbox : padded<unpadded_mail_outbox> {
+    static const int mailbox_task_limit = 32;
 
     task_proxy* internal_pop( __TBB_ISOLATION_EXPR(isolation_tag isolation) ) {
         task_proxy* curr = __TBB_load_relaxed( my_first );
@@ -133,6 +133,8 @@ class mail_outbox : padded<unpadded_mail_outbox> {
                 *prev_ptr = second;
             }
         }
+        --my_task_count;
+        __TBB_ASSERT( my_task_count >= 0, NULL );
         __TBB_ASSERT( curr, NULL );
         return curr;
     }
@@ -140,14 +142,19 @@ class mail_outbox : padded<unpadded_mail_outbox> {
     friend class mail_inbox;
 
     //! Push task_proxy onto the mailbox queue of another thread.
-    /** Implementation is wait-free. */
-    void push( task_proxy* t ) {
+    /** Implementation is wait-free.
+        Returns false if there are too many tasks. */
+    bool push( task_proxy* t ) {
+        if (my_task_count > mailbox_task_limit)
+            return false;
+        ++my_task_count;
         __TBB_ASSERT(t, NULL);
         t->next_in_mailbox = NULL;
         proxy_ptr * const link = (proxy_ptr *)__TBB_FetchAndStoreW(&my_last,(intptr_t)&t->next_in_mailbox);
         // No release fence required for the next store, because there are no memory operations
         // between the previous fully fenced atomic operation and the store.
         __TBB_store_relaxed(*link, t);
+        return true;
     }
 
     //! Return true if mailbox is empty
diff --git a/src/tbb/src/tbb/market.cpp b/src/tbb/src/tbb/market.cpp
index 3b6efc63..418bfded 100644
--- a/src/tbb/src/tbb/market.cpp
+++ b/src/tbb/src/tbb/market.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 "tbb/tbb_stddef.h"
@@ -190,7 +186,7 @@ bool market::release ( bool is_public, bool blocking_terminate ) {
                 // Theoretically, new private references to the market can be added during waiting making it potentially
                 // endless.
                 // TODO: revise why the weak scheduler needs market's pointer and try to remove this wait.
-                // Note that the market should know about its schedulers for cancelation/exception/priority propagation,
+                // Note that the market should know about its schedulers for cancellation/exception/priority propagation,
                 // see e.g. task_group_context::cancel_group_execution()
                 while ( __TBB_load_with_acquire( my_public_ref_count ) == 1 && __TBB_load_with_acquire( my_ref_count ) > 1 )
                     __TBB_Yield();
@@ -218,9 +214,25 @@ bool market::release ( bool is_public, bool blocking_terminate ) {
     return false;
 }
 
+int market::update_workers_request() {
+    int old_request = my_num_workers_requested;
+    my_num_workers_requested = min(my_total_demand, (int)my_num_workers_soft_limit);
+#if __TBB_ENQUEUE_ENFORCED_CONCURRENCY
+    if (my_mandatory_num_requested > 0) {
+        __TBB_ASSERT(my_num_workers_soft_limit == 0, NULL);
+        my_num_workers_requested = 1;
+    }
+#endif
+#if __TBB_TASK_PRIORITY
+    my_priority_levels[my_global_top_priority].workers_available = my_num_workers_requested;
+    update_allotment(my_global_top_priority);
+#else
+    update_allotment(my_num_workers_requested);
+#endif
+    return my_num_workers_requested - old_request;
+}
+
 void market::set_active_num_workers ( unsigned soft_limit ) {
-    int old_requested=0, requested=0;
-    bool need_mandatory = false;
     market *m;
 
     {
@@ -228,65 +240,61 @@ void market::set_active_num_workers ( unsigned soft_limit ) {
         if ( !theMarket )
             return; // actual value will be used at market creation
         m = theMarket;
+        if (m->my_num_workers_soft_limit == soft_limit)
+            return;
         ++m->my_ref_count;
     }
     // have my_ref_count for market, use it safely
+
+    int delta = 0;
     {
         arenas_list_mutex_type::scoped_lock lock( m->my_arenas_list_mutex );
         __TBB_ASSERT(soft_limit <= m->my_num_workers_hard_limit, NULL);
-        m->my_num_workers_soft_limit = soft_limit;
-        // report only once after new soft limit value is set
-        m->my_workers_soft_limit_to_report = soft_limit;
 
 #if __TBB_ENQUEUE_ENFORCED_CONCURRENCY
-        // updates soft_limit to zero must be postponed
-        // while mandatory parallelism is enabled
-        if( !(m->my_mandatory_num_requested && !soft_limit) )
-#endif
-        {
-            const int demand =
-#if __TBB_ENQUEUE_ENFORCED_CONCURRENCY
-                m->my_mandatory_num_requested? 0 :
-#endif
-                m->my_total_demand;
-            requested = min(demand, (int)soft_limit);
-            old_requested = m->my_num_workers_requested;
-            m->my_num_workers_requested = requested;
 #if __TBB_TASK_PRIORITY
-            m->my_priority_levels[m->my_global_top_priority].workers_available = soft_limit;
-            m->update_allotment( m->my_global_top_priority );
+#define FOR_EACH_PRIORITY_LEVEL_BEGIN {                                                         \
+        for (int p = m->my_global_top_priority; p >= m->my_global_bottom_priority; --p) {       \
+            priority_level_info& pl = m->my_priority_levels[p];                                 \
+            arena_list_type& arenas = pl.arenas;
 #else
-            m->update_allotment();
+#define FOR_EACH_PRIORITY_LEVEL_BEGIN { {                                                       \
+            const int p = 0;                                                                    \
+            tbb::internal::suppress_unused_warning(p);                                          \
+            arena_list_type& arenas = m->my_arenas;
 #endif
+#define FOR_EACH_PRIORITY_LEVEL_END } }
+
+        if (m->my_num_workers_soft_limit == 0 && m->my_mandatory_num_requested > 0) {
+            FOR_EACH_PRIORITY_LEVEL_BEGIN
+                for (arena_list_type::iterator it = arenas.begin(); it != arenas.end(); ++it)
+                    if (it->my_global_concurrency_mode)
+                        m->disable_mandatory_concurrency_impl(&*it);
+            FOR_EACH_PRIORITY_LEVEL_END
         }
+        __TBB_ASSERT(m->my_mandatory_num_requested == 0, NULL);
+#endif
+
+        as_atomic(m->my_num_workers_soft_limit) = soft_limit;
+        // report only once after new soft limit value is set
+        m->my_workers_soft_limit_to_report = soft_limit;
+
 #if __TBB_ENQUEUE_ENFORCED_CONCURRENCY
-        if( !m->my_mandatory_num_requested && !soft_limit ) {
-            // enable mandatory concurrency, if enqueued tasks are found
-            // and zero soft_limit requested
-#if __TBB_TASK_PRIORITY
-            for( int p = m->my_global_top_priority; p >= m->my_global_bottom_priority; --p ) {
-                priority_level_info &pl = m->my_priority_levels[p];
-                arena_list_type &arenas = pl.arenas;
-#else
-                const int p = 0;
-                arena_list_type &arenas = m->my_arenas;
-#endif /* __TBB_TASK_PRIORITY */
-                for( arena_list_type::iterator it = arenas.begin(); it != arenas.end(); ++it ) {
-                    if( !it->my_task_stream.empty(p) ) {
-                        // switch local_mandatory to global_mandatory unconditionally
-                        if( m->mandatory_concurrency_enable_impl( &*it ) )
-                            need_mandatory = true;
-                    }
+        if (m->my_num_workers_soft_limit == 0) {
+            FOR_EACH_PRIORITY_LEVEL_BEGIN
+                for (arena_list_type::iterator it = arenas.begin(); it != arenas.end(); ++it) {
+                    if (!it->my_task_stream.empty(p))
+                        m->enable_mandatory_concurrency_impl(&*it);
                 }
-#if __TBB_TASK_PRIORITY
-            }
-#endif /* __TBB_TASK_PRIORITY */
+            FOR_EACH_PRIORITY_LEVEL_END
         }
-#endif /* __TBB_ENQUEUE_ENFORCED_CONCURRENCY */
+#undef FOR_EACH_PRIORITY_LEVEL_BEGIN
+#undef FOR_EACH_PRIORITY_LEVEL_END
+#endif
+
+        delta = m->update_workers_request();
     }
     // adjust_job_count_estimate must be called outside of any locks
-    int delta = requested - old_requested;
-    if( need_mandatory ) ++delta;
     if( delta!=0 )
         m->my_server->adjust_job_count_estimate( delta );
     // release internal market reference to match ++m->my_ref_count above
@@ -314,6 +322,9 @@ arena* market::create_arena ( int num_slots, int num_reserved_slots, size_t stac
 void market::detach_arena ( arena& a ) {
     __TBB_ASSERT( theMarket == this, "Global market instance was destroyed prematurely?" );
     __TBB_ASSERT( !a.my_slots[0].my_scheduler, NULL );
+    if (a.my_global_concurrency_mode)
+        disable_mandatory_concurrency_impl(&a);
+
     remove_arena_from_list(a);
     if ( a.my_aba_epoch == my_arenas_aba_epoch )
         ++my_arenas_aba_epoch;
@@ -329,7 +340,7 @@ void market::try_destroy_arena ( arena* a, uintptr_t aba_epoch ) {
     assert_market_valid();
 #if __TBB_TASK_PRIORITY
     // scan all priority levels, not only in [my_global_bottom_priority;my_global_top_priority]
-    // range, because arena to be destoyed can have no outstanding request for workers
+    // range, because arena to be destroyed can have no outstanding request for workers
     for ( int p = num_priority_levels-1; p >= 0; --p ) {
         priority_level_info &pl = my_priority_levels[p];
         arena_list_type &my_arenas = pl.arenas;
@@ -360,61 +371,65 @@ void market::try_destroy_arena ( arena* a, uintptr_t aba_epoch ) {
 }
 
 /** This method must be invoked under my_arenas_list_mutex. **/
-arena* market::arena_in_need ( arena_list_type &arenas, arena *&next ) {
+arena* market::arena_in_need ( arena_list_type &arenas, arena *hint ) {
     if ( arenas.empty() )
         return NULL;
-    arena_list_type::iterator it = next;
+    arena_list_type::iterator it = hint;
     __TBB_ASSERT( it != arenas.end(), NULL );
     do {
         arena& a = *it;
         if ( ++it == arenas.end() )
             it = arenas.begin();
-        if( a.num_workers_active() < a.my_num_workers_allotted
-#if __TBB_ENQUEUE_ENFORCED_CONCURRENCY
-            && !a.recall_by_mandatory_request()
-#endif
-            ) {
+        if( a.num_workers_active() < a.my_num_workers_allotted ) {
             a.my_references += arena::ref_worker;
-            as_atomic(next) = &*it; // a subject for innocent data race under the reader lock
-            // TODO: rework global round robin policy to local or random to avoid this write
             return &a;
         }
-    } while ( it != next );
+    } while ( it != hint );
     return NULL;
 }
 
 int market::update_allotment ( arena_list_type& arenas, int workers_demand, int max_workers ) {
-    __TBB_ASSERT( workers_demand, NULL );
+    __TBB_ASSERT( workers_demand > 0, NULL );
     max_workers = min(workers_demand, max_workers);
-    int carry = 0;
     int assigned = 0;
-    arena_list_type::iterator it = arenas.begin();
-    for ( ; it != arenas.end(); ++it ) {
+    int carry = 0;
+    for (arena_list_type::iterator it = arenas.begin(); it != arenas.end(); ++it) {
         arena& a = *it;
-        if ( a.my_num_workers_requested <= 0 ) {
-            __TBB_ASSERT( !a.my_num_workers_allotted, NULL );
+        if (a.my_num_workers_requested <= 0) {
+            __TBB_ASSERT(!a.my_num_workers_allotted, NULL);
             continue;
         }
-        int tmp = a.my_num_workers_requested * max_workers + carry;
-        int allotted = tmp / workers_demand;
-        carry = tmp % workers_demand;
-        // a.my_num_workers_requested may temporarily exceed a.my_max_num_workers
-        allotted = min( allotted, (int)a.my_max_num_workers );
+        int allotted = 0;
 #if __TBB_ENQUEUE_ENFORCED_CONCURRENCY
-        if ( !allotted && a.must_have_concurrency() )
-            allotted = 1;
+        if (my_num_workers_soft_limit == 0) {
+            __TBB_ASSERT(max_workers == 0 || max_workers == 1, NULL);
+            allotted = a.my_global_concurrency_mode && assigned < max_workers ? 1 : 0;
+        } else
 #endif
+        {
+            int tmp = a.my_num_workers_requested * max_workers + carry;
+            allotted = tmp / workers_demand;
+            carry = tmp % workers_demand;
+            // a.my_num_workers_requested may temporarily exceed a.my_max_num_workers
+            allotted = min(allotted, (int)a.my_max_num_workers);
+        }
         a.my_num_workers_allotted = allotted;
         assigned += allotted;
     }
-#if __TBB_ENQUEUE_ENFORCED_CONCURRENCY
-    __TBB_ASSERT( assigned <= workers_demand, NULL ); // weaker assertion due to enforced allotment
-#else
-    __TBB_ASSERT( assigned <= max_workers, NULL );
-#endif
+    __TBB_ASSERT( 0 <= assigned && assigned <= max_workers, NULL );
     return assigned;
 }
 
+/** This method must be invoked under my_arenas_list_mutex. **/
+bool market::is_arena_in_list( arena_list_type &arenas, arena *a ) {
+    if ( a ) {
+        for ( arena_list_type::iterator it = arenas.begin(); it != arenas.end(); ++it )
+            if ( a == &*it )
+                return true;
+    }
+    return false;
+}
+
 #if __TBB_TASK_PRIORITY
 inline void market::update_global_top_priority ( intptr_t newPriority ) {
     GATHER_STATISTIC( ++governor::local_scheduler_if_initialized()->my_counters.market_prio_switches );
@@ -432,21 +447,29 @@ inline void market::reset_global_priority () {
     update_global_top_priority(normalized_normal_priority);
 }
 
-arena* market::arena_in_need ( arena* prev_arena )
-{
-    suppress_unused_warning(prev_arena);
+arena* market::arena_in_need ( arena* prev_arena ) {
     if( as_atomic(my_total_demand) <= 0 )
         return NULL;
     arenas_list_mutex_type::scoped_lock lock(my_arenas_list_mutex, /*is_writer=*/false);
     assert_market_valid();
     int p = my_global_top_priority;
     arena *a = NULL;
-    do {
-        priority_level_info &pl = my_priority_levels[p];
+
+    // Checks if arena is alive or not
+    if ( is_arena_in_list( my_priority_levels[p].arenas, prev_arena ) ) {
+        a = arena_in_need( my_priority_levels[p].arenas, prev_arena );
+    }
+
+    while ( !a && p >= my_global_bottom_priority ) {
+        priority_level_info &pl = my_priority_levels[p--];
         a = arena_in_need( pl.arenas, pl.next_arena );
+        if ( a ) {
+            as_atomic(pl.next_arena) = a; // a subject for innocent data race under the reader lock
+            // TODO: rework global round robin policy to local or random to avoid this write
+        }
         // TODO: When refactoring task priority code, take into consideration the
         // __TBB_TRACK_PRIORITY_LEVEL_SATURATION sections from earlier versions of TBB
-    } while ( !a && --p >= my_global_bottom_priority );
+    }
     return a;
 }
 
@@ -458,7 +481,7 @@ void market::update_allotment ( intptr_t highest_affected_priority ) {
         pl.workers_available = available;
         if ( pl.workers_requested ) {
             available -= update_allotment( pl.arenas, pl.workers_requested, available );
-            if ( available < 0 ) { // TODO: assertion?
+            if ( available <= 0 ) { // TODO: assertion?
                 available = 0;
                 break;
             }
@@ -471,103 +494,63 @@ void market::update_allotment ( intptr_t highest_affected_priority ) {
         arena_list_type::iterator it = pl.arenas.begin();
         for ( ; it != pl.arenas.end(); ++it ) {
             __TBB_ASSERT( it->my_num_workers_requested >= 0 || !it->my_num_workers_allotted, NULL );
-#if __TBB_ENQUEUE_ENFORCED_CONCURRENCY
-            it->my_num_workers_allotted = it->must_have_concurrency() ? 1 : 0;
-#else
             it->my_num_workers_allotted = 0;
-#endif
         }
     }
 }
 #endif /* __TBB_TASK_PRIORITY */
 
 #if __TBB_ENQUEUE_ENFORCED_CONCURRENCY
-bool market::mandatory_concurrency_enable_impl ( arena *a, bool *enabled ) {
-    if( a->my_concurrency_mode==arena_base::cm_enforced_global ) {
-        if( enabled )
-            *enabled = false;
-        return false;
-    }
-    if( enabled )
-        *enabled = true;
-    a->my_max_num_workers = 1;
-    a->my_concurrency_mode = arena_base::cm_enforced_global;
-#if __TBB_TASK_PRIORITY
-    priority_level_info &pl = my_priority_levels[a->my_top_priority];
-    pl.workers_requested++;
-    if( my_global_top_priority < a->my_top_priority ) {
-        my_global_top_priority = a->my_top_priority;
-        advance_global_reload_epoch();
-    }
-#endif
-    a->my_num_workers_requested++;
-    a->my_num_workers_allotted++;
-    if( 1 == ++my_mandatory_num_requested ) {
-        my_total_demand++;
-        return true;
-    }
-    return false;
+void market::enable_mandatory_concurrency_impl ( arena *a ) {
+    __TBB_ASSERT(!a->my_global_concurrency_mode, NULL);
+    __TBB_ASSERT(my_num_workers_soft_limit == 0, NULL);
+
+    a->my_global_concurrency_mode = true;
+    my_mandatory_num_requested++;
 }
 
-bool market::mandatory_concurrency_enable ( arena *a ) {
-    bool add_thread;
-    bool enabled;
+void market::enable_mandatory_concurrency ( arena *a ) {
+    int delta = 0;
     {
         arenas_list_mutex_type::scoped_lock lock(my_arenas_list_mutex);
-        add_thread = mandatory_concurrency_enable_impl(a, &enabled);
+        if (my_num_workers_soft_limit != 0 || a->my_global_concurrency_mode)
+            return;
+
+        enable_mandatory_concurrency_impl(a);
+        delta = update_workers_request();
     }
-    if( add_thread )
-        my_server->adjust_job_count_estimate( 1 );
-    return enabled;
+
+    if (delta != 0)
+        my_server->adjust_job_count_estimate(delta);
 }
 
-void market::mandatory_concurrency_disable ( arena *a ) {
-    bool remove_thread = false;
-    int delta_adjust_demand = 0;
+void market::disable_mandatory_concurrency_impl(arena* a) {
+    __TBB_ASSERT(a->my_global_concurrency_mode, NULL);
+    __TBB_ASSERT(my_mandatory_num_requested > 0, NULL);
+
+    a->my_global_concurrency_mode = false;
+    my_mandatory_num_requested--;
+}
 
+void market::mandatory_concurrency_disable ( arena *a ) {
+    int delta = 0;
     {
         arenas_list_mutex_type::scoped_lock lock(my_arenas_list_mutex);
-
-        if( a->my_concurrency_mode!=arena_base::cm_enforced_global  )
+        if (!a->my_global_concurrency_mode)
+            return;
+        // There is a racy window in advertise_new_work between mandtory concurrency enabling and 
+        // setting SNAPSHOT_FULL. It gives a chance to spawn request to disable mandatory concurrency.
+        // Therefore, we double check that there is no enqueued tasks.
+        if (a->has_enqueued_tasks())
             return;
-        __TBB_ASSERT( a->my_max_num_workers==1, NULL );
-        a->my_max_num_workers = 0;
-#if __TBB_TASK_PRIORITY
-        if ( a->my_top_priority != normalized_normal_priority ) {
-            update_arena_top_priority( *a, normalized_normal_priority );
-        }
-        a->my_bottom_priority = normalized_normal_priority;
-#endif
 
-        int val = --my_mandatory_num_requested;
-        __TBB_ASSERT_EX( val >= 0, NULL );
-        if( val == 0 ) {
-            my_total_demand--;
-            remove_thread = true;
-        }
-        a->my_num_workers_requested--;
-        if (a->my_num_workers_requested > 0)
-            delta_adjust_demand = a->my_num_workers_requested;
-        else
-            a->my_num_workers_allotted = 0;
+        __TBB_ASSERT(my_num_workers_soft_limit == 0, NULL);
+        disable_mandatory_concurrency_impl(a);
 
-#if __TBB_TASK_PRIORITY
-        priority_level_info &pl = my_priority_levels[a->my_top_priority];
-        pl.workers_requested--;
-        intptr_t p = my_global_top_priority;
-        for (; !my_priority_levels[p].workers_requested && p>0; p--)
-            ;
-        if( !p )
-            reset_global_priority();
-        else if( p!= my_global_top_priority )
-            update_global_top_priority(p);
-#endif
-        a->my_concurrency_mode = arena::cm_normal;
+        delta = update_workers_request();
     }
-    if( delta_adjust_demand )
-        adjust_demand( *a, -delta_adjust_demand );
-    if( remove_thread )
-        my_server->adjust_job_count_estimate( -1 );
+    if (delta != 0)
+        my_server->adjust_job_count_estimate(delta);
 }
 #endif /* __TBB_ENQUEUE_ENFORCED_CONCURRENCY */
 
@@ -579,13 +562,7 @@ void market::adjust_demand ( arena& a, int delta ) {
     int prev_req = a.my_num_workers_requested;
     a.my_num_workers_requested += delta;
     if ( a.my_num_workers_requested <= 0 ) {
-#if __TBB_ENQUEUE_ENFORCED_CONCURRENCY
-        // must not recall worker from arena with mandatory parallelism
-        if ( a.my_market->my_mandatory_num_requested && a.my_concurrency_mode!=arena_base::cm_normal )
-            a.my_num_workers_allotted = 1;
-        else
-#endif
-            a.my_num_workers_allotted = 0;
+        a.my_num_workers_allotted = 0;
         if ( prev_req <= 0 ) {
             my_arenas_list_mutex.unlock();
             return;
@@ -596,8 +573,13 @@ void market::adjust_demand ( arena& a, int delta ) {
         delta = a.my_num_workers_requested;
     }
     my_total_demand += delta;
+    unsigned effective_soft_limit = my_num_workers_soft_limit;
+    if (my_mandatory_num_requested > 0) {
+        __TBB_ASSERT(effective_soft_limit == 0, NULL);
+        effective_soft_limit = 1;
+    }
 #if !__TBB_TASK_PRIORITY
-    update_allotment();
+    update_allotment(effective_soft_limit);
 #else /* !__TBB_TASK_PRIORITY */
     intptr_t p = a.my_top_priority;
     priority_level_info &pl = my_priority_levels[p];
@@ -619,6 +601,7 @@ void market::adjust_demand ( arena& a, int delta ) {
             else
                 update_global_top_priority(p);
         }
+        my_priority_levels[my_global_top_priority].workers_available = effective_soft_limit;
         update_allotment( my_global_top_priority );
     }
     else if ( p > my_global_top_priority ) {
@@ -626,14 +609,8 @@ void market::adjust_demand ( arena& a, int delta ) {
         // TODO: investigate if the following invariant is always valid
         __TBB_ASSERT( a.my_num_workers_requested >= 0, NULL );
         update_global_top_priority(p);
-        a.my_num_workers_allotted = min( (int)my_num_workers_soft_limit, a.my_num_workers_requested );
-#if __TBB_ENQUEUE_ENFORCED_CONCURRENCY
-        // must not recall worker from arena with mandatory parallelism
-        if ( !a.my_num_workers_allotted && a.my_num_workers_requested
-             && a.my_market->my_mandatory_num_requested && a.my_concurrency_mode!=arena_base::cm_normal )
-            a.my_num_workers_allotted = 1;
-#endif
-        my_priority_levels[p - 1].workers_available = my_num_workers_soft_limit - a.my_num_workers_allotted;
+        a.my_num_workers_allotted = min( (int)effective_soft_limit, a.my_num_workers_requested );
+        my_priority_levels[p - 1].workers_available = effective_soft_limit - a.my_num_workers_allotted;
         update_allotment( p - 1 );
     }
     else if ( p == my_global_bottom_priority ) {
@@ -663,15 +640,15 @@ void market::adjust_demand ( arena& a, int delta ) {
     if ( delta > 0 ) {
         // can't overflow soft_limit, but remember values request by arenas in
         // my_total_demand to not prematurely release workers to RML
-        if ( my_num_workers_requested+delta > (int)my_num_workers_soft_limit )
-            delta = my_num_workers_soft_limit - my_num_workers_requested;
+        if ( my_num_workers_requested+delta > (int)effective_soft_limit)
+            delta = effective_soft_limit - my_num_workers_requested;
     } else {
         // the number of workers should not be decreased below my_total_demand
         if ( my_num_workers_requested+delta < my_total_demand )
-            delta = min(my_total_demand, (int)my_num_workers_soft_limit) - my_num_workers_requested;
+            delta = min(my_total_demand, (int)effective_soft_limit) - my_num_workers_requested;
     }
     my_num_workers_requested += delta;
-    __TBB_ASSERT( my_num_workers_requested <= (int)my_num_workers_soft_limit, NULL );
+    __TBB_ASSERT( my_num_workers_requested <= (int)effective_soft_limit, NULL );
 
     my_arenas_list_mutex.unlock();
     // Must be called outside of any locks
@@ -681,43 +658,23 @@ void market::adjust_demand ( arena& a, int delta ) {
 
 void market::process( job& j ) {
     generic_scheduler& s = static_cast<generic_scheduler&>(j);
-    arena *a = NULL;
+    // s.my_arena can be dead. Don't access it until arena_in_need is called
+    arena *a = s.my_arena;
     __TBB_ASSERT( governor::is_set(&s), NULL );
-    enum {
-        query_interval = 1000,
-        first_interval = 1
-    };
-    for(int i = first_interval; ; i--) {
-        while ( (a = arena_in_need(a)) )
-        {
+
+    for (int i = 0; i < 2; ++i) {
+        while ( (a = arena_in_need(a)) ) {
             a->process(s);
-            i = first_interval;
+            a = NULL; // to avoid double checks in arena_in_need(arena*) for the same priority level
         }
         // Workers leave market because there is no arena in need. It can happen earlier than
         // adjust_job_count_estimate() decreases my_slack and RML can put this thread to sleep.
         // It might result in a busy-loop checking for my_slack<0 and calling this method instantly.
-        // first_interval>0 and the yield refines this spinning.
-        if( i > 0 )
+        // the yield refines this spinning.
+        if ( !i )
             __TBB_Yield();
-        else
-#if !__TBB_SLEEP_PERMISSION
-            break;
-#else
-        { // i == 0
-#if __TBB_TASK_PRIORITY
-            arena_list_type &al = my_priority_levels[my_global_top_priority].arenas;
-#else /* __TBB_TASK_PRIORITY */
-            arena_list_type &al = my_arenas;
-#endif /* __TBB_TASK_PRIORITY */
-            if( al.empty() ) // races if any are innocent TODO: replace by an RML query interface
-                break; // no arenas left, perhaps going to shut down
-            if( the_global_observer_list.ask_permission_to_leave() )
-                break; // go sleep
-            __TBB_Yield();
-            i = query_interval;
-        }
-#endif// !__TBB_SLEEP_PERMISSION
     }
+
     GATHER_STATISTIC( ++s.my_counters.market_roundtrips );
 }
 
@@ -744,7 +701,7 @@ ::rml::job* market::create_one_job() {
     __TBB_ASSERT( index > 0, NULL );
     ITT_THREAD_SET_NAME(_T("TBB Worker Thread"));
     // index serves as a hint decreasing conflicts between workers when they migrate between arenas
-    generic_scheduler* s = generic_scheduler::create_worker( *this, index );
+    generic_scheduler* s = generic_scheduler::create_worker( *this, index, /* genuine = */ true );
 #if __TBB_TASK_GROUP_CONTEXT
     __TBB_ASSERT( index <= my_num_workers_hard_limit, NULL );
     __TBB_ASSERT( !my_workers[index - 1], NULL );
@@ -848,12 +805,7 @@ bool market::update_arena_priority ( arena& a, intptr_t new_priority ) {
                 && !my_priority_levels[my_global_bottom_priority].workers_requested )
             ++my_global_bottom_priority;
         __TBB_ASSERT( my_global_bottom_priority <= new_priority, NULL );
-#if __TBB_ENQUEUE_ENFORCED_CONCURRENCY
-        const bool enforced_concurrency = my_mandatory_num_requested && a.must_have_concurrency();
-#else
-        const bool enforced_concurrency = false;
-#endif
-        __TBB_ASSERT_EX( enforced_concurrency || my_priority_levels[my_global_bottom_priority].workers_requested > 0, NULL );
+        __TBB_ASSERT( my_priority_levels[my_global_bottom_priority].workers_requested > 0, NULL );
     }
     update_allotment( highest_affected_level );
 
diff --git a/src/tbb/src/tbb/market.h b/src/tbb/src/tbb/market.h
index 39d12d5e..8c4a1282 100644
--- a/src/tbb/src/tbb/market.h
+++ b/src/tbb/src/tbb/market.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef _TBB_market_H
@@ -178,6 +174,9 @@ class market : no_copy, rml::tbb_client {
     //! Destroys and deallocates market object created by market::create()
     void destroy ();
 
+    //! Recalculates the number of workers requested from RML and updates the allotment.
+    int update_workers_request();
+
 #if __TBB_TASK_PRIORITY
     //! Returns next arena that needs more workers, or NULL.
     arena* arena_in_need ( arena* prev_arena );
@@ -212,18 +211,33 @@ class market : no_copy, rml::tbb_client {
     //! Recalculates the number of workers assigned to each arena in the list.
     /** The actual number of workers servicing a particular arena may temporarily
         deviate from the calculated value. **/
-    void update_allotment () {
+    void update_allotment (unsigned effective_soft_limit) {
         if ( my_total_demand )
-            update_allotment( my_arenas, my_total_demand, (int)my_num_workers_soft_limit );
+            update_allotment( my_arenas, my_total_demand, (int)effective_soft_limit );
     }
 
+    // TODO: consider to rewrite the code with is_arena_in_list function
     //! Returns next arena that needs more workers, or NULL.
-    arena* arena_in_need (arena*) {
+    arena* arena_in_need (arena* prev_arena) {
         if(__TBB_load_with_acquire(my_total_demand) <= 0)
             return NULL;
         arenas_list_mutex_type::scoped_lock lock(my_arenas_list_mutex, /*is_writer=*/false);
-        return arena_in_need(my_arenas, my_next_arena);
+        arena* a = NULL;
+
+        // Checks if arena is alive or not
+        if ( is_arena_in_list( my_arenas, prev_arena ) ) {
+            a = arena_in_need( my_arenas, prev_arena );
+        } else {
+            a = arena_in_need( my_arenas, my_next_arena );
+            if (a) {
+                as_atomic(my_next_arena) = a; // a subject for innocent data race under the reader lock
+                // TODO: rework global round robin policy to local or random to avoid this write
+            }
+        }
+
+        return a;
     }
+
     void assert_market_valid () const {}
 #endif /* !__TBB_TASK_PRIORITY */
 
@@ -234,9 +248,11 @@ class market : no_copy, rml::tbb_client {
 
     void remove_arena_from_list ( arena& a );
 
-    arena* arena_in_need ( arena_list_type &arenas, arena *&next );
+    arena* arena_in_need ( arena_list_type &arenas, arena *hint );
+
+    int update_allotment ( arena_list_type& arenas, int total_demand, int max_workers );
 
-    static int update_allotment ( arena_list_type& arenas, int total_demand, int max_workers );
+    bool is_arena_in_list( arena_list_type &arenas, arena *a );
 
 
     ////////////////////////////////////////////////////////////////////////////////
@@ -275,10 +291,13 @@ class market : no_copy, rml::tbb_client {
 
 #if __TBB_ENQUEUE_ENFORCED_CONCURRENCY
     //! Imlpementation of mandatory concurrency enabling
-    bool mandatory_concurrency_enable_impl ( arena *a, bool *enabled = NULL );
+    void enable_mandatory_concurrency_impl ( arena *a );
 
     //! Inform the master that there is an arena with mandatory concurrency
-    bool mandatory_concurrency_enable ( arena *a );
+    void enable_mandatory_concurrency ( arena *a );
+
+    //! Inform the master that the arena is no more interested in mandatory concurrency
+    void disable_mandatory_concurrency_impl(arena* a);
 
     //! Inform the master that the arena is no more interested in mandatory concurrency
     void mandatory_concurrency_disable ( arena *a );
diff --git a/src/tbb/src/tbb/mutex.cpp b/src/tbb/src/tbb/mutex.cpp
index fd02d260..603109ae 100644
--- a/src/tbb/src/tbb/mutex.cpp
+++ b/src/tbb/src/tbb/mutex.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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||_WIN64
diff --git a/src/tbb/src/tbb/observer_proxy.cpp b/src/tbb/src/tbb/observer_proxy.cpp
index 2a9b2bf4..b22f3c63 100644
--- a/src/tbb/src/tbb/observer_proxy.cpp
+++ b/src/tbb/src/tbb/observer_proxy.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 "tbb/tbb_config.h"
@@ -47,7 +43,7 @@ struct check_observer_proxy_count {
 static check_observer_proxy_count the_check_observer_proxy_count;
 #endif /* TBB_USE_ASSERT */
 
-#if __TBB_ARENA_OBSERVER || __TBB_SLEEP_PERMISSION
+#if __TBB_ARENA_OBSERVER
 interface6::task_scheduler_observer* observer_proxy::get_v6_observer() {
     if(my_version != 6) return NULL;
     return static_cast<interface6::task_scheduler_observer*>(my_observer);
@@ -295,64 +291,6 @@ void observer_list::do_notify_exit_observers( observer_proxy* last, bool worker
     }
 }
 
-#if __TBB_SLEEP_PERMISSION
-bool observer_list::ask_permission_to_leave() {
-    __TBB_ASSERT( this == &the_global_observer_list, "This method cannot be used on lists of arena observers" );
-    if( !my_head ) return true;
-    // Pointer p marches though the list
-    observer_proxy *p = NULL, *prev = NULL;
-    bool result = true;
-    while( result ) {
-        task_scheduler_observer* tso = NULL;
-        // Hold lock on list only long enough to advance to the next proxy in the list.
-        {
-            scoped_lock lock(mutex(), /*is_writer=*/false);
-            do {
-                if( p ) {
-                    // We were already processing the list.
-                    observer_proxy* q = p->my_next;
-                    // read next, remove the previous reference
-                    if( p == prev )
-                        remove_ref_fast(prev); // sets prev to NULL if successful
-                    if( q ) p = q;
-                    else {
-                        // Reached the end of the list.
-                        if( prev ) {
-                            lock.release();
-                            remove_ref(prev);
-                        }
-                        return result;
-                    }
-                } else {
-                    // Starting pass through the list
-                    p = my_head;
-                    if( !p )
-                        return result;
-                }
-                tso = p->get_v6_observer();
-            } while( !tso );
-            ++p->my_ref_count;
-            ++tso->my_busy_count;
-        }
-        __TBB_ASSERT( !prev || p!=prev, NULL );
-        // Release the proxy pinned before p
-        if( prev )
-            remove_ref(prev);
-        // Do not hold any locks on the list while calling user's code.
-        // Do not intercept any exceptions that may escape the callback so that
-        // they are either handled by the TBB scheduler or passed to the debugger.
-        result = tso->may_sleep();
-        __TBB_ASSERT(p->my_ref_count, NULL);
-        intptr_t bc = --tso->my_busy_count;
-        __TBB_ASSERT_EX( bc>=0, "my_busy_count underflowed" );
-        prev = p;
-    }
-    if( prev )
-        remove_ref(prev);
-    return result;
-}
-#endif//__TBB_SLEEP_PERMISSION
-
 void task_scheduler_observer_v3::observe( bool enable ) {
     if( enable ) {
         if( !my_proxy ) {
@@ -366,10 +304,11 @@ void task_scheduler_observer_v3::observe( bool enable ) {
                 intptr_t tag = my_proxy->get_v6_observer()->my_context_tag;
                 if( tag != interface6::task_scheduler_observer::implicit_tag ) { // explicit arena
                     task_arena *a = reinterpret_cast<task_arena*>(tag);
-                    a->initialize();
+                    if ( a->my_arena==NULL ) // Avoid recursion during arena initialization
+                        a->initialize();
                     my_proxy->my_list = &a->my_arena->my_observers;
                 } else {
-                    if( !s )
+                    if( !(s && s->my_arena) )
                         s = governor::init_scheduler( task_scheduler_init::automatic, 0, true );
                     __TBB_ASSERT( __TBB_InitOnce::initialization_done(), NULL );
                     __TBB_ASSERT( s && s->my_arena, NULL );
diff --git a/src/tbb/src/tbb/observer_proxy.h b/src/tbb/src/tbb/observer_proxy.h
index 7f2c4e39..50b652e1 100644
--- a/src/tbb/src/tbb/observer_proxy.h
+++ b/src/tbb/src/tbb/observer_proxy.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef _TBB_observer_proxy_H
@@ -92,9 +88,6 @@ class observer_list {
 
     //! Call exit notifications on last and observers added before it.
     inline void notify_exit_observers( observer_proxy*& last, bool worker );
-
-    //! Call may_sleep callbacks to ask for permission for a worker thread to leave market
-    bool ask_permission_to_leave();
 }; // class observer_list
 
 //! Wrapper for an observer object
@@ -122,7 +115,7 @@ class observer_proxy {
     //! Version
     char my_version;
 
-#if __TBB_ARENA_OBSERVER || __TBB_SLEEP_PERMISSION
+#if __TBB_ARENA_OBSERVER
     interface6::task_scheduler_observer* get_v6_observer();
 #endif
 #if __TBB_ARENA_OBSERVER
diff --git a/src/tbb/src/tbb/pipeline.cpp b/src/tbb/src/tbb/pipeline.cpp
index 96a0aeea..89c66f9f 100644
--- a/src/tbb/src/tbb/pipeline.cpp
+++ b/src/tbb/src/tbb/pipeline.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 "tbb/pipeline.h"
@@ -169,8 +165,8 @@ class input_buffer : no_copy {
 
     //! Note that processing of a token is finished.
     /** Fires up processing of the next token, if processing was deferred. */
-    // Using template to avoid explicit dependency on stage_task
-    // this is only called for serial filters, and is the reason for the
+    // Uses template to avoid explicit dependency on stage_task.
+    // This is only called for serial filters, and is the reason for the
     // advance parameter in return_item (we're incrementing low_token here.)
     // Non-TBF serial stages don't advance the token at the start because the presence
     // of the current token in the buffer keeps another stage from being spawned.
@@ -206,8 +202,8 @@ class input_buffer : no_copy {
     }
 #endif
 
-    //! return an item, invalidate the queued item, but only advance if advance
-    //  advance == true for parallel filters.  If the filter is serial, leave the
+    //! return an item, invalidate the queued item, but only advance if the filter
+    // is parallel (as indicated by advance == true). If the filter is serial, leave the
     // item in the buffer to keep another stage from being spawned.
     bool return_item(task_info& info, bool advance) {
         spin_mutex::scoped_lock lock( array_mutex );
@@ -425,10 +421,27 @@ class pipeline_root_task: public task {
                 {
                     task_info info;
                     info.reset();
-                    if( current_filter->my_input_buffer->return_item(info, !current_filter->is_serial()) ) {
-                        set_ref_count(1);
+                    task* bypass = NULL;
+                    int refcnt = 0;
+                    task_list list;
+                    // No new tokens are created; it's OK to process all waiting tokens.
+                    // If the filter is serial, the second call to return_item will return false.
+                    while( current_filter->my_input_buffer->return_item(info, !current_filter->is_serial()) ) {
+                        task* t = new( allocate_child() ) stage_task( my_pipeline, current_filter, info );
+                        if( ++refcnt == 1 )
+                            bypass = t;
+                        else // there's more than one task
+                            list.push_back(*t);
+                        // TODO: limit the list size (to arena size?) to spawn tasks sooner
+                        __TBB_ASSERT( refcnt <= int(my_pipeline.token_counter), "token counting error" );
+                        info.reset();
+                    }
+                    if( refcnt ) {
+                        set_ref_count( refcnt );
+                        if( refcnt > 1 )
+                            spawn(list);
                         recycle_as_continuation();
-                        return new( allocate_child() ) stage_task( my_pipeline, current_filter, info);
+                        return bypass;
                     }
                     current_filter = current_filter->next_segment;
                     if( !current_filter ) {
@@ -565,9 +578,7 @@ void pipeline::add_filter( filter& filter_ ) {
             filter_end->next_filter_in_pipeline = &filter_;
         filter_.next_filter_in_pipeline = NULL;
         filter_end = &filter_;
-    }
-    else
-    {
+    } else {
         if( !filter_end )
             filter_end = reinterpret_cast<filter*>(&filter_list);
 
@@ -580,15 +591,13 @@ void pipeline::add_filter( filter& filter_ ) {
             if( filter_.is_bound() )
                 has_thread_bound_filters = true;
             filter_.my_input_buffer = new internal::input_buffer( filter_.is_ordered(), filter_.is_bound() );
-        }
-        else {
+        } else {
             if(filter_.prev_filter_in_pipeline) {
                 if(filter_.prev_filter_in_pipeline->is_bound()) {
                     // successors to bound filters must have an input_buffer
                     filter_.my_input_buffer = new internal::input_buffer( /*is_ordered*/false, false );
                 }
-            }
-            else {  // input filter
+            } else {  // input filter
                 if(filter_.object_may_be_null() ) {
                     //TODO: buffer only needed to hold TLS; could improve
                     filter_.my_input_buffer = new internal::input_buffer( /*is_ordered*/false, false );
@@ -696,14 +705,12 @@ filter::~filter() {
     }
 }
 
-void
-filter::set_end_of_input() {
+void filter::set_end_of_input() {
     __TBB_ASSERT(my_input_buffer, NULL);
     __TBB_ASSERT(object_may_be_null(), NULL);
     if(is_serial()) {
         my_pipeline->end_of_input = true;
-    }
-    else {
+    } else {
         __TBB_ASSERT(my_input_buffer->end_of_input_tls_allocated, NULL);
         my_input_buffer->set_my_tls_end_of_input();
     }
diff --git a/src/tbb/src/tbb/private_server.cpp b/src/tbb/src/tbb/private_server.cpp
index d9be168c..d0639038 100644
--- a/src/tbb/src/tbb/private_server.cpp
+++ b/src/tbb/src/tbb/private_server.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,14 +12,10 @@
     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 "rml_tbb.h"
-#include "../server/thread_monitor.h"
+#include "../rml/include/rml_tbb.h"
+#include "../rml/server/thread_monitor.h"
 #include "tbb/atomic.h"
 #include "tbb/cache_aligned_allocator.h"
 #include "scheduler_common.h"
@@ -275,6 +271,7 @@ void private_worker::run() {
             // Check/set the invariant for sleeping
             if( my_state!=st_quit && my_server.try_insert_in_asleep_list(*this) ) {
                 my_thread_monitor.commit_wait(c);
+                __TBB_ASSERT( my_state==st_quit || !my_next, "Thread monitor missed a spurious wakeup?" );
                 my_server.propagate_chain_reaction();
             } else {
                 // Invariant broken
@@ -310,8 +307,10 @@ inline void private_worker::wake_or_launch() {
             release_handle(my_handle, governor::does_client_join_workers(my_client));
         }
     }
-    else
+    else {
+        __TBB_ASSERT( !my_next, "Should not wake a thread while it's still in asleep list" );
         my_thread_monitor.notify();
+    }
 }
 
 //------------------------------------------------------------------------
@@ -390,8 +389,11 @@ void private_server::wake_some( int additional_slack ) {
         }
     }
 done:
-    while( w>wakee )
-        (*--w)->wake_or_launch();
+    while( w>wakee ) {
+        private_worker* ww = *--w;
+        ww->my_next = NULL;
+        ww->wake_or_launch();
+    }
 }
 
 void private_server::adjust_job_count_estimate( int delta ) {
diff --git a/src/tbb/src/tbb/queuing_mutex.cpp b/src/tbb/src/tbb/queuing_mutex.cpp
index 0071f8b9..4d71052d 100644
--- a/src/tbb/src/tbb/queuing_mutex.cpp
+++ b/src/tbb/src/tbb/queuing_mutex.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 "tbb/queuing_mutex.h"
diff --git a/src/tbb/src/tbb/queuing_rw_mutex.cpp b/src/tbb/src/tbb/queuing_rw_mutex.cpp
index f19a86bd..ca496054 100644
--- a/src/tbb/src/tbb/queuing_rw_mutex.cpp
+++ b/src/tbb/src/tbb/queuing_rw_mutex.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 /** Before making any changes in the implementation, please emulate algorithmic changes
@@ -363,7 +359,7 @@ void queuing_rw_mutex::scoped_lock::release( )
 
 bool queuing_rw_mutex::scoped_lock::downgrade_to_reader()
 {
-    __TBB_ASSERT( my_state==STATE_WRITER, "no sense to downgrade a reader" );
+    if ( my_state == STATE_ACTIVEREADER ) return true; // Already a reader
 
     ITT_NOTIFY(sync_releasing, my_mutex);
     my_state = STATE_READER;
@@ -390,7 +386,7 @@ bool queuing_rw_mutex::scoped_lock::downgrade_to_reader()
 
 bool queuing_rw_mutex::scoped_lock::upgrade_to_writer()
 {
-    __TBB_ASSERT( my_state==STATE_ACTIVEREADER, "only active reader can be upgraded" );
+    if ( my_state == STATE_WRITER ) return true; // Already a writer
 
     queuing_rw_mutex::scoped_lock * tmp;
     queuing_rw_mutex::scoped_lock * me = this;
diff --git a/src/tbb/src/tbb/reader_writer_lock.cpp b/src/tbb/src/tbb/reader_writer_lock.cpp
index 770ab25d..0ee81861 100644
--- a/src/tbb/src/tbb/reader_writer_lock.cpp
+++ b/src/tbb/src/tbb/reader_writer_lock.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 "tbb/reader_writer_lock.h"
diff --git a/src/tbb/src/tbb/recursive_mutex.cpp b/src/tbb/src/tbb/recursive_mutex.cpp
index 7d33202c..6e815618 100644
--- a/src/tbb/src/tbb/recursive_mutex.cpp
+++ b/src/tbb/src/tbb/recursive_mutex.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 "tbb/recursive_mutex.h"
diff --git a/src/tbb/src/tbb/scheduler.cpp b/src/tbb/src/tbb/scheduler.cpp
index adb01c80..f98440d4 100644
--- a/src/tbb/src/tbb/scheduler.cpp
+++ b/src/tbb/src/tbb/scheduler.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 "custom_scheduler.h"
@@ -36,10 +32,10 @@ namespace internal {
 //------------------------------------------------------------------------
 
 /** Defined in tbb_main.cpp **/
-extern generic_scheduler* (*AllocateSchedulerPtr)( market& );
+extern generic_scheduler* (*AllocateSchedulerPtr)( market&, bool );
 
-inline generic_scheduler* allocate_scheduler ( market& m ) {
-    return AllocateSchedulerPtr( m );
+inline generic_scheduler* allocate_scheduler ( market& m, bool genuine ) {
+    return AllocateSchedulerPtr( m, genuine);
 }
 
 #if __TBB_TASK_GROUP_CONTEXT
@@ -85,10 +81,13 @@ scheduler::~scheduler( ) {}
     #pragma warning(disable:4355)
 #endif
 
-generic_scheduler::generic_scheduler( market& m )
+generic_scheduler::generic_scheduler( market& m, bool genuine )
     : my_market(&m)
     , my_random(this)
     , my_ref_count(1)
+#if __TBB_PREVIEW_RESUMABLE_TASKS
+    , my_co_context(m.worker_stack_size(), genuine ? NULL : this)
+#endif
     , my_small_task_count(1)   // Extra 1 is a guard reference
 #if __TBB_SURVIVE_THREAD_SWITCH && TBB_USE_ASSERT
     , my_cilk_state(cs_none)
@@ -98,6 +97,18 @@ generic_scheduler::generic_scheduler( market& m )
     __TBB_ASSERT( governor::is_set(NULL), "scheduler is already initialized for this thread" );
 
     my_innermost_running_task = my_dummy_task = &allocate_task( sizeof(task), __TBB_CONTEXT_ARG(NULL, &the_dummy_context) );
+#if __TBB_PREVIEW_CRITICAL_TASKS
+    my_properties.has_taken_critical_task = false;
+#endif
+#if __TBB_PREVIEW_RESUMABLE_TASKS
+    my_properties.genuine = genuine;
+    my_current_is_recalled = NULL;
+    my_post_resume_action = PRA_NONE;
+    my_post_resume_arg = NULL;
+    my_wait_task = NULL;
+#else
+    suppress_unused_warning(genuine);
+#endif
     my_properties.outermost = true;
 #if __TBB_TASK_PRIORITY
     my_ref_top_priority = &m.my_global_top_priority;
@@ -182,9 +193,20 @@ void generic_scheduler::init_stack_info () {
     void    *rsb_base = __TBB_get_bsp();
 #endif
     size_t  np_stack_size = 0;
+    // Points to the lowest addressable byte of a stack.
     void    *stack_limit = NULL;
+
+#if __TBB_PREVIEW_RESUMABLE_TASKS
+    if ( !my_properties.genuine ) {
+        stack_limit = my_co_context.get_stack_limit();
+        __TBB_ASSERT( (uintptr_t)stack_base > (uintptr_t)stack_limit, "stack size must be positive" );
+        // Size of the stack free part
+        stack_size = size_t((char*)stack_base - (char*)stack_limit);
+    }
+#endif
+
     pthread_attr_t  np_attr_stack;
-    if( 0 == pthread_getattr_np(pthread_self(), &np_attr_stack) ) {
+    if( !stack_limit && 0 == pthread_getattr_np(pthread_self(), &np_attr_stack) ) {
         if ( 0 == pthread_attr_getstack(&np_attr_stack, &stack_limit, &np_stack_size) ) {
 #if __TBB_ipf
             pthread_attr_t  attr_stack;
@@ -207,6 +229,8 @@ void generic_scheduler::init_stack_info () {
             // IA-64 architecture stack is split into RSE backup and memory parts
             my_rsb_stealing_threshold = (uintptr_t)((char*)rsb_base + stack_size/2);
 #endif /* __TBB_ipf */
+            // TODO: pthread_attr_getstack cannot be used with Intel(R) Cilk(TM) Plus
+            // __TBB_ASSERT( (uintptr_t)stack_base > (uintptr_t)stack_limit, "stack size must be positive" );
             // Size of the stack free part
             stack_size = size_t((char*)stack_base - (char*)stack_limit);
         }
@@ -258,8 +282,23 @@ void generic_scheduler::cleanup_local_context_list () {
 }
 #endif /* __TBB_TASK_GROUP_CONTEXT */
 
-void generic_scheduler::free_scheduler() {
+void generic_scheduler::destroy() {
+    __TBB_ASSERT(my_small_task_count == 0, "The scheduler is still in use.");
+    this->~generic_scheduler();
+#if TBB_USE_DEBUG
+    memset((void*)this, -1, sizeof(generic_scheduler));
+#endif
+    NFS_Free(this);
+}
+
+void generic_scheduler::cleanup_scheduler() {
     __TBB_ASSERT( !my_arena_slot, NULL );
+#if __TBB_TASK_PRIORITY
+    __TBB_ASSERT( my_offloaded_tasks == NULL, NULL );
+#endif
+#if __TBB_PREVIEW_CRITICAL_TASKS
+    __TBB_ASSERT( !my_properties.has_taken_critical_task, "Critical tasks miscount." );
+#endif
 #if __TBB_TASK_GROUP_CONTEXT
     cleanup_local_context_list();
 #endif /* __TBB_TASK_GROUP_CONTEXT */
@@ -292,7 +331,7 @@ void generic_scheduler::free_scheduler() {
     __TBB_ASSERT( my_small_task_count>=k, "my_small_task_count corrupted" );
     governor::sign_off(this);
     if( __TBB_FetchAndAddW( &my_small_task_count, -k )==k )
-        NFS_Free( this );
+        destroy();
 }
 
 task& generic_scheduler::allocate_task( size_t number_of_bytes,
@@ -393,7 +432,7 @@ void generic_scheduler::free_nonlocal_small_task( task& t ) {
     if( __TBB_FetchAndDecrementWrelease( &s.my_small_task_count )==1 ) {
         // We freed the last task allocated by scheduler s, so it's our responsibility
         // to free the scheduler.
-        NFS_Free( &s );
+        s.destroy();
     }
 }
 
@@ -584,13 +623,31 @@ inline task* generic_scheduler::prepare_for_spawning( task* t ) {
 #endif /* __TBB_TASK_PRIORITY */
         __TBB_ISOLATION_EXPR( proxy.prefix().isolation = isolation );
         ITT_NOTIFY( sync_releasing, proxy.outbox );
-        // Mail the proxy - after this point t may be destroyed by another thread at any moment.
-        proxy.outbox->push(&proxy);
-        return &proxy;
+        // Mail the proxy, if success, it may be destroyed by another thread at any moment after this point.
+        if ( proxy.outbox->push(&proxy) )
+            return &proxy;
+        // The mailbox is overfilled, deallocate the proxy and return the initial task.
+        free_task<small_task>(proxy);
     }
     return t;
 }
 
+#if __TBB_PREVIEW_CRITICAL_TASKS
+bool generic_scheduler::handled_as_critical( task& t ) {
+    if( !internal::is_critical( t ) )
+        return false;
+#if __TBB_TASK_ISOLATION
+    t.prefix().isolation = my_innermost_running_task->prefix().isolation;
+#endif
+    ITT_NOTIFY(sync_releasing, &my_arena->my_critical_task_stream);
+    __TBB_ASSERT( my_arena, "Must be attached to the arena." );
+    __TBB_ASSERT( my_arena_slot, "Must occupy a slot in the attached arena" );
+    my_arena->my_critical_task_stream.push(
+        &t, 0, tbb::internal::subsequent_lane_selector(my_arena_slot->hint_for_critical) );
+    return true;
+}
+#endif /* __TBB_PREVIEW_CRITICAL_TASKS */
+
 /** Conceptually, this method should be a member of class scheduler.
     But doing so would force us to publish class scheduler in the headers. */
 void generic_scheduler::local_spawn( task* first, task*& next ) {
@@ -609,9 +666,16 @@ void generic_scheduler::local_spawn( task* first, task*& next ) {
         // change the implementation of the task_list class). But since such changes
         // may affect the binary compatibility, we postpone them for a while.
 #endif
-        size_t T = prepare_task_pool( 1 );
-        my_arena_slot->task_pool_ptr[T] = prepare_for_spawning( first );
-        commit_spawned_tasks( T + 1 );
+#if __TBB_PREVIEW_CRITICAL_TASKS
+        if( !handled_as_critical( *first ) )
+#endif
+        {
+            size_t T = prepare_task_pool( 1 );
+            my_arena_slot->task_pool_ptr[T] = prepare_for_spawning( first );
+            commit_spawned_tasks( T + 1 );
+            if ( !is_task_pool_published() )
+                publish_task_pool();
+        }
     }
     else {
         // Task list is being spawned
@@ -634,17 +698,21 @@ void generic_scheduler::local_spawn( task* first, task*& next ) {
             // So milk it while it is alive.
             bool end = &t->prefix().next == &next;
             t_next = t->prefix().next;
-            tasks.push_back( prepare_for_spawning(t) );
+#if __TBB_PREVIEW_CRITICAL_TASKS
+            if( !handled_as_critical( *t ) )
+#endif
+                tasks.push_back( prepare_for_spawning(t) );
             if( end )
                 break;
         }
-        size_t num_tasks = tasks.size();
-        size_t T = prepare_task_pool( num_tasks );
-        tasks.copy_memory( my_arena_slot->task_pool_ptr + T );
-        commit_spawned_tasks( T + num_tasks );
+        if( size_t num_tasks = tasks.size() ) {
+            size_t T = prepare_task_pool( num_tasks );
+            tasks.copy_memory( my_arena_slot->task_pool_ptr + T );
+            commit_spawned_tasks( T + num_tasks );
+            if ( !is_task_pool_published() )
+                publish_task_pool();
+        }
     }
-    if ( !is_task_pool_published() )
-        publish_task_pool();
     my_arena->advertise_new_work<arena::work_spawned>();
     assert_task_pool_valid();
 }
@@ -920,7 +988,6 @@ inline task* generic_scheduler::get_task( size_t T )
         GATHER_STATISTIC( ++my_counters.proxies_executed );
         // Following assertion should be true because TBB 2.0 tasks never specify affinity, and hence are not proxied.
         __TBB_ASSERT( is_version_3_task( *t ), "backwards compatibility with TBB 2.0 broken" );
-        __TBB_ASSERT( my_innermost_running_task != t, NULL );
         my_innermost_running_task = t; // prepare for calling note_affinity()
 #if __TBB_TASK_ISOLATION
         // Task affinity has changed. Postpone calling note_affinity because the task pool is in invalid state.
@@ -1039,7 +1106,42 @@ inline task* generic_scheduler::get_task( __TBB_ISOLATION_EXPR( isolation_tag is
     return result;
 } // generic_scheduler::get_task
 
-task* generic_scheduler::steal_task( __TBB_ISOLATION_ARG( arena_slot& victim_slot, isolation_tag isolation ) ) {
+task* generic_scheduler::steal_task( __TBB_ISOLATION_EXPR(isolation_tag isolation) ) {
+    // Try to steal a task from a random victim.
+    size_t k = my_random.get() % (my_arena->my_limit-1);
+    arena_slot* victim = &my_arena->my_slots[k];
+    // The following condition excludes the master that might have
+    // already taken our previous place in the arena from the list .
+    // of potential victims. But since such a situation can take
+    // place only in case of significant oversubscription, keeping
+    // the checks simple seems to be preferable to complicating the code.
+    if( k >= my_arena_index )
+        ++victim;               // Adjusts random distribution to exclude self
+    task **pool = victim->task_pool;
+    task *t = NULL;
+    if( pool == EmptyTaskPool || !(t = steal_task_from( __TBB_ISOLATION_ARG(*victim, isolation) )) )
+        return NULL;
+    if( is_proxy(*t) ) {
+        task_proxy &tp = *(task_proxy*)t;
+        t = tp.extract_task<task_proxy::pool_bit>();
+        if ( !t ) {
+            // Proxy was empty, so it's our responsibility to free it
+            free_task<no_cache_small_task>(tp);
+            return NULL;
+        }
+        GATHER_STATISTIC( ++my_counters.proxies_stolen );
+    }
+    t->prefix().extra_state |= es_task_is_stolen;
+    if( is_version_3_task(*t) ) {
+        my_innermost_running_task = t;
+        t->prefix().owner = this;
+        t->note_affinity( my_affinity_id );
+    }
+    GATHER_STATISTIC( ++my_counters.steals_committed );
+    return t;
+}
+
+task* generic_scheduler::steal_task_from( __TBB_ISOLATION_ARG( arena_slot& victim_slot, isolation_tag isolation ) ) {
     task** victim_pool = lock_task_pool( &victim_slot );
     if ( !victim_pool )
         return NULL;
@@ -1072,7 +1174,7 @@ task* generic_scheduler::steal_task( __TBB_ISOLATION_ARG( arena_slot& victim_slo
                     break;
                 GATHER_STATISTIC( ++my_counters.proxies_bypassed );
             }
-            // The task cannot be executed either due to isolation or proxy contraints.
+            // The task cannot be executed either due to isolation or proxy constraints.
             result = NULL;
             tasks_omitted = true;
         } else if ( !tasks_omitted ) {
@@ -1104,6 +1206,31 @@ task* generic_scheduler::steal_task( __TBB_ISOLATION_ARG( arena_slot& victim_slo
     return result;
 }
 
+#if __TBB_PREVIEW_CRITICAL_TASKS
+// Retrieves critical task respecting isolation level, if provided. The rule is:
+// 1) If no outer critical task and no isolation => take any critical task
+// 2) If working on an outer critical task and no isolation => cannot take any critical task
+// 3) If no outer critical task but isolated => respect isolation
+// 4) If working on an outer critical task and isolated => respect isolation
+task* generic_scheduler::get_critical_task( __TBB_ISOLATION_EXPR(isolation_tag isolation) ) {
+    __TBB_ASSERT( my_arena && my_arena_slot, "Must be attached to arena" );
+    if( my_arena->my_critical_task_stream.empty(0) )
+        return NULL;
+    task* critical_task = NULL;
+    // To keep some LIFO-ness, start search with the lane that was used during push operation.
+    unsigned& start_lane = my_arena_slot->hint_for_critical;
+#if __TBB_TASK_ISOLATION
+    if( isolation != no_isolation ) {
+        critical_task = my_arena->my_critical_task_stream.pop_specific( 0, start_lane, isolation );
+    } else
+#endif
+    if( !my_properties.has_taken_critical_task ) {
+        critical_task = my_arena->my_critical_task_stream.pop( 0, preceding_lane_selector(start_lane) );
+    }
+    return critical_task;
+}
+#endif
+
 task* generic_scheduler::get_mailbox_task( __TBB_ISOLATION_EXPR( isolation_tag isolation ) ) {
     __TBB_ASSERT( my_affinity_id>0, "not in arena" );
     while ( task_proxy* const tp = my_inbox.pop( __TBB_ISOLATION_EXPR( isolation ) ) ) {
@@ -1143,14 +1270,15 @@ inline void generic_scheduler::leave_task_pool() {
     __TBB_store_relaxed( my_arena_slot->task_pool, EmptyTaskPool );
 }
 
-generic_scheduler* generic_scheduler::create_worker( market& m, size_t index ) {
-    generic_scheduler* s = allocate_scheduler( m );
-    __TBB_ASSERT(index, "workers should have index > 0");
+generic_scheduler* generic_scheduler::create_worker( market& m, size_t index, bool genuine ) {
+    generic_scheduler* s = allocate_scheduler( m, genuine );
+    __TBB_ASSERT(!genuine || index, "workers should have index > 0");
     s->my_arena_index = index; // index is not a real slot in arena yet
     s->my_dummy_task->prefix().ref_count = 2;
     s->my_properties.type = scheduler_properties::worker;
     // Do not call init_stack_info before the scheduler is set as master or worker.
-    s->init_stack_info();
+    if (genuine)
+        s->init_stack_info();
     governor::sign_on(s);
     return s;
 }
@@ -1158,7 +1286,7 @@ generic_scheduler* generic_scheduler::create_worker( market& m, size_t index ) {
 // TODO: make it a member method
 generic_scheduler* generic_scheduler::create_master( arena* a ) {
     // add an internal market reference; the public reference is possibly added in create_arena
-    generic_scheduler* s = allocate_scheduler( market::global_market(/*is_public=*/false) );
+    generic_scheduler* s = allocate_scheduler( market::global_market(/*is_public=*/false), /* genuine = */ true );
     __TBB_ASSERT( !s->my_arena, NULL );
     __TBB_ASSERT( s->my_market, NULL );
     task& t = *s->my_dummy_task;
@@ -1177,10 +1305,12 @@ generic_scheduler* generic_scheduler::create_master( arena* a ) {
     lock.release();
 #endif /* __TBB_TASK_GROUP_CONTEXT */
     if( a ) {
-    // Master thread always occupies the first slot
+        // Master thread always occupies the first slot
         s->attach_arena( a, /*index*/0, /*is_master*/true );
-    s->my_arena_slot->my_scheduler = s;
+        s->my_arena_slot->my_scheduler = s;
+#if __TBB_TASK_GROUP_CONTEXT
         a->my_default_ctx = s->default_context(); // also transfers implied ownership
+#endif
     }
     __TBB_ASSERT( s->my_arena_index == 0, "Master thread must occupy the first slot in its arena" );
     governor::sign_on(s);
@@ -1205,7 +1335,7 @@ void generic_scheduler::cleanup_worker( void* arg, bool worker ) {
     if ( worker ) // can be called by master for worker, do not notify master twice
         the_global_observer_list.notify_exit_observers( s.my_last_global_observer, /*worker=*/true );
 #endif /* __TBB_SCHEDULER_OBSERVER */
-    s.free_scheduler();
+    s.cleanup_scheduler();
 }
 
 bool generic_scheduler::cleanup_master( bool blocking_terminate ) {
@@ -1224,6 +1354,8 @@ bool generic_scheduler::cleanup_master( bool blocking_terminate ) {
             // Master's local task pool may e.g. contain proxies of affinitized tasks.
             release_task_pool();
             __TBB_ASSERT ( governor::is_set(this), "TLS slot is cleared before the task pool cleanup" );
+            // Set refcount to make the following dispach loop infinite (it is interrupted by the cleanup logic).
+            my_dummy_task->set_ref_count(2);
             local_wait_for_all( *my_dummy_task, NULL );
             __TBB_ASSERT( !is_task_pool_published(), NULL );
             __TBB_ASSERT ( governor::is_set(this), "Other thread reused our TLS key during the task pool cleanup" );
@@ -1256,7 +1388,7 @@ bool generic_scheduler::cleanup_master( bool blocking_terminate ) {
     lock.release();
 #endif /* __TBB_TASK_GROUP_CONTEXT */
     my_arena_slot = NULL; // detached from slot
-    free_scheduler(); // do not use scheduler state after this point
+    cleanup_scheduler(); // do not use scheduler state after this point
 
     if( a )
         a->on_thread_leaving<arena::ref_external>();
diff --git a/src/tbb/src/tbb/scheduler.h b/src/tbb/src/tbb/scheduler.h
index 8dda929f..eff182d5 100644
--- a/src/tbb/src/tbb/scheduler.h
+++ b/src/tbb/src/tbb/scheduler.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef _TBB_scheduler_H
@@ -34,6 +30,10 @@
 #include "cilk-tbb-interop.h"
 #endif /* __TBB_SURVIVE_THREAD_SWITCH */
 
+#if __TBB_PREVIEW_RESUMABLE_TASKS
+#include "co_context.h"
+#endif
+
 namespace tbb {
 namespace internal {
 
@@ -55,8 +55,23 @@ struct scheduler_properties {
     //! Indicates that a scheduler is on outermost level.
     /**  Note that the explicit execute method will set this property. **/
     bool outermost : 1;
+#if __TBB_PREVIEW_CRITICAL_TASKS
+    //! Indicates that a scheduler is in the process of executing critical task(s).
+    bool has_taken_critical_task : 1;
+#endif
+#if __TBB_PREVIEW_RESUMABLE_TASKS
+    //! Indicates that the scheduler is bound to an original thread stack.
+    bool genuine : 1;
+#endif
     //! Reserved bits
-    unsigned char : 6;
+    unsigned char :
+#if __TBB_PREVIEW_RESUMABLE_TASKS
+                    4;
+#elif __TBB_PREVIEW_CRITICAL_TASKS
+                    5;
+#else
+                    6;
+#endif
 };
 
 struct scheduler_state {
@@ -103,6 +118,13 @@ struct scheduler_state {
     //! Pointer to market's (for workers) or current arena's (for the master) reload epoch counter.
     volatile uintptr_t *my_ref_reload_epoch;
 #endif /* __TBB_TASK_PRIORITY */
+#if __TBB_PREVIEW_RESUMABLE_TASKS
+    //! The currently waited task.
+    task* my_wait_task;
+
+    //! The currently recalled stack.
+    tbb::atomic<bool>* my_current_is_recalled;
+#endif
 };
 
 //! Work stealing task scheduler.
@@ -110,7 +132,7 @@ struct scheduler_state {
     the thread that creates the instance.
 
     Class generic_scheduler is an abstract base class that contains most of the scheduler,
-    except for tweaks specific to processors and tools (e.g. VTune).
+    except for tweaks specific to processors and tools (e.g. VTune(TM) Performance Tools).
     The derived template class custom_scheduler<SchedulerTraits> fills in the tweaks. */
 class generic_scheduler: public scheduler
                        , public ::rml::job
@@ -122,7 +144,11 @@ class generic_scheduler: public scheduler
     static const size_t quick_task_size = 256-task_prefix_reservation_size;
 
     static bool is_version_3_task( task& t ) {
+#if __TBB_PREVIEW_CRITICAL_TASKS
+        return (t.prefix().extra_state & 0x7)>=0x1;
+#else
         return (t.prefix().extra_state & 0x0F)>=0x1;
+#endif
     }
 
     //! Position in the call stack specifying its maximal filling when stealing is still allowed
@@ -175,6 +201,68 @@ class generic_scheduler: public scheduler
     intptr_t my_task_node_count;
 #endif /* __TBB_COUNT_TASK_NODES */
 
+#if __TBB_PREVIEW_RESUMABLE_TASKS
+    //! The list of possible post resume actions.
+    enum post_resume_action {
+        PRA_INVALID,
+        PRA_ABANDON,
+        PRA_CALLBACK,
+        PRA_CLEANUP,
+        PRA_NOTIFY,
+        PRA_NONE
+    };
+
+    //! The suspend callback function type.
+    typedef void(*suspend_callback_t)(void*, task::suspend_point);
+
+    //! The callback to call the user callback passed to tbb::suspend.
+    struct callback_t {
+        suspend_callback_t suspend_callback;
+        void* user_callback;
+        task::suspend_point tag;
+
+        void operator()() {
+            if (suspend_callback) {
+                __TBB_ASSERT(suspend_callback && user_callback && tag, NULL);
+                suspend_callback(user_callback, tag);
+            }
+        }
+    };
+
+    //! The coroutine context associated with the current scheduler.
+    co_context my_co_context;
+
+    //! The post resume action requested for the current scheduler.
+    post_resume_action my_post_resume_action;
+
+    //! The post resume action argument.
+    void* my_post_resume_arg;
+
+    //! The scheduler to resume on exit.
+    generic_scheduler* my_target_on_exit;
+
+    //! Set post resume action to perform after resume.
+    void set_post_resume_action(post_resume_action, void* arg);
+
+    //! Performs post resume action.
+    void do_post_resume_action();
+
+    //! Decides how to switch and sets post resume action.
+    /** Returns false if the caller should finish the coroutine and then resume the target scheduler.
+        Returns true if the caller should resume the target scheduler immediately. **/
+    bool prepare_resume(generic_scheduler& target);
+
+    //! Resumes the original scheduler of the calling thread.
+    /** Returns false if the current stack should be left to perform the resume.
+        Returns true if the current stack is resumed. **/
+    bool resume_original_scheduler();
+
+    //! Resumes the target scheduler. The prepare_resume must be called for the target scheduler in advance.
+    void resume(generic_scheduler& target);
+
+    friend void recall_function(task::suspend_point tag);
+#endif /* __TBB_PREVIEW_RESUMABLE_TASKS */
+
     //! Sets up the data necessary for the stealing limiting heuristics
     void init_stack_info ();
 
@@ -261,8 +349,20 @@ class generic_scheduler: public scheduler
         return t.prefix().extra_state==es_task_proxy;
     }
 
+    //! Attempts to steal a task from a randomly chosen thread/scheduler
+    task* steal_task( __TBB_ISOLATION_EXPR(isolation_tag isolation) );
+
     //! Steal task from another scheduler's ready pool.
-    task* steal_task( __TBB_ISOLATION_ARG( arena_slot& victim_arena_slot, isolation_tag isolation ) );
+    task* steal_task_from( __TBB_ISOLATION_ARG( arena_slot& victim_arena_slot, isolation_tag isolation ) );
+
+#if __TBB_PREVIEW_CRITICAL_TASKS
+    //! Tries to find critical task in critical task stream
+    task* get_critical_task( __TBB_ISOLATION_EXPR(isolation_tag isolation) );
+
+    //! Pushes task to critical task stream if it appears to be such task and returns
+    //! true. Otherwise does nothing and returns false.
+    bool handled_as_critical( task& t );
+#endif
 
     /** Initial size of the task deque sufficient to serve without reallocation
         4 nested parallel_for calls with iteration space of 65535 grains each. **/
@@ -280,14 +380,14 @@ class generic_scheduler: public scheduler
     bool cleanup_master( bool blocking_terminate );
 
     //! Initialize a scheduler for a worker thread.
-    static generic_scheduler* create_worker( market& m, size_t index );
+    static generic_scheduler* create_worker( market& m, size_t index, bool geniune );
 
     //! Perform necessary cleanup when a worker thread finishes.
     static void cleanup_worker( void* arg, bool worker );
 
 protected:
     template<typename SchedulerTraits> friend class custom_scheduler;
-    generic_scheduler( market & );
+    generic_scheduler( market &, bool );
 
 public:
 #if TBB_USE_ASSERT > 1
@@ -313,8 +413,11 @@ class generic_scheduler: public scheduler
     void local_spawn_root_and_wait( task* first, task*& next );
     virtual void local_wait_for_all( task& parent, task* child ) = 0;
 
-    //! Destroy and deallocate this scheduler object
-    void free_scheduler();
+    //! Destroy and deallocate this scheduler object.
+    void destroy();
+
+    //! Cleans up this scheduler (the scheduler might be destroyed).
+    void cleanup_scheduler();
 
     //! Allocate task object, either from the heap or a free list.
     /** Returns uninitialized task object with initialized prefix. */
@@ -639,7 +742,11 @@ void generic_scheduler::free_task( task& t ) {
     poison_value(p.depth);
     poison_value(p.ref_count);
     poison_pointer(p.owner);
-    __TBB_ASSERT( 1L<<t.state() & (1L<<task::executing|1L<<task::allocated), NULL );
+#if __TBB_PREVIEW_RESUMABLE_TASKS
+    __TBB_ASSERT(1L << t.state() & (1L << task::executing | 1L << task::allocated | 1 << task::to_resume), NULL);
+#else
+    __TBB_ASSERT(1L << t.state() & (1L << task::executing | 1L << task::allocated), NULL);
+#endif
     p.state = task::freed;
     if( h==small_local_task || p.origin==this ) {
         GATHER_STATISTIC(++my_counters.free_list_length);
@@ -672,11 +779,7 @@ inline intptr_t generic_scheduler::effective_reference_priority () const {
     // be trapped in a futile spinning (because market's priority would prohibit
     // executing ANY tasks in this arena).
     return !worker_outermost_level() ||
-        (my_arena->my_num_workers_allotted < my_arena->num_workers_active()
-#if __TBB_ENQUEUE_ENFORCED_CONCURRENCY
-         && my_arena->my_concurrency_mode!=arena_base::cm_enforced_global
-#endif
-            ) ? *my_ref_top_priority : my_arena->my_top_priority;
+        my_arena->my_num_workers_allotted < my_arena->num_workers_active() ? *my_ref_top_priority : my_arena->my_top_priority;
 }
 
 inline void generic_scheduler::offload_task ( task& t, intptr_t /*priority*/ ) {
@@ -691,40 +794,232 @@ inline void generic_scheduler::offload_task ( task& t, intptr_t /*priority*/ ) {
 }
 #endif /* __TBB_TASK_PRIORITY */
 
+#if __TBB_PREVIEW_RESUMABLE_TASKS
+inline void generic_scheduler::set_post_resume_action(post_resume_action pra, void* arg) {
+    __TBB_ASSERT(my_post_resume_action == PRA_NONE, "Post resume action has already been set.");
+    __TBB_ASSERT(!my_post_resume_arg, NULL);
+
+    my_post_resume_action = pra;
+    my_post_resume_arg = arg;
+}
+
+inline bool generic_scheduler::prepare_resume(generic_scheduler& target) {
+    // The second condition is valid for worker or cleanup operation for master
+    if (my_properties.outermost && my_wait_task == my_dummy_task) {
+        if (my_properties.genuine) {
+            // We are in someone's original scheduler.
+            target.set_post_resume_action(PRA_NOTIFY, my_current_is_recalled);
+            return true;
+        }
+        // We are in a coroutine on outermost level.
+        target.set_post_resume_action(PRA_CLEANUP, this);
+        my_target_on_exit = &target;
+        // Request to finish coroutine instead of immediate resume.
+        return false;
+    }
+    __TBB_ASSERT(my_wait_task != my_dummy_task, NULL);
+    // We are in the coroutine on a nested level.
+    my_wait_task->prefix().abandoned_scheduler = this;
+    target.set_post_resume_action(PRA_ABANDON, my_wait_task);
+    return true;
+}
+
+inline bool generic_scheduler::resume_original_scheduler() {
+    generic_scheduler& target = *my_arena_slot->my_scheduler;
+    if (!prepare_resume(target)) {
+        // We should return and finish the current coroutine.
+        return false;
+    }
+    resume(target);
+    return true;
+}
+
+inline void generic_scheduler::resume(generic_scheduler& target) {
+    // Do not create non-trivial objects on the stack of this function. They might never be destroyed.
+    __TBB_ASSERT(governor::is_set(this), NULL);
+    __TBB_ASSERT(target.my_post_resume_action != PRA_NONE,
+        "The post resume action is not set. Has prepare_resume been called?");
+    __TBB_ASSERT(target.my_post_resume_arg, NULL);
+    __TBB_ASSERT(&target != this, NULL);
+    __TBB_ASSERT(target.my_arena == my_arena, "Cross-arena switch is forbidden.");
+
+    // Transfer thread related data.
+    target.my_arena_index = my_arena_index;
+    target.my_arena_slot = my_arena_slot;
+#if __TBB_SCHEDULER_OBSERVER
+    target.my_last_global_observer = my_last_global_observer;
+#endif
+#if __TBB_ARENA_OBSERVER
+    target.my_last_local_observer = my_last_local_observer;
+#endif
+    target.attach_mailbox(affinity_id(target.my_arena_index + 1));
+
+#if __TBB_TASK_PRIORITY
+    if (my_offloaded_tasks)
+        my_arena->orphan_offloaded_tasks(*this);
+#endif /* __TBB_TASK_PRIORITY */
+
+    governor::assume_scheduler(&target);
+    my_co_context.resume(target.my_co_context);
+    __TBB_ASSERT(governor::is_set(this), NULL);
+
+    do_post_resume_action();
+    if (this == my_arena_slot->my_scheduler) {
+        my_arena_slot->my_scheduler_is_recalled->store<tbb::relaxed>(false);
+    }
+}
+
+inline void generic_scheduler::do_post_resume_action() {
+    __TBB_ASSERT(my_post_resume_action != PRA_NONE, "The post resume action is not set.");
+    __TBB_ASSERT(my_post_resume_arg, NULL);
+
+    switch (my_post_resume_action) {
+    case PRA_ABANDON:
+    {
+        task_prefix& wait_task_prefix = static_cast<task*>(my_post_resume_arg)->prefix();
+        reference_count old_ref_count = __TBB_FetchAndAddW(&wait_task_prefix.ref_count, internal::abandon_flag);
+        __TBB_ASSERT(old_ref_count > 0, NULL);
+        if (old_ref_count == 1) {
+            // Remove the abandon flag.
+            __TBB_store_with_release(wait_task_prefix.ref_count, 1);
+            // The wait has been completed. Spawn a resume task.
+            tbb::task::resume(wait_task_prefix.abandoned_scheduler);
+        }
+        break;
+    }
+    case PRA_CALLBACK:
+    {
+        callback_t callback = *static_cast<callback_t*>(my_post_resume_arg);
+        callback();
+        break;
+    }
+    case PRA_CLEANUP:
+    {
+        generic_scheduler* to_cleanup = static_cast<generic_scheduler*>(my_post_resume_arg);
+        __TBB_ASSERT(!to_cleanup->my_properties.genuine, NULL);
+        // Release coroutine's reference to my_arena.
+        to_cleanup->my_arena->on_thread_leaving<arena::ref_external>();
+        // Cache the coroutine for possible later re-usage
+        to_cleanup->my_arena->my_co_cache.push(to_cleanup);
+        break;
+    }
+    case PRA_NOTIFY:
+    {
+        tbb::atomic<bool>& scheduler_recall_flag = *static_cast<tbb::atomic<bool>*>(my_post_resume_arg);
+        scheduler_recall_flag = true;
+        // Do not access recall_flag because it can be destroyed after the notification.
+        break;
+    }
+    default:
+        __TBB_ASSERT(false, NULL);
+    }
+
+    my_post_resume_action = PRA_NONE;
+    my_post_resume_arg = NULL;
+}
+
+struct recall_functor {
+    tbb::atomic<bool>* scheduler_recall_flag;
+
+    recall_functor(tbb::atomic<bool>* recall_flag_) :
+        scheduler_recall_flag(recall_flag_) {}
+
+    void operator()(task::suspend_point /*tag*/) {
+        *scheduler_recall_flag = true;
+    }
+};
+
+#if _WIN32
+/* [[noreturn]] */ inline void __stdcall co_local_wait_for_all(void* arg) {
+#else
+/* [[noreturn]] */ inline void co_local_wait_for_all(void* arg) {
+#endif
+    // Do not create non-trivial objects on the stack of this function. They will never be destroyed.
+    generic_scheduler& s = *static_cast<generic_scheduler*>(arg);
+    __TBB_ASSERT(governor::is_set(&s), NULL);
+    // For correct task stealing threshold, calculate stack on a coroutine start
+    s.init_stack_info();
+    // Basically calls the user callback passed to the tbb::task::suspend function
+    s.do_post_resume_action();
+    // Endless loop here because coroutine could be reused
+    for( ;; ) {
+        __TBB_ASSERT(s.my_innermost_running_task == s.my_dummy_task, NULL);
+        __TBB_ASSERT(s.worker_outermost_level(), NULL);
+        s.local_wait_for_all(*s.my_dummy_task, NULL);
+        __TBB_ASSERT(s.my_target_on_exit, NULL);
+        __TBB_ASSERT(s.my_wait_task == NULL, NULL);
+        s.resume(*s.my_target_on_exit);
+    }
+    // This code is unreachable
+}
+#endif /* __TBB_PREVIEW_RESUMABLE_TASKS */
+
+#if __TBB_TASK_GROUP_CONTEXT
+//! Helper class for tracking floating point context and task group context switches
+/** Assuming presence of an itt collector, in addition to keeping track of floating
+    point context, this class emits itt events to indicate begin and end of task group
+    context execution **/
+template <bool report_tasks>
+class context_guard_helper {
+    const task_group_context *curr_ctx;
 #if __TBB_FP_CONTEXT
-class cpu_ctl_env_helper {
     cpu_ctl_env guard_cpu_ctl_env;
     cpu_ctl_env curr_cpu_ctl_env;
+#endif
 public:
-    cpu_ctl_env_helper() {
+    context_guard_helper() : curr_ctx( NULL ) {
+#if __TBB_FP_CONTEXT
         guard_cpu_ctl_env.get_env();
         curr_cpu_ctl_env = guard_cpu_ctl_env;
+#endif
     }
-    ~cpu_ctl_env_helper() {
+    ~context_guard_helper() {
+#if __TBB_FP_CONTEXT
         if ( curr_cpu_ctl_env != guard_cpu_ctl_env )
             guard_cpu_ctl_env.set_env();
+#endif
+        if ( report_tasks && curr_ctx )
+            ITT_TASK_END;
     }
-    void set_env( const task_group_context *ctx ) {
-        generic_scheduler::assert_context_valid(ctx);
-        const cpu_ctl_env &ctl = *punned_cast<cpu_ctl_env*>(&ctx->my_cpu_ctl_env);
+    // The function is called from bypass dispatch loop on the hot path.
+    // Consider performance issues when refactoring.
+    void set_ctx( const task_group_context *ctx ) {
+        generic_scheduler::assert_context_valid( ctx );
+#if __TBB_FP_CONTEXT
+        const cpu_ctl_env &ctl = *punned_cast<cpu_ctl_env*>( &ctx->my_cpu_ctl_env );
+        // Compare the FPU settings directly because the context can be reused between parallel algorithms.
         if ( ctl != curr_cpu_ctl_env ) {
             curr_cpu_ctl_env = ctl;
             curr_cpu_ctl_env.set_env();
         }
+#endif
+        if ( report_tasks && ctx != curr_ctx ) {
+            // if task group context was active, report end of current execution frame.
+            if ( curr_ctx )
+                ITT_TASK_END;
+            // reporting begin of new task group context execution frame.
+            // using address of task group context object to group tasks (parent).
+            // id of task execution frame is NULL and reserved for future use.
+            ITT_TASK_BEGIN( ctx,ctx->my_name, NULL );
+            curr_ctx = ctx;
+        }
     }
     void restore_default() {
+#if __TBB_FP_CONTEXT
         if ( curr_cpu_ctl_env != guard_cpu_ctl_env ) {
             guard_cpu_ctl_env.set_env();
             curr_cpu_ctl_env = guard_cpu_ctl_env;
         }
+#endif
     }
 };
 #else
-struct cpu_ctl_env_helper {
-    void set_env( __TBB_CONTEXT_ARG1(task_group_context *) ) {}
+template <bool T>
+struct context_guard_helper {
+    void set_ctx() {}
     void restore_default() {}
 };
-#endif /* __TBB_FP_CONTEXT */
+#endif /* __TBB_TASK_GROUP_CONTEXT */
 
 } // namespace internal
 } // namespace tbb
diff --git a/src/tbb/src/tbb/scheduler_common.h b/src/tbb/src/tbb/scheduler_common.h
index 02a39d25..60a03798 100644
--- a/src/tbb/src/tbb/scheduler_common.h
+++ b/src/tbb/src/tbb/scheduler_common.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef _TBB_scheduler_common_H
@@ -168,6 +164,10 @@ enum task_extra_state {
     es_version_1_task = 0,
     //! Tag for v3 tasks (i.e. tasks in TBB 2.1-2.2)
     es_version_3_task = 1,
+#if __TBB_PREVIEW_CRITICAL_TASKS
+    //! Tag for critical tasks
+    es_task_critical = 0x8,
+#endif
     //! Tag for enqueued tasks
     es_task_enqueued = 0x10,
     //! Tag for v3 task_proxy.
@@ -220,6 +220,7 @@ inline void assert_task_valid( const task* task ) {
     __TBB_ASSERT( task!=NULL, NULL );
     __TBB_ASSERT( !is_poisoned(&task), NULL );
     __TBB_ASSERT( (uintptr_t)task % task_alignment == 0, "misaligned task" );
+    __TBB_ASSERT( task->prefix().ref_count >= 0, NULL);
 #if __TBB_RECYCLE_TO_ENQUEUE
     __TBB_ASSERT( (unsigned)task->state()<=(unsigned)task::to_enqueue, "corrupt task (invalid state)" );
 #else
@@ -340,6 +341,11 @@ struct arena_slot_line1 {
     //! Index of the first ready task in the deque.
     /** Modified by thieves, and by the owner during compaction/reallocation **/
     __TBB_atomic size_t head;
+
+#if __TBB_PREVIEW_RESUMABLE_TASKS
+    //! The flag is raised when the original owner of the scheduler should return to this scheduler (for resume).
+    tbb::atomic<bool>* my_scheduler_is_recalled;
+#endif
 };
 
 struct arena_slot_line2 {
@@ -347,6 +353,11 @@ struct arena_slot_line2 {
     /** Modified by the owner thread (during these operations). **/
     unsigned hint_for_pop;
 
+#if __TBB_PREVIEW_CRITICAL_TASKS
+    //! Similar to 'hint_for_pop' but for critical tasks.
+    unsigned hint_for_critical;
+#endif
+
     //! Index of the element following the last ready task in the deque.
     /** Modified by the owner thread. **/
     __TBB_atomic size_t tail;
@@ -354,7 +365,7 @@ struct arena_slot_line2 {
     //! Capacity of the primary task pool (number of elements - pointers to task).
     size_t my_task_pool_size;
 
-    // Task pool of the scheduler that owns this slot
+    //! Task pool of the scheduler that owns this slot
     task* *__TBB_atomic task_pool_ptr;
 
 #if __TBB_STATISTICS
diff --git a/src/tbb/src/tbb/scheduler_utility.h b/src/tbb/src/tbb/scheduler_utility.h
index 5c228598..790156b5 100644
--- a/src/tbb/src/tbb/scheduler_utility.h
+++ b/src/tbb/src/tbb/scheduler_utility.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef _TBB_scheduler_utility_H
diff --git a/src/tbb/src/tbb/semaphore.cpp b/src/tbb/src/tbb/semaphore.cpp
index 4c6d8532..ae7f4d5a 100644
--- a/src/tbb/src/tbb/semaphore.cpp
+++ b/src/tbb/src/tbb/semaphore.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 "semaphore.h"
diff --git a/src/tbb/src/tbb/semaphore.h b/src/tbb/src/tbb/semaphore.h
index 43af24aa..0545b95a 100644
--- a/src/tbb/src/tbb/semaphore.h
+++ b/src/tbb/src/tbb/semaphore.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,15 +12,12 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_tbb_semaphore_H
 #define __TBB_tbb_semaphore_H
 
+#include <tbb/atomic.h>
 #include "tbb/tbb_stddef.h"
 
 #if _WIN32||_WIN64
@@ -191,6 +188,8 @@ class binary_semaphore : no_copy {
 
 #if __TBB_USE_FUTEX
 class binary_semaphore : no_copy {
+// The implementation is equivalent to the "Mutex, Take 3" one
+// in the paper "Futexes Are Tricky" by Ulrich Drepper
 public:
     //! ctor
     binary_semaphore() { my_sem = 1; }
@@ -202,7 +201,7 @@ class binary_semaphore : no_copy {
         if( (s = my_sem.compare_and_swap( 1, 0 ))!=0 ) {
             if( s!=2 )
                 s = my_sem.fetch_and_store( 2 );
-            while( s!=0 ) {
+            while( s!=0 ) { // This loop deals with spurious wakeup
                 futex_wait( &my_sem, 2 );
                 s = my_sem.fetch_and_store( 2 );
             }
@@ -211,14 +210,11 @@ class binary_semaphore : no_copy {
     //! post/release
     void V() {
         __TBB_ASSERT( my_sem>=1, "multiple V()'s in a row?" );
-        if( my_sem--!=1 ) {
-            //if old value was 2
-            my_sem = 0;
+        if( my_sem.fetch_and_store( 0 )==2 )
             futex_wakeup_one( &my_sem );
-        }
     }
 private:
-    atomic<int> my_sem;
+    atomic<int> my_sem; // 0 - open; 1 - closed, no waits; 2 - closed, possible waits
 };
 #else
 typedef uint32_t sem_count_t;
diff --git a/src/tbb/src/tbb/spin_mutex.cpp b/src/tbb/src/tbb/spin_mutex.cpp
index 6fab769a..efe1dcc1 100644
--- a/src/tbb/src/tbb/spin_mutex.cpp
+++ b/src/tbb/src/tbb/spin_mutex.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 "tbb/tbb_machine.h"
diff --git a/src/tbb/src/tbb/spin_rw_mutex.cpp b/src/tbb/src/tbb/spin_rw_mutex.cpp
index 9b14cc1c..e033f12c 100644
--- a/src/tbb/src/tbb/spin_rw_mutex.cpp
+++ b/src/tbb/src/tbb/spin_rw_mutex.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 "tbb/spin_rw_mutex.h"
diff --git a/src/tbb/src/tbb/task.cpp b/src/tbb/src/tbb/task.cpp
index 12307a91..70fdc7e1 100644
--- a/src/tbb/src/tbb/task.cpp
+++ b/src/tbb/src/tbb/task.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 // Do not include task.h directly. Use scheduler_common.h instead
@@ -31,8 +27,6 @@
 
 namespace tbb {
 
-using namespace std;
-
 namespace internal {
 
 //------------------------------------------------------------------------
diff --git a/src/tbb/src/tbb/task_group_context.cpp b/src/tbb/src/tbb/task_group_context.cpp
index 4036a666..910d54e5 100644
--- a/src/tbb/src/tbb/task_group_context.cpp
+++ b/src/tbb/src/tbb/task_group_context.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 "scheduler.h"
@@ -200,11 +196,19 @@ task_group_context::~task_group_context () {
 }
 
 void task_group_context::init () {
+#if DO_ITT_NOTIFY
+    // Check version of task group context to avoid reporting misleading identifier.
+    if( ( my_version_and_traits & version_mask ) < 3 )
+        my_name = internal::CUSTOM_CTX;
+#endif
+    ITT_TASK_GROUP(this, my_name, NULL);
     __TBB_STATIC_ASSERT ( sizeof(my_version_and_traits) >= 4, "Layout of my_version_and_traits must be reconsidered on this platform" );
     __TBB_STATIC_ASSERT ( sizeof(task_group_context) == 2 * NFS_MaxLineSize, "Context class has wrong size - check padding and members alignment" );
     __TBB_ASSERT ( (uintptr_t(this) & (sizeof(my_cancellation_requested) - 1)) == 0, "Context is improperly aligned" );
     __TBB_ASSERT ( __TBB_load_relaxed(my_kind) == isolated || __TBB_load_relaxed(my_kind) == bound, "Context can be created only as isolated or bound" );
     my_parent = NULL;
+    my_node.my_next = NULL;
+    my_node.my_prev = NULL;
     my_cancellation_requested = 0;
     my_exception = NULL;
     my_owner = NULL;
diff --git a/src/tbb/src/tbb/task_stream.h b/src/tbb/src/tbb/task_stream.h
index 0118e1b8..b4500ffa 100644
--- a/src/tbb/src/tbb/task_stream.h
+++ b/src/tbb/src/tbb/task_stream.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef _TBB_task_stream_H
diff --git a/src/tbb/src/tbb/task_stream_extended.h b/src/tbb/src/tbb/task_stream_extended.h
new file mode 100644
index 00000000..dcb08cb8
--- /dev/null
+++ b/src/tbb/src/tbb/task_stream_extended.h
@@ -0,0 +1,319 @@
+/*
+    Copyright (c) 2005-2020 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.
+*/
+
+#ifndef _TBB_task_stream_extended_H
+#define _TBB_task_stream_extended_H
+
+//! This file is a possible future replacement for the task_stream class implemented in
+//! task_stream.h. It refactors the code and extends task_stream capabilities by moving lane
+//! management during operations on caller side. Despite the fact that new implementation should not
+//! affect performance of the original task stream, analysis on this subject was not made at the
+//! time it was developed. In addition, it is not clearly seen at the moment that this container
+//! would be suitable for critical tasks due to linear time complexity on its operations.
+
+
+#if _TBB_task_stream_H
+#error Either task_stream.h or this file can be included at the same time.
+#endif
+
+#if !__TBB_CPF_BUILD
+#error This code bears a preview status until it proves its usefulness/performance suitability.
+#endif
+
+#include "tbb/tbb_stddef.h"
+#include <deque>
+#include <climits>
+#include "tbb/atomic.h" // for __TBB_Atomic*
+#include "tbb/spin_mutex.h"
+#include "tbb/tbb_allocator.h"
+#include "scheduler_common.h"
+#include "tbb_misc.h" // for FastRandom
+
+namespace tbb {
+namespace internal {
+
+//! Essentially, this is just a pair of a queue and a mutex to protect the queue.
+/** The reason std::pair is not used is that the code would look less clean
+    if field names were replaced with 'first' and 'second'. **/
+template< typename T, typename mutex_t >
+struct queue_and_mutex {
+    typedef std::deque< T, tbb_allocator<T> > queue_base_t;
+
+    queue_base_t my_queue;
+    mutex_t      my_mutex;
+
+    queue_and_mutex () : my_queue(), my_mutex() {}
+    ~queue_and_mutex () {}
+};
+
+typedef uintptr_t population_t;
+const population_t one = 1;
+
+inline void set_one_bit( population_t& dest, int pos ) {
+    __TBB_ASSERT( pos>=0, NULL );
+    __TBB_ASSERT( pos<int(sizeof(population_t)*CHAR_BIT), NULL );
+    __TBB_AtomicOR( &dest, one<<pos );
+}
+
+inline void clear_one_bit( population_t& dest, int pos ) {
+    __TBB_ASSERT( pos>=0, NULL );
+    __TBB_ASSERT( pos<int(sizeof(population_t)*CHAR_BIT), NULL );
+    __TBB_AtomicAND( &dest, ~(one<<pos) );
+}
+
+inline bool is_bit_set( population_t val, int pos ) {
+    __TBB_ASSERT( pos>=0, NULL );
+    __TBB_ASSERT( pos<int(sizeof(population_t)*CHAR_BIT), NULL );
+    return (val & (one<<pos)) != 0;
+}
+
+struct random_lane_selector :
+#if __INTEL_COMPILER == 1110 || __INTEL_COMPILER == 1500
+        no_assign
+#else
+        no_copy
+#endif
+{
+    random_lane_selector( FastRandom& random ) : my_random( random ) {}
+    unsigned operator()( unsigned out_of ) const {
+        __TBB_ASSERT( ((out_of-1) & out_of) == 0, "number of lanes is not power of two." );
+        return my_random.get() & (out_of-1);
+    }
+private:
+    FastRandom& my_random;
+};
+
+struct lane_selector_base :
+#if __INTEL_COMPILER == 1110 || __INTEL_COMPILER == 1500
+        no_assign
+#else
+        no_copy
+#endif
+{
+    unsigned& my_previous;
+    lane_selector_base( unsigned& previous ) : my_previous( previous ) {}
+};
+
+struct subsequent_lane_selector : lane_selector_base {
+    subsequent_lane_selector( unsigned& previous ) : lane_selector_base( previous ) {}
+    unsigned operator()( unsigned out_of ) const {
+        __TBB_ASSERT( ((out_of-1) & out_of) == 0, "number of lanes is not power of two." );
+        return (++my_previous &= out_of-1);
+    }
+};
+
+struct preceding_lane_selector : lane_selector_base {
+    preceding_lane_selector( unsigned& previous ) : lane_selector_base( previous ) {}
+    unsigned operator()( unsigned out_of ) const {
+        __TBB_ASSERT( ((out_of-1) & out_of) == 0, "number of lanes is not power of two." );
+        return (--my_previous &= (out_of-1));
+    }
+};
+
+class task_stream_base : no_copy {
+protected:
+    typedef queue_and_mutex <task*, spin_mutex> lane_t;
+};
+
+enum task_stream_accessor_type { front_accessor = 0, back_nonnull_accessor };
+
+//! Specializes from which side of the underlying container elements are retrieved. Method must be
+//! called under corresponding mutex locked.
+template<task_stream_accessor_type accessor>
+class task_stream_accessor : public task_stream_base {
+protected:
+    using task_stream_base::lane_t;
+    task* get_item( lane_t::queue_base_t& queue ) {
+        task* result = queue.front();
+        queue.pop_front();
+        return result;
+    }
+};
+
+template<>
+class task_stream_accessor< back_nonnull_accessor > : public task_stream_base {
+protected:
+    task* get_item( lane_t::queue_base_t& queue ) {
+        task* result = NULL;
+        do {
+            result = queue.back();
+            queue.pop_back();
+        } while( !result && !queue.empty() );
+        return result;
+    }
+};
+
+//! The container for "fairness-oriented" aka "enqueued" tasks.
+template<int Levels, task_stream_accessor_type accessor>
+class task_stream : public task_stream_accessor< accessor > {
+    typedef typename task_stream_accessor<accessor>::lane_t lane_t;
+    population_t population[Levels];
+    padded<lane_t>* lanes[Levels];
+    unsigned N;
+
+public:
+    task_stream() : N() {
+        for(int level = 0; level < Levels; level++) {
+            population[level] = 0;
+            lanes[level] = NULL;
+        }
+    }
+
+    void initialize( unsigned n_lanes ) {
+        const unsigned max_lanes = sizeof(population_t) * CHAR_BIT;
+
+        N = n_lanes>=max_lanes ? max_lanes : n_lanes>2 ? 1<<(__TBB_Log2(n_lanes-1)+1) : 2;
+        __TBB_ASSERT( N==max_lanes || N>=n_lanes && ((N-1)&N)==0, "number of lanes miscalculated");
+        __TBB_ASSERT( N <= sizeof(population_t) * CHAR_BIT, NULL );
+        for(int level = 0; level < Levels; level++) {
+            lanes[level] = new padded<lane_t>[N];
+            __TBB_ASSERT( !population[level], NULL );
+        }
+    }
+
+    ~task_stream() {
+        for(int level = 0; level < Levels; level++)
+            if (lanes[level]) delete[] lanes[level];
+    }
+
+    //! Returns true on successful push, otherwise - false.
+    bool try_push( task* source, int level, unsigned lane_idx ) {
+        __TBB_ASSERT( 0 <= level && level < Levels, "Incorrect lane level specified." );
+        spin_mutex::scoped_lock lock;
+        if( lock.try_acquire( lanes[level][lane_idx].my_mutex ) ) {
+            lanes[level][lane_idx].my_queue.push_back( source );
+            set_one_bit( population[level], lane_idx ); // TODO: avoid atomic op if the bit is already set
+            return true;
+        }
+        return false;
+    }
+
+    //! Push a task into a lane. Lane selection is performed by passed functor.
+    template<typename lane_selector_t>
+    void push( task* source, int level, const lane_selector_t& next_lane ) {
+        bool succeed = false;
+        unsigned lane = 0;
+        do {
+            lane = next_lane( /*out_of=*/N );
+            __TBB_ASSERT( lane < N, "Incorrect lane index." );
+        } while( ! (succeed = try_push( source, level, lane )) );
+    }
+
+    //! Returns pointer to task on successful pop, otherwise - NULL.
+    task* try_pop( int level, unsigned lane_idx ) {
+        __TBB_ASSERT( 0 <= level && level < Levels, "Incorrect lane level specified." );
+        if( !is_bit_set( population[level], lane_idx ) )
+            return NULL;
+        task* result = NULL;
+        lane_t& lane = lanes[level][lane_idx];
+        spin_mutex::scoped_lock lock;
+        if( lock.try_acquire( lane.my_mutex ) && !lane.my_queue.empty() ) {
+            result = this->get_item( lane.my_queue );
+            if( lane.my_queue.empty() )
+                clear_one_bit( population[level], lane_idx );
+        }
+        return result;
+    }
+
+    //! Try finding and popping a task using passed functor for lane selection. Last used lane is
+    //! updated inside lane selector.
+    template<typename lane_selector_t>
+    task* pop( int level, const lane_selector_t& next_lane ) {
+        task* popped = NULL;
+        unsigned lane = 0;
+        do {
+            lane = next_lane( /*out_of=*/N );
+            __TBB_ASSERT( lane < N, "Incorrect lane index." );
+        } while( !empty( level ) && !(popped = try_pop( level, lane )) );
+        return popped;
+    }
+
+    // TODO: unify '*_specific' logic with 'pop' methods above
+    task* look_specific( __TBB_ISOLATION_ARG(task_stream_base::lane_t::queue_base_t& queue, isolation_tag isolation) ) {
+        __TBB_ASSERT( !queue.empty(), NULL );
+        // TODO: add a worst-case performance test and consider an alternative container with better
+        // performance for isolation search.
+        typename lane_t::queue_base_t::iterator curr = queue.end();
+        do {
+            // TODO: consider logic from get_task to simplify the code.
+            task* result = *--curr;
+            if( result __TBB_ISOLATION_EXPR( && result->prefix().isolation == isolation ) ) {
+                if( queue.end() - curr == 1 )
+                    queue.pop_back(); // a little of housekeeping along the way
+                else
+                    *curr = 0;      // grabbing task with the same isolation
+                // TODO: move one of the container's ends instead if the task has been found there
+                return result;
+            }
+        } while( curr != queue.begin() );
+        return NULL;
+    }
+
+    //! Try finding and popping a related task.
+    task* pop_specific( int level, __TBB_ISOLATION_ARG(unsigned& last_used_lane, isolation_tag isolation) ) {
+        task* result = NULL;
+        // Lane selection is round-robin in backward direction.
+        unsigned idx = last_used_lane & (N-1);
+        do {
+            if( is_bit_set( population[level], idx ) ) {
+                lane_t& lane = lanes[level][idx];
+                spin_mutex::scoped_lock lock;
+                if( lock.try_acquire(lane.my_mutex) && !lane.my_queue.empty() ) {
+                    result = look_specific( __TBB_ISOLATION_ARG(lane.my_queue, isolation) );
+                    if( lane.my_queue.empty() )
+                        clear_one_bit( population[level], idx );
+                    if( result )
+                        break;
+                }
+            }
+            idx=(idx-1)&(N-1);
+        } while( !empty(level) && idx != last_used_lane );
+        last_used_lane = idx;
+        return result;
+    }
+
+    //! Checks existence of a task.
+    bool empty(int level) {
+        return !population[level];
+    }
+
+    //! Destroys all remaining tasks in every lane. Returns the number of destroyed tasks.
+    /** Tasks are not executed, because it would potentially create more tasks at a late stage.
+        The scheduler is really expected to execute all tasks before task_stream destruction. */
+    intptr_t drain() {
+        intptr_t result = 0;
+        for(int level = 0; level < Levels; level++)
+            for(unsigned i=0; i<N; ++i) {
+                lane_t& lane = lanes[level][i];
+                spin_mutex::scoped_lock lock(lane.my_mutex);
+                for(typename lane_t::queue_base_t::iterator it=lane.my_queue.begin();
+                    it!=lane.my_queue.end(); ++it, ++result)
+                {
+                    __TBB_ASSERT( is_bit_set( population[level], i ), NULL );
+                    task* t = *it;
+                    tbb::task::destroy(*t);
+                }
+                lane.my_queue.clear();
+                clear_one_bit( population[level], i );
+            }
+        return result;
+    }
+}; // task_stream
+
+} // namespace internal
+} // namespace tbb
+
+#endif /* _TBB_task_stream_extended_H */
diff --git a/src/tbb/src/tbb/tbb_assert_impl.h b/src/tbb/src/tbb/tbb_assert_impl.h
index 6fcf5bf2..bad2a634 100644
--- a/src/tbb/src/tbb/tbb_assert_impl.h
+++ b/src/tbb/src/tbb/tbb_assert_impl.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,12 +12,11 @@
     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.
-
-
-
-
 */
 
+#ifndef _TBB_assert_impl_H
+#define _TBB_assert_impl_H
+
 // IMPORTANT: To use assertion handling in TBB, exactly one of the TBB source files
 // should #include tbb_assert_impl.h thus instantiating assertion handling routines.
 // The intent of putting it to a separate file is to allow some tests to use it
@@ -38,8 +37,6 @@
 #define __TBB_EXPORTED_FUNC
 #endif
 
-using namespace std;
-
 #if __TBBMALLOC_BUILD
 namespace rml { namespace internal {
 #else
@@ -72,7 +69,7 @@ namespace tbb {
                         _CrtDbgBreak();
 #else
                 fflush(stderr);
-                abort();
+                std::abort();
 #endif
             }
         }
@@ -82,7 +79,7 @@ namespace tbb {
 #   define vsnprintf _vsnprintf
 #endif
 
-#if !__TBBMALLOC_BUILD
+#if !__TBBMALLOC_BUILD && !__TBBBIND_BUILD
     namespace internal {
         //! Report a runtime warning.
         void __TBB_EXPORTED_FUNC runtime_warning( const char* format, ... )
@@ -101,3 +98,5 @@ namespace tbb {
 #else
 }  // namespace tbb
 #endif
+
+#endif /*_TBB_assert_impl_H*/
diff --git a/src/tbb/src/tbb/tbb_bind.cpp b/src/tbb/src/tbb/tbb_bind.cpp
new file mode 100644
index 00000000..36bd5bce
--- /dev/null
+++ b/src/tbb/src/tbb/tbb_bind.cpp
@@ -0,0 +1,302 @@
+/*
+    Copyright (c) 2005-2020 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 "../tbb/tbb_assert_impl.h" // Out-of-line TBB assertion handling routines are instantiated here.
+#include "tbb/tbb_stddef.h"
+
+#if _MSC_VER && !__INTEL_COMPILER
+#pragma warning( push )
+#pragma warning( disable : 4100 )
+#endif
+#include <hwloc.h>
+#if _MSC_VER && !__INTEL_COMPILER
+#pragma warning( pop )
+#endif
+
+#include <vector>
+
+// Most of hwloc calls returns negative exit code on error.
+// This macro tracks error codes that are returned from the hwloc interfaces.
+#define assertion_hwloc_wrapper(command, ...) \
+        __TBB_ASSERT_EX( (command(__VA_ARGS__)) >= 0, "Error occurred during call to hwloc API.");
+
+namespace tbb {
+namespace internal {
+
+//------------------------------------------------------------------------
+// Information about the machine's hardware TBB is happen to work on
+//------------------------------------------------------------------------
+class platform_topology {
+    friend class numa_affinity_handler;
+
+    // TODO: add the `my_` prefix to the members
+    hwloc_topology_t topology;
+    hwloc_cpuset_t   process_cpu_affinity_mask;
+    hwloc_nodeset_t  process_node_affinity_mask;
+    std::vector<hwloc_cpuset_t>  affinity_masks_list;
+
+    std::vector<int> default_concurrency_list;
+    std::vector<int> numa_indexes_list;
+    int  numa_nodes_count;
+
+    enum init_stages { uninitialized,
+                       started,
+                       topology_allocated,
+                       topology_loaded,
+                       topology_parsed } initialization_state;
+
+    // Binding threads to NUMA nodes that locates in another Windows Processor groups
+    // is allowed only if machine topology contains several Windows Processors groups
+    // and process affinity mask wasn`t limited manually (affinity mask cannot violates
+    // processors group boundaries).
+    bool intergroup_binding_allowed(size_t groups_num) { return groups_num > 1; }
+
+    platform_topology() : topology(NULL),
+                          process_cpu_affinity_mask(NULL),
+                          process_node_affinity_mask(NULL),
+                          numa_nodes_count(0),
+                          initialization_state(uninitialized) {}
+
+public:
+    typedef hwloc_cpuset_t             affinity_mask;
+    typedef hwloc_const_cpuset_t const_affinity_mask;
+
+    static platform_topology& instance() {
+        static platform_topology topology;
+        return topology;
+    }
+
+    bool is_topology_parsed() { return initialization_state == topology_parsed; }
+
+    void initialize( size_t groups_num ) {
+        if ( initialization_state != uninitialized )
+            return;
+        initialization_state = started;
+
+        // Parse topology
+        if ( hwloc_topology_init( &topology ) == 0 ) {
+            initialization_state = topology_allocated;
+            if ( hwloc_topology_load( topology ) == 0 ) {
+                initialization_state = topology_loaded;
+            }
+        }
+
+        // Fill parameters with stubs if topology parsing is broken.
+        if ( initialization_state != topology_loaded ) {
+            if ( initialization_state == topology_allocated ) {
+                hwloc_topology_destroy(topology);
+            }
+            numa_nodes_count = 1;
+            numa_indexes_list.push_back(-1);
+            default_concurrency_list.push_back(-1);
+            return;
+        }
+
+        // Getting process affinity mask
+        if ( intergroup_binding_allowed(groups_num) ) {
+            process_cpu_affinity_mask  = hwloc_bitmap_dup(hwloc_topology_get_complete_cpuset (topology));
+            process_node_affinity_mask = hwloc_bitmap_dup(hwloc_topology_get_complete_nodeset(topology));
+        } else {
+            process_cpu_affinity_mask  = hwloc_bitmap_alloc();
+            process_node_affinity_mask = hwloc_bitmap_alloc();
+
+            assertion_hwloc_wrapper(hwloc_get_cpubind, topology, process_cpu_affinity_mask, 0);
+            hwloc_cpuset_to_nodeset(topology, process_cpu_affinity_mask, process_node_affinity_mask);
+        }
+
+        // If system contains no NUMA nodes, HWLOC 1.11 returns an infinitely filled bitmap.
+        // hwloc_bitmap_weight() returns negative value for such bitmaps, so we use this check
+        // to change way of topology initialization.
+        if (hwloc_bitmap_weight(process_node_affinity_mask) < 0) {
+            numa_nodes_count = 1;
+            numa_indexes_list.push_back(0);
+            default_concurrency_list.push_back(hwloc_bitmap_weight(process_cpu_affinity_mask));
+
+            affinity_masks_list.push_back(hwloc_bitmap_dup(process_cpu_affinity_mask));
+            initialization_state = topology_parsed;
+            return;
+        }
+
+        // Get number of available NUMA nodes
+        numa_nodes_count = hwloc_bitmap_weight(process_node_affinity_mask);
+        __TBB_ASSERT(numa_nodes_count > 0, "Any system must contain one or more NUMA nodes");
+
+        // Get NUMA logical indexes list
+        unsigned counter = 0;
+        int i = 0;
+        int max_numa_index = -1;
+        numa_indexes_list.resize(numa_nodes_count);
+        hwloc_obj_t node_buffer;
+        hwloc_bitmap_foreach_begin(i, process_node_affinity_mask) {
+            node_buffer = hwloc_get_obj_by_type(topology, HWLOC_OBJ_NUMANODE, i);
+            numa_indexes_list[counter] = static_cast<int>(node_buffer->logical_index);
+
+            if ( numa_indexes_list[counter] > max_numa_index ) {
+                max_numa_index = numa_indexes_list[counter];
+            }
+
+            counter++;
+        } hwloc_bitmap_foreach_end();
+        __TBB_ASSERT(max_numa_index >= 0, "Maximal NUMA index must not be negative");
+
+        // Fill concurrency and affinity masks lists
+        default_concurrency_list.resize(max_numa_index + 1);
+        affinity_masks_list.resize(max_numa_index + 1);
+
+        int index = 0;
+        hwloc_bitmap_foreach_begin(i, process_node_affinity_mask) {
+            node_buffer = hwloc_get_obj_by_type(topology, HWLOC_OBJ_NUMANODE, i);
+            index = static_cast<int>(node_buffer->logical_index);
+
+            hwloc_cpuset_t& current_mask = affinity_masks_list[index];
+            current_mask = hwloc_bitmap_dup(node_buffer->cpuset);
+
+            hwloc_bitmap_and(current_mask, current_mask, process_cpu_affinity_mask);
+            __TBB_ASSERT(!hwloc_bitmap_iszero(current_mask), "hwloc detected unavailable NUMA node");
+            default_concurrency_list[index] = hwloc_bitmap_weight(current_mask);
+        } hwloc_bitmap_foreach_end();
+        initialization_state = topology_parsed;
+    }
+
+    ~platform_topology() {
+        if ( is_topology_parsed() ) {
+            for (int i = 0; i < numa_nodes_count; i++) {
+                hwloc_bitmap_free(affinity_masks_list[numa_indexes_list[i]]);
+            }
+            hwloc_bitmap_free(process_node_affinity_mask);
+            hwloc_bitmap_free(process_cpu_affinity_mask);
+        }
+
+        if ( initialization_state >= topology_allocated ) {
+            hwloc_topology_destroy(topology);
+        }
+
+        initialization_state = uninitialized;
+    }
+
+    void fill(int& nodes_count, int*& indexes_list, int*& concurrency_list ) {
+        __TBB_ASSERT(is_topology_parsed(), "Trying to get access to uninitialized platform_topology");
+        nodes_count = numa_nodes_count;
+        indexes_list = &numa_indexes_list.front();
+        concurrency_list = &default_concurrency_list.front();
+    }
+
+    affinity_mask allocate_process_affinity_mask() {
+        __TBB_ASSERT(is_topology_parsed(), "Trying to get access to uninitialized platform_topology");
+        return hwloc_bitmap_dup(process_cpu_affinity_mask);
+    }
+
+    void free_affinity_mask( affinity_mask mask_to_free ) {
+        hwloc_bitmap_free(mask_to_free); // If bitmap is NULL, no operation is performed.
+    }
+
+    void store_current_affinity_mask( affinity_mask current_mask ) {
+        assertion_hwloc_wrapper(hwloc_get_cpubind, topology, current_mask, HWLOC_CPUBIND_THREAD);
+
+        hwloc_bitmap_and(current_mask, current_mask, process_cpu_affinity_mask);
+        __TBB_ASSERT(!hwloc_bitmap_iszero(current_mask),
+            "Current affinity mask must intersects with process affinity mask");
+    }
+
+    void set_new_affinity_mask( const_affinity_mask new_mask ) {
+        assertion_hwloc_wrapper(hwloc_set_cpubind, topology, new_mask, HWLOC_CPUBIND_THREAD);
+    }
+
+    const_affinity_mask get_node_affinity_mask( int node_index ) {
+        __TBB_ASSERT((int)affinity_masks_list.size() > node_index,
+            "Trying to get affinity mask for uninitialized NUMA node");
+        return affinity_masks_list[node_index];
+    }
+};
+
+class binding_handler {
+    // Following vector saves thread affinity mask on scheduler entry to return it to this thread 
+    // on scheduler exit.
+    typedef std::vector<platform_topology::affinity_mask> affinity_masks_container;
+    affinity_masks_container affinity_backup;
+
+public:
+    binding_handler( size_t size ) : affinity_backup(size) {
+        for (affinity_masks_container::iterator it = affinity_backup.begin();
+             it != affinity_backup.end(); it++) {
+            *it = platform_topology::instance().allocate_process_affinity_mask();
+        }
+    }
+
+    ~binding_handler() {
+        for (affinity_masks_container::iterator it = affinity_backup.begin();
+             it != affinity_backup.end(); it++) {
+            platform_topology::instance().free_affinity_mask(*it);
+        }
+    }
+
+    void bind_thread_to_node( unsigned slot_num, unsigned numa_node_id ) {
+        __TBB_ASSERT(slot_num < affinity_backup.size(),
+            "The slot number is greater than the number of slots in the arena");
+        __TBB_ASSERT(platform_topology::instance().is_topology_parsed(),
+            "Trying to get access to uninitialized platform_topology");
+        platform_topology::instance().store_current_affinity_mask(affinity_backup[slot_num]);
+
+        platform_topology::instance().set_new_affinity_mask(
+            platform_topology::instance().get_node_affinity_mask(numa_node_id));
+    }
+
+    void restore_previous_affinity_mask( unsigned slot_num ) {
+        __TBB_ASSERT(platform_topology::instance().is_topology_parsed(),
+            "Trying to get access to uninitialized platform_topology");
+        platform_topology::instance().set_new_affinity_mask(affinity_backup[slot_num]);
+    };
+
+};
+
+extern "C" { // exported to TBB interfaces
+
+void initialize_numa_topology( size_t groups_num,
+                               int& nodes_count, int*& indexes_list, int*& concurrency_list ) {
+    platform_topology::instance().initialize(groups_num);
+    platform_topology::instance().fill(nodes_count, indexes_list, concurrency_list);
+}
+
+binding_handler* allocate_binding_handler(int slot_num) {
+    __TBB_ASSERT(slot_num > 0, "Trying to create numa handler for 0 threads.");
+    return new binding_handler(slot_num);
+}
+
+void deallocate_binding_handler(binding_handler* handler_ptr) {
+    __TBB_ASSERT(handler_ptr != NULL, "Trying to deallocate NULL pointer.");
+    delete handler_ptr;
+}
+
+void bind_to_node(binding_handler* handler_ptr, int slot_num, int numa_id) {
+    __TBB_ASSERT(handler_ptr != NULL, "Trying to get access to uninitialized metadata.");
+    __TBB_ASSERT(platform_topology::instance().is_topology_parsed(),
+        "Trying to get access to uninitialized platform_topology.");
+    handler_ptr->bind_thread_to_node(slot_num, numa_id);
+}
+
+void restore_affinity(binding_handler* handler_ptr, int slot_num) {
+    __TBB_ASSERT(handler_ptr != NULL, "Trying to get access to uninitialized metadata.");
+    __TBB_ASSERT(platform_topology::instance().is_topology_parsed(),
+        "Trying to get access to uninitialized platform_topology.");
+    handler_ptr->restore_previous_affinity_mask(slot_num);
+}
+
+} // extern "C"
+
+} // namespace internal
+} // namespace tbb
+
+#undef assertion_hwloc_wrapper
diff --git a/src/tbb/src/tbb/tbb_environment.h b/src/tbb/src/tbb/tbb_environment.h
new file mode 100644
index 00000000..e6a88cca
--- /dev/null
+++ b/src/tbb/src/tbb/tbb_environment.h
@@ -0,0 +1,85 @@
+/*
+    Copyright (c) 2018-2020 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.
+*/
+
+#ifndef __TBB_tbb_environment_H
+#define __TBB_tbb_environment_H
+
+#include <cstdlib>
+#include <cstring>
+#include <cerrno>
+#include <cctype>
+
+namespace tbb {
+
+namespace internal {
+
+#if __TBB_WIN8UI_SUPPORT
+static inline bool GetBoolEnvironmentVariable( const char * ) {
+    return false;
+}
+
+static inline long GetIntegralEnvironmentVariable( const char * ) {
+    return -1;
+}
+#else  /* __TBB_WIN8UI_SUPPORT */
+static inline bool GetBoolEnvironmentVariable( const char * name ) {
+    if( const char* s = std::getenv(name) )
+    {
+        // The result is defined as true only if the environment variable contains
+        // no characters except one '1' character and an arbitrary number of spaces
+        // (including the absence of spaces).
+        size_t index = std::strspn(s, " ");
+        if (s[index] != '1') return false;
+        index++;
+        // Memory access after incrementing is safe, since the getenv() returns a
+        // NULL terminated string, and even if the character getting by index is '1',
+        // and this character is the end of string, after incrementing we will get
+        // an index of character, that contains '\0'
+        index += std::strspn(&s[index], " ");
+        return !s[index];
+    }
+    return false;
+}
+
+static inline long GetIntegralEnvironmentVariable( const char * name ) {
+    if( const char* s = std::getenv(name) )
+    {
+        char* end = NULL;
+        errno = 0;
+        long value = std::strtol(s, &end, 10);
+
+        // We have exceeded the range, value is negative or string is incovertable
+        if ( errno == ERANGE || value < 0 || end==s )
+        {
+            return -1;
+        }
+
+        for ( ; *end != '\0'; end++ )
+        {
+            if ( !std::isspace(*end) )
+                return -1;
+        }
+
+        return value;
+    }
+    return -1;
+}
+#endif /* __TBB_WIN8UI_SUPPORT */
+
+} // namespace internal
+} // namespace tbb
+
+#endif // __TBB_tbb_environment_H
diff --git a/src/tbb/src/tbb/tbb_main.cpp b/src/tbb/src/tbb/tbb_main.cpp
index 685d28ec..4fa2ea50 100644
--- a/src/tbb/src/tbb/tbb_main.cpp
+++ b/src/tbb/src/tbb/tbb_main.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 "tbb/tbb_config.h"
@@ -41,6 +37,7 @@ static const char _pad[NFS_MaxLineSize - sizeof(int)] = {};
 // governor data
 basic_tls<uintptr_t> governor::theTLS;
 unsigned governor::DefaultNumberOfThreads;
+size_t governor::DefaultPageSize;
 rml::tbb_factory governor::theRMLServerFactory;
 bool governor::UsePrivateRML;
 bool governor::is_speculation_enabled;
@@ -64,7 +61,7 @@ bool __TBB_InitOnce::InitializationDone;
 
 #if DO_ITT_NOTIFY
     static bool ITT_Present;
-    static bool ITT_InitializationDone;
+    static atomic<bool> ITT_InitializationDone;
 #endif
 
 #if !(_WIN32||_WIN64) || __TBB_SOURCE_DIRECTLY_INCLUDED
@@ -75,7 +72,7 @@ bool __TBB_InitOnce::InitializationDone;
 // generic_scheduler data
 
 //! Pointer to the scheduler factory function
-generic_scheduler* (*AllocateSchedulerPtr)( market& );
+generic_scheduler* (*AllocateSchedulerPtr)( market&, bool );
 
 #if __TBB_OLD_PRIMES_RNG
 //! Table of primes used by fast random-number generator (FastRandom).
@@ -143,9 +140,7 @@ void Scheduler_OneTimeInitialization ( bool itt_present );
 
 #if DO_ITT_NOTIFY
 
-#if __TBB_ITT_STRUCTURE_API
-
-static __itt_domain *fgt_domain = NULL;
+static __itt_domain *tbb_domains[ITT_NUM_DOMAINS] = {};
 
 struct resource_string {
     const char *str;
@@ -163,13 +158,17 @@ static resource_string strings_for_itt[] = {
 #undef TBB_STRING_RESOURCE
 
 static __itt_string_handle *ITT_get_string_handle(int idx) {
-    __TBB_ASSERT(idx >= 0, NULL);
-    return idx < NUM_STRINGS ? strings_for_itt[idx].itt_str_handle : NULL;
+    __TBB_ASSERT( idx >= 0 && idx < NUM_STRINGS, "string handle out of valid range");
+    return (idx >= 0 && idx < NUM_STRINGS) ? strings_for_itt[idx].itt_str_handle : NULL;
 }
 
 static void ITT_init_domains() {
-    fgt_domain = __itt_domain_create( _T("tbb.flow") );
-    fgt_domain->flags = 1;
+    tbb_domains[ITT_DOMAIN_MAIN] = __itt_domain_create( _T("tbb") );
+    tbb_domains[ITT_DOMAIN_MAIN]->flags = 1;
+    tbb_domains[ITT_DOMAIN_FLOW] = __itt_domain_create( _T("tbb.flow") );
+    tbb_domains[ITT_DOMAIN_FLOW]->flags = 1;
+    tbb_domains[ITT_DOMAIN_ALGO] = __itt_domain_create( _T("tbb.algorithm") );
+    tbb_domains[ITT_DOMAIN_ALGO]->flags = 1;
 }
 
 static void ITT_init_strings() {
@@ -187,16 +186,14 @@ static void ITT_init() {
     ITT_init_strings();
 }
 
-#endif // __TBB_ITT_STRUCTURE_API
-
 /** Thread-unsafe lazy one-time initialization of tools interop.
     Used by both dummy handlers and general TBB one-time initialization routine. **/
 void ITT_DoUnsafeOneTimeInitialization () {
+    // Double check ITT_InitializationDone is necessary because the first check 
+    // in ITT_DoOneTimeInitialization is not guarded with the __TBB_InitOnce lock.
     if ( !ITT_InitializationDone ) {
         ITT_Present = (__TBB_load_ittnotify()!=0);
-#if __TBB_ITT_STRUCTURE_API
         if (ITT_Present) ITT_init();
-#endif
         ITT_InitializationDone = true;
         ITT_SYNC_CREATE(&market::theMarketMutex, SyncType_GlobalLock, SyncObj_SchedulerInitialization);
     }
@@ -206,9 +203,11 @@ void ITT_DoUnsafeOneTimeInitialization () {
     Used by dummy handlers only. **/
 extern "C"
 void ITT_DoOneTimeInitialization() {
-    __TBB_InitOnce::lock();
-    ITT_DoUnsafeOneTimeInitialization();
-    __TBB_InitOnce::unlock();
+    if ( !ITT_InitializationDone ) {
+        __TBB_InitOnce::lock();
+        ITT_DoUnsafeOneTimeInitialization();
+        __TBB_InitOnce::unlock();
+    }
 }
 #endif /* DO_ITT_NOTIFY */
 
@@ -231,6 +230,8 @@ void DoOneTimeInitializations() {
         Scheduler_OneTimeInitialization( itt_present );
         // Force processor groups support detection
         governor::default_num_threads();
+        // Force OS regular page size detection
+        governor::default_page_size();
         // Dump version data
         governor::print_version_info();
         PrintExtraVersionInfo( "Tools support", itt_present ? "enabled" : "disabled" );
@@ -241,12 +242,16 @@ void DoOneTimeInitializations() {
 
 #if (_WIN32||_WIN64) && !__TBB_SOURCE_DIRECTLY_INCLUDED
 //! Windows "DllMain" that handles startup and shutdown of dynamic library.
-extern "C" bool WINAPI DllMain( HANDLE /*hinstDLL*/, DWORD reason, LPVOID /*lpvReserved*/ ) {
+extern "C" bool WINAPI DllMain( HANDLE /*hinstDLL*/, DWORD reason, LPVOID lpvReserved ) {
     switch( reason ) {
         case DLL_PROCESS_ATTACH:
             __TBB_InitOnce::add_ref();
             break;
         case DLL_PROCESS_DETACH:
+            // Since THREAD_DETACH is not called for the main thread, call auto-termination
+            // here as well - but not during process shutdown (due to risk of a deadlock).
+            if( lpvReserved==NULL ) // library unload
+                governor::terminate_auto_initialized_scheduler();
             __TBB_InitOnce::remove_ref();
             // It is assumed that InitializationDone is not set after DLL_PROCESS_DETACH,
             // and thus no race on InitializationDone is possible.
@@ -287,14 +292,14 @@ void call_itt_notify_v5(int t, void *ptr) {
 void call_itt_notify_v5(int /*t*/, void* /*ptr*/) {}
 #endif
 
-#if __TBB_ITT_STRUCTURE_API
-
 #if DO_ITT_NOTIFY
-
 const __itt_id itt_null_id = {0, 0, 0};
 
 static inline __itt_domain* get_itt_domain( itt_domain_enum idx ) {
-    return ( idx == ITT_DOMAIN_FLOW ) ? fgt_domain : NULL;
+    if (tbb_domains[idx] == NULL) {
+        ITT_DoOneTimeInitialization();
+    }
+    return tbb_domains[idx];
 }
 
 static inline void itt_id_make(__itt_id *id, void* addr, unsigned long long extra) {
@@ -335,6 +340,21 @@ void itt_metadata_str_add_v7( itt_domain_enum domain, void *addr, unsigned long
     }
 }
 
+void itt_metadata_ptr_add_v11( itt_domain_enum domain, void *addr, unsigned long long addr_extra,
+                              string_index key, void *value ) {
+    if ( __itt_domain *d = get_itt_domain( domain ) ) {
+        __itt_id id = itt_null_id;
+        itt_id_make( &id, addr, addr_extra );
+        __itt_string_handle *k = ITT_get_string_handle(key);
+#if __TBB_x86_32
+        ITTNOTIFY_VOID_D5(metadata_add, d, id, k, __itt_metadata_u32, 1, value);
+#else
+        ITTNOTIFY_VOID_D5(metadata_add, d, id, k, __itt_metadata_u64, 1, value);
+#endif 
+    }
+}
+
+
 void itt_relation_add_v7( itt_domain_enum domain, void *addr0, unsigned long long addr0_extra,
                           itt_relation relation, void *addr1, unsigned long long addr1_extra ) {
     if ( __itt_domain *d = get_itt_domain( domain ) ) {
@@ -351,7 +371,9 @@ void itt_task_begin_v7( itt_domain_enum domain, void *task, unsigned long long t
     if ( __itt_domain *d = get_itt_domain( domain ) ) {
         __itt_id task_id = itt_null_id;
         __itt_id parent_id = itt_null_id;
-        itt_id_make( &task_id, task, task_extra );
+        if ( task ) {
+            itt_id_make( &task_id, task, task_extra );
+        }
         if ( parent ) {
             itt_id_make( &parent_id, parent, parent_extra );
         }
@@ -389,28 +411,29 @@ void itt_region_end_v9( itt_domain_enum domain, void *region, unsigned long long
 
 #else // DO_ITT_NOTIFY
 
-void itt_make_task_group_v7( itt_domain_enum domain, void *group, unsigned long long group_extra,
-                             void *parent, unsigned long long parent_extra, string_index name_index ) { }
+void itt_make_task_group_v7( itt_domain_enum /*domain*/, void* /*group*/, unsigned long long /*group_extra*/,
+                             void* /*parent*/, unsigned long long /*parent_extra*/, string_index /*name_index*/ ) { }
 
-void itt_metadata_str_add_v7( itt_domain_enum domain, void *addr, unsigned long long addr_extra,
-                              string_index key, const char *value ) { }
+void itt_metadata_str_add_v7( itt_domain_enum /*domain*/, void* /*addr*/, unsigned long long /*addr_extra*/,
+                              string_index /*key*/, const char* /*value*/ ) { }
 
-void itt_relation_add_v7( itt_domain_enum domain, void *addr0, unsigned long long addr0_extra,
-                          itt_relation relation, void *addr1, unsigned long long addr1_extra ) { }
+void itt_relation_add_v7( itt_domain_enum /*domain*/, void* /*addr0*/, unsigned long long /*addr0_extra*/,
+                          itt_relation /*relation*/, void* /*addr1*/, unsigned long long /*addr1_extra*/ ) { }
 
-void itt_task_begin_v7( itt_domain_enum domain, void *task, unsigned long long task_extra,
-                        void * /*parent*/, unsigned long long /* parent_extra */, string_index /* name_index */ ) { }
+void itt_metadata_ptr_add_v11( itt_domain_enum /*domain*/, void * /*addr*/, unsigned long long /*addr_extra*/,
+                              string_index /*key*/, void * /*value*/ ) {}
 
-void itt_task_end_v7( itt_domain_enum domain ) { }
+void itt_task_begin_v7( itt_domain_enum /*domain*/, void* /*task*/, unsigned long long /*task_extra*/,
+                        void* /*parent*/, unsigned long long /*parent_extra*/, string_index /*name_index*/ ) { }
 
-void itt_region_begin_v9( itt_domain_enum domain, void *region, unsigned long long region_extra,
-                          void *parent, unsigned long long parent_extra, string_index /* name_index */ ) { }
+void itt_task_end_v7( itt_domain_enum /*domain*/ ) { }
 
-void itt_region_end_v9( itt_domain_enum domain, void *region, unsigned long long region_extra ) { }
+void itt_region_begin_v9( itt_domain_enum /*domain*/, void* /*region*/, unsigned long long /*region_extra*/,
+                          void* /*parent*/, unsigned long long /*parent_extra*/, string_index /*name_index*/ ) { }
 
-#endif // DO_ITT_NOTIFY
+void itt_region_end_v9( itt_domain_enum /*domain*/, void* /*region*/, unsigned long long /*region_extra*/ ) { }
 
-#endif // __TBB_ITT_STRUCTURE_API
+#endif // DO_ITT_NOTIFY
 
 void* itt_load_pointer_v3( const void* src ) {
     //TODO: replace this with __TBB_load_relaxed
@@ -423,7 +446,6 @@ void itt_set_sync_name_v3( void* obj, const tchar* name) {
     suppress_unused_warning(obj, name);
 }
 
-
 class control_storage {
     friend class tbb::interface9::global_control;
 protected:
@@ -476,8 +498,8 @@ class stack_size_control : public padded<control_storage> {
         return tbb::internal::ThreadStackSize;
     }
     virtual void apply_active() const __TBB_override {
-#if __TBB_WIN8UI_SUPPORT
-        __TBB_ASSERT( false, "For Windows Store* apps we must not set stack size" );
+#if __TBB_WIN8UI_SUPPORT && (_WIN32_WINNT < 0x0A00)
+        __TBB_ASSERT( false, "For Windows 8 Store* apps we must not set stack size" );
 #endif
     }
 };
diff --git a/src/tbb/src/tbb/tbb_main.h b/src/tbb/src/tbb/tbb_main.h
index 24d77d11..917e35dd 100644
--- a/src/tbb/src/tbb/tbb_main.h
+++ b/src/tbb/src/tbb/tbb_main.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,16 +12,14 @@
     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.
-
-
-
-
 */
 
 #ifndef _TBB_tbb_main_H
 #define _TBB_tbb_main_H
 
 #include "tbb/atomic.h"
+#include "governor.h"
+#include "tbb_environment.h"
 
 namespace tbb {
 
@@ -73,6 +71,7 @@ class __TBB_InitOnce {
     //! Remove the initial reference to resources.
     /** This is not necessarily the last reference if other threads are still running. **/
     ~__TBB_InitOnce() {
+        governor::terminate_auto_initialized_scheduler(); // TLS dtor not called for the main thread
         remove_ref();
         // We assume that InitializationDone is not set after file-scope destructors
         // start running, and thus no race on InitializationDone is possible.
diff --git a/src/tbb/src/tbb/tbb_misc.cpp b/src/tbb/src/tbb/tbb_misc.cpp
index 5e389fec..7c4fec50 100644
--- a/src/tbb/src/tbb/tbb_misc.cpp
+++ b/src/tbb/src/tbb/tbb_misc.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 // Source file for miscellaneous entities that are infrequently referenced by
@@ -37,6 +33,10 @@
 #include "tbb/machine/windows_api.h"
 #endif
 
+#if !_WIN32
+#include <unistd.h> // sysconf(_SC_PAGESIZE)
+#endif
+
 #define __TBB_STD_RETHROW_EXCEPTION_POSSIBLY_BROKEN                             \
     (__GLIBCXX__ && __TBB_GLIBCXX_VERSION>=40700 && __TBB_GLIBCXX_VERSION<60000 \
      && TBB_USE_EXCEPTIONS && !TBB_USE_CAPTURED_EXCEPTION)
@@ -46,8 +46,6 @@
 #include <cxxabi.h>
 #endif
 
-using namespace std;
-
 namespace tbb {
 
 const char* bad_last_alloc::what() const throw() { return "bad allocation in previous or concurrent attempt"; }
@@ -65,10 +63,19 @@ namespace internal {
         fprintf (stderr, "Exception %s with message %s would've been thrown, "  \
             "if exception handling were not disabled. Aborting.\n", exc_name, msg); \
         fflush(stderr); \
-        abort();
+        std::abort();
     #define DO_THROW(exc, init_args) PRINT_ERROR_AND_ABORT(#exc, #init_args)
 #endif /* !TBB_USE_EXCEPTIONS */
 
+size_t DefaultSystemPageSize() {
+#if _WIN32
+    SYSTEM_INFO si;
+    GetSystemInfo(&si);
+    return si.dwPageSize;
+#else
+    return sysconf(_SC_PAGESIZE);
+#endif
+}
 
 /* The "what" should be fairly short, not more than about 128 characters.
    Because we control all the call sites to handle_perror, it is pointless
@@ -88,7 +95,7 @@ void handle_perror( int error_code, const char* what ) {
     // Ensure that buffer ends in terminator.
     buf[sizeof(buf)-1] = 0;
 #if TBB_USE_EXCEPTIONS
-    throw runtime_error(buf);
+    throw std::runtime_error(buf);
 #else
     PRINT_ERROR_AND_ABORT( "runtime_error", buf);
 #endif /* !TBB_USE_EXCEPTIONS */
@@ -105,7 +112,7 @@ void handle_win_error( int error_code ) {
     sprintf_s((char*)&buf, 512, "error code %d", error_code);
 #endif
 #if TBB_USE_EXCEPTIONS
-    throw runtime_error(buf);
+    throw std::runtime_error(buf);
 #else
     PRINT_ERROR_AND_ABORT( "runtime_error", buf);
 #endif /* !TBB_USE_EXCEPTIONS */
@@ -119,27 +126,27 @@ void throw_bad_last_alloc_exception_v4() {
 void throw_exception_v4 ( exception_id eid ) {
     __TBB_ASSERT ( eid > 0 && eid < eid_max, "Unknown exception ID" );
     switch ( eid ) {
-    case eid_bad_alloc: DO_THROW( bad_alloc, () );
+    case eid_bad_alloc: DO_THROW(std::bad_alloc, () );
     case eid_bad_last_alloc: DO_THROW( bad_last_alloc, () );
-    case eid_nonpositive_step: DO_THROW( invalid_argument, ("Step must be positive") );
-    case eid_out_of_range: DO_THROW( out_of_range, ("Index out of requested size range") );
-    case eid_segment_range_error: DO_THROW( range_error, ("Index out of allocated segment slots") );
-    case eid_index_range_error: DO_THROW( range_error, ("Index is not allocated") );
+    case eid_nonpositive_step: DO_THROW(std::invalid_argument, ("Step must be positive") );
+    case eid_out_of_range: DO_THROW(std::out_of_range, ("Index out of requested size range") );
+    case eid_segment_range_error: DO_THROW(std::range_error, ("Index out of allocated segment slots") );
+    case eid_index_range_error: DO_THROW(std::range_error, ("Index is not allocated") );
     case eid_missing_wait: DO_THROW( missing_wait, () );
     case eid_invalid_multiple_scheduling: DO_THROW( invalid_multiple_scheduling, () );
     case eid_improper_lock: DO_THROW( improper_lock, () );
-    case eid_possible_deadlock: DO_THROW( runtime_error, ("Resource deadlock would occur") );
-    case eid_operation_not_permitted: DO_THROW( runtime_error, ("Operation not permitted") );
-    case eid_condvar_wait_failed: DO_THROW( runtime_error, ("Wait on condition variable failed") );
-    case eid_invalid_load_factor: DO_THROW( out_of_range, ("Invalid hash load factor") );
-    case eid_reserved: DO_THROW( out_of_range, ("[backward compatibility] Invalid number of buckets") );
-    case eid_invalid_swap: DO_THROW( invalid_argument, ("swap() is invalid on non-equal allocators") );
-    case eid_reservation_length_error: DO_THROW( length_error, ("reservation size exceeds permitted max size") );
-    case eid_invalid_key: DO_THROW( out_of_range, ("invalid key") );
+    case eid_possible_deadlock: DO_THROW(std::runtime_error, ("Resource deadlock would occur") );
+    case eid_operation_not_permitted: DO_THROW(std::runtime_error, ("Operation not permitted") );
+    case eid_condvar_wait_failed: DO_THROW(std::runtime_error, ("Wait on condition variable failed") );
+    case eid_invalid_load_factor: DO_THROW(std::out_of_range, ("Invalid hash load factor") );
+    case eid_reserved: DO_THROW(std::out_of_range, ("[backward compatibility] Invalid number of buckets") );
+    case eid_invalid_swap: DO_THROW(std::invalid_argument, ("swap() is invalid on non-equal allocators") );
+    case eid_reservation_length_error: DO_THROW(std::length_error, ("reservation size exceeds permitted max size") );
+    case eid_invalid_key: DO_THROW(std::out_of_range, ("invalid key") );
     case eid_user_abort: DO_THROW( user_abort, () );
-    case eid_bad_tagged_msg_cast: DO_THROW( runtime_error, ("Illegal tagged_msg cast") );
+    case eid_bad_tagged_msg_cast: DO_THROW(std::runtime_error, ("Illegal tagged_msg cast") );
 #if __TBB_SUPPORTS_WORKERS_WAITING_IN_TERMINATE
-    case eid_blocking_thread_join_impossible: DO_THROW( runtime_error, ("Blocking terminate failed") );
+    case eid_blocking_thread_join_impossible: DO_THROW(std::runtime_error, ("Blocking terminate failed") );
 #endif
     default: break;
     }
@@ -191,16 +198,6 @@ void fix_broken_rethrow() {}
 bool gcc_rethrow_exception_broken() { return false; }
 #endif /* __TBB_STD_RETHROW_EXCEPTION_POSSIBLY_BROKEN */
 
-#if __TBB_WIN8UI_SUPPORT
-bool GetBoolEnvironmentVariable( const char * ) { return false;}
-#else  /* __TBB_WIN8UI_SUPPORT */
-bool GetBoolEnvironmentVariable( const char * name ) {
-    if( const char* s = getenv(name) )
-        return strcmp(s,"0") != 0;
-    return false;
-}
-#endif /* __TBB_WIN8UI_SUPPORT */
-
 /** The leading "\0" is here so that applying "strings" to the binary delivers a clean result. */
 static const char VersionString[] = "\0" TBB_VERSION_STRINGS;
 
diff --git a/src/tbb/src/tbb/tbb_misc.h b/src/tbb/src/tbb/tbb_misc.h
index 8a05197e..31d887b8 100644
--- a/src/tbb/src/tbb/tbb_misc.h
+++ b/src/tbb/src/tbb/tbb_misc.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef _TBB_tbb_misc_H
@@ -25,6 +21,10 @@
 #include "tbb/tbb_machine.h"
 #include "tbb/atomic.h"     // For atomic_xxx definitions
 
+#if __TBB_NUMA_SUPPORT
+#include "tbb/info.h"
+#endif /*__TBB_NUMA_SUPPORT*/
+
 #if __linux__ || __FreeBSD__
 #include <sys/param.h>  // __FreeBSD_version
 #if __FreeBSD_version >= 701000
@@ -39,12 +39,14 @@
 #define __TBB_USE_OS_AFFINITY_SYSCALL (__TBB_OS_AFFINITY_SYSCALL_PRESENT && !__bg__)
 
 namespace tbb {
+
 namespace internal {
 
 const size_t MByte = 1024*1024;
 
-#if __TBB_WIN8UI_SUPPORT
-// In Win8UI mode, TBB uses a thread creation API that does not allow to specify the stack size.
+#if __TBB_WIN8UI_SUPPORT && (_WIN32_WINNT < 0x0A00)
+// In Win8UI mode (Windows 8 Store* applications), TBB uses a thread creation API
+// that does not allow to specify the stack size.
 // Still, the thread stack size value, either explicit or default, is used by the scheduler.
 // So here we set the default value to match the platform's default of 1MB.
 const size_t ThreadStackSize = 1*MByte;
@@ -65,6 +67,8 @@ inline int AvailableHwConcurrency() {
 }
 #endif /* __TBB_HardwareConcurrency */
 
+//! Returns OS regular memory page size
+size_t DefaultSystemPageSize();
 
 #if _WIN32||_WIN64
 
@@ -83,9 +87,6 @@ void MoveThreadIntoProcessorGroup( void* hThread, int groupIndex );
 //! Throws std::runtime_error with what() returning error_code description prefixed with aux_info
 void handle_win_error( int error_code );
 
-//! True if environment variable with given name is set and not 0; otherwise false.
-bool GetBoolEnvironmentVariable( const char * name );
-
 //! Prints TBB version information on stderr
 void PrintVersion();
 
@@ -269,6 +270,22 @@ bool cpu_has_speculation();
 bool gcc_rethrow_exception_broken();
 void fix_broken_rethrow();
 
+#if __TBB_NUMA_SUPPORT
+class binding_handler;
+
+binding_handler* construct_binding_handler(int slot_num);
+void destroy_binding_handler(binding_handler* handler_ptr);
+void bind_thread_to_node(binding_handler* handler_ptr, int slot_num , int numa_id);
+void restore_affinity_mask(binding_handler* handler_ptr, int slot_num);
+
+namespace numa_topology {
+    bool is_initialized();
+    void initialize();
+    void destroy();
+}
+
+#endif /*__TBB_NUMA_SUPPORT*/
+
 } // namespace internal
 } // namespace tbb
 
diff --git a/src/tbb/src/tbb/tbb_misc_ex.cpp b/src/tbb/src/tbb/tbb_misc_ex.cpp
index 264abe6a..a35792b6 100644
--- a/src/tbb/src/tbb/tbb_misc_ex.cpp
+++ b/src/tbb/src/tbb/tbb_misc_ex.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 // Source file for miscellaneous entities that are infrequently referenced by
@@ -61,7 +57,7 @@ namespace internal {
 static int (*libiomp_try_restoring_original_mask)();
 // Table for mapping to libiomp entry points
 static const dynamic_link_descriptor iompLinkTable[] = {
-    { "kmp_set_thread_affinity_mask_initial", (pointer_to_handler*)(void*)(&libiomp_try_restoring_original_mask) }
+    DLD_NOWEAK( kmp_set_thread_affinity_mask_initial, libiomp_try_restoring_original_mask )
 };
 #endif
 
diff --git a/src/tbb/src/tbb/tbb_resource.rc b/src/tbb/src/tbb/tbb_resource.rc
index 7dc4fe6f..2bf623fc 100644
--- a/src/tbb/src/tbb/tbb_resource.rc
+++ b/src/tbb/src/tbb/tbb_resource.rc
@@ -1,4 +1,4 @@
-// Copyright (c) 2005-2017 Intel Corporation
+// Copyright (c) 2005-2020 Intel Corporation
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -11,10 +11,6 @@
 // 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.
-//
-//
-//
-//
 
 // Microsoft Visual C++ generated resource script.
 //
@@ -81,7 +77,7 @@ BEGIN
             VALUE "CompanyName", "Intel Corporation\0"
             VALUE "FileDescription", "Intel(R) Threading Building Blocks library\0"
             VALUE "FileVersion", TBB_VERSION "\0"
-            VALUE "LegalCopyright", "Copyright 2005-2017 Intel Corporation.  All Rights Reserved.\0"
+            VALUE "LegalCopyright", "Copyright 2005-2020 Intel Corporation.  All Rights Reserved.\0"
             VALUE "LegalTrademarks", "\0"
 #ifndef TBB_USE_DEBUG
             VALUE "OriginalFilename", "tbb.dll\0"
diff --git a/src/tbb/src/tbb/tbb_statistics.cpp b/src/tbb/src/tbb/tbb_statistics.cpp
index 3656f9ab..c1a9d126 100644
--- a/src/tbb/src/tbb/tbb_statistics.cpp
+++ b/src/tbb/src/tbb/tbb_statistics.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 "tbb_statistics.h"
diff --git a/src/tbb/src/tbb/tbb_statistics.h b/src/tbb/src/tbb/tbb_statistics.h
index 390aa36a..03bc437c 100644
--- a/src/tbb/src/tbb/tbb_statistics.h
+++ b/src/tbb/src/tbb/tbb_statistics.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef _TBB_tbb_statistics_H
@@ -208,7 +204,7 @@ struct statistics_counters {
 
     statistics_counters() { reset(); }
 
-    void reset () { memset( (void*) this, 0, sizeof(statistics_counters) ); }
+    void reset () { memset( this, 0, sizeof(statistics_counters) ); }
 
     counter_type& field ( size_t index ) { return reinterpret_cast<counter_type*>(this)[index]; }
 
diff --git a/src/tbb/src/tbb/tbb_thread.cpp b/src/tbb/src/tbb/tbb_thread.cpp
index f64fb1f3..85d1b7ee 100644
--- a/src/tbb/src/tbb/tbb_thread.cpp
+++ b/src/tbb/src/tbb/tbb_thread.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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||_WIN64
diff --git a/src/tbb/src/tbb/tbb_version.h b/src/tbb/src/tbb/tbb_version.h
index 89a1c516..5aff3e25 100644
--- a/src/tbb/src/tbb/tbb_version.h
+++ b/src/tbb/src/tbb/tbb_version.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 // Please define version number in the file:
diff --git a/src/tbb/src/tbb/tls.h b/src/tbb/src/tbb/tls.h
index fd4355e8..2a3f79e7 100644
--- a/src/tbb/src/tbb/tls.h
+++ b/src/tbb/src/tbb/tls.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef _TBB_tls_H
diff --git a/src/tbb/src/tbb/tools_api/disable_warnings.h b/src/tbb/src/tbb/tools_api/disable_warnings.h
index a2452bb6..34621c40 100644
--- a/src/tbb/src/tbb/tools_api/disable_warnings.h
+++ b/src/tbb/src/tbb/tools_api/disable_warnings.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 "ittnotify_config.h"
diff --git a/src/tbb/src/tbb/tools_api/ittnotify.h b/src/tbb/src/tbb/tools_api/ittnotify.h
index 037588ce..95ca8e60 100644
--- a/src/tbb/src/tbb/tools_api/ittnotify.h
+++ b/src/tbb/src/tbb/tools_api/ittnotify.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef _ITTNOTIFY_H_
@@ -26,7 +22,7 @@
 @brief Public User API functions and types
 @mainpage
 
-The ITT API is used to annotate a user's program with additional information
+The Instrumentation and Tracing Technology API (ITT API) is used to annotate a user's program with additional information
 that can be used by correctness and performance tools. The user inserts
 calls in their program. Those calls generate information that is collected
 at runtime, and used by Intel(R) Threading Tools.
@@ -158,17 +154,17 @@ The same ID may not be reused for different instances, unless a previous
 #endif /* UNICODE || _UNICODE */
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 
-#ifndef CDECL
+#ifndef ITTAPI_CDECL
 #  if ITT_PLATFORM==ITT_PLATFORM_WIN
-#    define CDECL __cdecl
+#    define ITTAPI_CDECL __cdecl
 #  else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #    if defined _M_IX86 || defined __i386__
-#      define CDECL __attribute__ ((cdecl))
+#      define ITTAPI_CDECL __attribute__ ((cdecl))
 #    else  /* _M_IX86 || __i386__ */
-#      define CDECL /* actual only on x86 platform */
+#      define ITTAPI_CDECL /* actual only on x86 platform */
 #    endif /* _M_IX86 || __i386__ */
 #  endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#endif /* CDECL */
+#endif /* ITTAPI_CDECL */
 
 #ifndef STDCALL
 #  if ITT_PLATFORM==ITT_PLATFORM_WIN
@@ -182,12 +178,12 @@ The same ID may not be reused for different instances, unless a previous
 #  endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #endif /* STDCALL */
 
-#define ITTAPI    CDECL
-#define LIBITTAPI CDECL
+#define ITTAPI    ITTAPI_CDECL
+#define LIBITTAPI ITTAPI_CDECL
 
 /* TODO: Temporary for compatibility! */
-#define ITTAPI_CALL    CDECL
-#define LIBITTAPI_CALL CDECL
+#define ITTAPI_CALL    ITTAPI_CDECL
+#define LIBITTAPI_CALL ITTAPI_CDECL
 
 #if ITT_PLATFORM==ITT_PLATFORM_WIN
 /* use __forceinline (VC++ specific) */
@@ -348,6 +344,87 @@ ITT_STUBV(ITTAPI, void, detach, (void))
 /** @} control group */
 /** @endcond */
 
+/**
+ * @defgroup Intel Processor Trace control
+ * API from this group provides control over collection and analysis of Intel Processor Trace (Intel PT) data
+ * Information about Intel Processor Trace technology can be found here (Volume 3 chapter 35):
+ * https://software.intel.com/sites/default/files/managed/39/c5/325462-sdm-vol-1-2abcd-3abcd.pdf
+ * Use this API to mark particular code regions for loading detailed performance statistics.
+ * This mode makes your analysis faster and more accurate.
+ * @{
+*/
+typedef unsigned char __itt_pt_region;
+
+/**
+ * @brief function saves a region name marked with Intel PT API and returns a region id.
+ * Only 7 names can be registered. Attempts to register more names will be ignored and a region id with auto names will be returned.
+ * For automatic naming of regions pass NULL as function parameter
+*/
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+__itt_pt_region ITTAPI __itt_pt_region_createA(const char    *name);
+__itt_pt_region ITTAPI __itt_pt_region_createW(const wchar_t *name);
+#if defined(UNICODE) || defined(_UNICODE)
+#  define __itt_pt_region_create __itt_pt_region_createW
+#else /* UNICODE */
+#  define __itt_pt_region_create __itt_pt_region_createA
+#endif /* UNICODE */
+#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+__itt_pt_region ITTAPI __itt_pt_region_create(const char *name);
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+ITT_STUB(ITTAPI, __itt_pt_region, pt_region_createA, (const char    *name))
+ITT_STUB(ITTAPI, __itt_pt_region, pt_region_createW, (const wchar_t *name))
+#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUB(ITTAPI, __itt_pt_region, pt_region_create,  (const char    *name))
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_pt_region_createA     ITTNOTIFY_DATA(pt_region_createA)
+#define __itt_pt_region_createA_ptr ITTNOTIFY_NAME(pt_region_createA)
+#define __itt_pt_region_createW     ITTNOTIFY_DATA(pt_region_createW)
+#define __itt_pt_region_createW_ptr ITTNOTIFY_NAME(pt_region_createW)
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_pt_region_create     ITTNOTIFY_DATA(pt_region_create)
+#define __itt_pt_region_create_ptr ITTNOTIFY_NAME(pt_region_create)
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#else  /* INTEL_NO_ITTNOTIFY_API */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_pt_region_createA(name) (__itt_pt_region)0
+#define __itt_pt_region_createA_ptr 0
+#define __itt_pt_region_createW(name) (__itt_pt_region)0
+#define __itt_pt_region_createW_ptr 0
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_pt_region_create(name)  (__itt_pt_region)0
+#define __itt_pt_region_create_ptr 0
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else  /* INTEL_NO_MACRO_BODY */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_pt_region_createA_ptr 0
+#define __itt_pt_region_createW_ptr 0
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_pt_region_create_ptr  0
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @brief function contains a special code pattern identified on the post-processing stage and
+ * marks the beginning of a code region targeted for Intel PT analysis
+ * @param[in] region - region id, 0 <= region < 8
+*/
+void __itt_mark_pt_region_begin(__itt_pt_region region);
+/**
+ * @brief function contains a special code pattern identified on the post-processing stage and
+ * marks the end of a code region targeted for Intel PT analysis
+ * @param[in] region - region id, 0 <= region < 8
+*/
+void __itt_mark_pt_region_end(__itt_pt_region region);
+/** @} Intel PT control group*/
+
 /**
  * @defgroup threads Threads
  * @ingroup public
@@ -2248,59 +2325,6 @@ ITT_STUBV(ITTAPI, void, task_end_overlapped,   (const __itt_domain *domain, __it
 /** @endcond */
 /** @} tasks group */
 
-/**
- * @defgroup counters Counters
- * @ingroup public
- * Counters are user-defined objects with a monotonically increasing
- * value. Counter values are 64-bit unsigned integers. Counter values
- * are tracked per-thread. Counters have names that can be displayed in
- * the tools.
- * @{
- */
-
-/**
- * @ingroup counters
- * @brief Increment a counter by one.
- * The first call with a given name creates a counter by that name and sets its
- * value to zero on every thread. Successive calls increment the counter value
- * on the thread on which the call is issued.
- * @param[in] domain The domain controlling the call. Counter names are not domain specific.
- *            The domain argument is used only to enable or disable the API calls.
- * @param[in] name The name of the counter
- */
-void ITTAPI __itt_counter_inc_v3(const __itt_domain *domain, __itt_string_handle *name);
-
-/**
- * @ingroup counters
- * @brief Increment a counter by the value specified in delta.
- * @param[in] domain The domain controlling the call. Counter names are not domain specific.
- *            The domain argument is used only to enable or disable the API calls.
- * @param[in] name The name of the counter
- * @param[in] delta The amount by which to increment the counter
- */
-void ITTAPI __itt_counter_inc_delta_v3(const __itt_domain *domain, __itt_string_handle *name, unsigned long long delta);
-
-/** @cond exclude_from_documentation */
-#ifndef INTEL_NO_MACRO_BODY
-#ifndef INTEL_NO_ITTNOTIFY_API
-ITT_STUBV(ITTAPI, void, counter_inc_v3,       (const __itt_domain *domain, __itt_string_handle *name))
-ITT_STUBV(ITTAPI, void, counter_inc_delta_v3, (const __itt_domain *domain, __itt_string_handle *name, unsigned long long delta))
-#define __itt_counter_inc_v3(d,x)         ITTNOTIFY_VOID_D1(counter_inc_v3,d,x)
-#define __itt_counter_inc_v3_ptr          ITTNOTIFY_NAME(counter_inc_v3)
-#define __itt_counter_inc_delta_v3(d,x,y) ITTNOTIFY_VOID_D2(counter_inc_delta_v3,d,x,y)
-#define __itt_counter_inc_delta_v3_ptr    ITTNOTIFY_NAME(counter_inc_delta_v3)
-#else  /* INTEL_NO_ITTNOTIFY_API */
-#define __itt_counter_inc_v3(domain,name)
-#define __itt_counter_inc_v3_ptr       0
-#define __itt_counter_inc_delta_v3(domain,name,delta)
-#define __itt_counter_inc_delta_v3_ptr 0
-#endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
-#define __itt_counter_inc_v3_ptr       0
-#define __itt_counter_inc_delta_v3_ptr 0
-#endif /* INTEL_NO_MACRO_BODY */
-/** @endcond */
-/** @} counters group */
 
 /**
  * @defgroup markers Markers
@@ -2709,7 +2733,7 @@ ITT_STUB(ITTAPI, __itt_clock_domain*, clock_domain_create, (__itt_get_clock_info
 
 /**
  * @ingroup clockdomains
- * @brief Recalculate clock domains frequences and clock base timestamps.
+ * @brief Recalculate clock domains frequencies and clock base timestamps.
  */
 void ITTAPI __itt_clock_domain_reset(void);
 
@@ -2835,6 +2859,371 @@ ITT_STUBV(ITTAPI, void, task_end_ex,          (const __itt_domain *domain, __itt
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
+/**
+ * @defgroup counters Counters
+ * @ingroup public
+ * Counters are user-defined objects with a monotonically increasing
+ * value. Counter values are 64-bit unsigned integers.
+ * Counters have names that can be displayed in
+ * the tools.
+ * @{
+ */
+
+/**
+ * @brief opaque structure for counter identification
+ */
+/** @cond exclude_from_documentation */
+
+typedef struct ___itt_counter* __itt_counter;
+
+/**
+ * @brief Create an unsigned 64 bits integer counter with given name/domain
+ *
+ * After __itt_counter_create() is called, __itt_counter_inc(id), __itt_counter_inc_delta(id, delta),
+ * __itt_counter_set_value(id, value_ptr) or __itt_counter_set_value_ex(id, clock_domain, timestamp, value_ptr)
+ * can be used to change the value of the counter, where value_ptr is a pointer to an unsigned 64 bits integer
+ *
+ * The call is equal to __itt_counter_create_typed(name, domain, __itt_metadata_u64)
+ */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+__itt_counter ITTAPI __itt_counter_createA(const char    *name, const char    *domain);
+__itt_counter ITTAPI __itt_counter_createW(const wchar_t *name, const wchar_t *domain);
+#if defined(UNICODE) || defined(_UNICODE)
+#  define __itt_counter_create     __itt_counter_createW
+#  define __itt_counter_create_ptr __itt_counter_createW_ptr
+#else /* UNICODE */
+#  define __itt_counter_create     __itt_counter_createA
+#  define __itt_counter_create_ptr __itt_counter_createA_ptr
+#endif /* UNICODE */
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+__itt_counter ITTAPI __itt_counter_create(const char *name, const char *domain);
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+ITT_STUB(ITTAPI, __itt_counter, counter_createA, (const char    *name, const char    *domain))
+ITT_STUB(ITTAPI, __itt_counter, counter_createW, (const wchar_t *name, const wchar_t *domain))
+#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUB(ITTAPI, __itt_counter, counter_create,  (const char *name, const char *domain))
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_counter_createA     ITTNOTIFY_DATA(counter_createA)
+#define __itt_counter_createA_ptr ITTNOTIFY_NAME(counter_createA)
+#define __itt_counter_createW     ITTNOTIFY_DATA(counter_createW)
+#define __itt_counter_createW_ptr ITTNOTIFY_NAME(counter_createW)
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_counter_create     ITTNOTIFY_DATA(counter_create)
+#define __itt_counter_create_ptr ITTNOTIFY_NAME(counter_create)
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#else  /* INTEL_NO_ITTNOTIFY_API */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_counter_createA(name, domain)
+#define __itt_counter_createA_ptr 0
+#define __itt_counter_createW(name, domain)
+#define __itt_counter_createW_ptr 0
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_counter_create(name, domain)
+#define __itt_counter_create_ptr  0
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else  /* INTEL_NO_MACRO_BODY */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_counter_createA_ptr 0
+#define __itt_counter_createW_ptr 0
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_counter_create_ptr  0
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @brief Increment the unsigned 64 bits integer counter value
+ *
+ * Calling this function to non-unsigned 64 bits integer counters has no effect
+ */
+void ITTAPI __itt_counter_inc(__itt_counter id);
+
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, counter_inc, (__itt_counter id))
+#define __itt_counter_inc     ITTNOTIFY_VOID(counter_inc)
+#define __itt_counter_inc_ptr ITTNOTIFY_NAME(counter_inc)
+#else  /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_counter_inc(id)
+#define __itt_counter_inc_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else  /* INTEL_NO_MACRO_BODY */
+#define __itt_counter_inc_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+/**
+ * @brief Increment the unsigned 64 bits integer counter value with x
+ *
+ * Calling this function to non-unsigned 64 bits integer counters has no effect
+ */
+void ITTAPI __itt_counter_inc_delta(__itt_counter id, unsigned long long value);
+
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, counter_inc_delta, (__itt_counter id, unsigned long long value))
+#define __itt_counter_inc_delta     ITTNOTIFY_VOID(counter_inc_delta)
+#define __itt_counter_inc_delta_ptr ITTNOTIFY_NAME(counter_inc_delta)
+#else  /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_counter_inc_delta(id, value)
+#define __itt_counter_inc_delta_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else  /* INTEL_NO_MACRO_BODY */
+#define __itt_counter_inc_delta_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @brief Decrement the unsigned 64 bits integer counter value
+ *
+ * Calling this function to non-unsigned 64 bits integer counters has no effect
+ */
+void ITTAPI __itt_counter_dec(__itt_counter id);
+
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, counter_dec, (__itt_counter id))
+#define __itt_counter_dec     ITTNOTIFY_VOID(counter_dec)
+#define __itt_counter_dec_ptr ITTNOTIFY_NAME(counter_dec)
+#else  /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_counter_dec(id)
+#define __itt_counter_dec_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else  /* INTEL_NO_MACRO_BODY */
+#define __itt_counter_dec_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+/**
+ * @brief Decrement the unsigned 64 bits integer counter value with x
+ *
+ * Calling this function to non-unsigned 64 bits integer counters has no effect
+ */
+void ITTAPI __itt_counter_dec_delta(__itt_counter id, unsigned long long value);
+
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, counter_dec_delta, (__itt_counter id, unsigned long long value))
+#define __itt_counter_dec_delta     ITTNOTIFY_VOID(counter_dec_delta)
+#define __itt_counter_dec_delta_ptr ITTNOTIFY_NAME(counter_dec_delta)
+#else  /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_counter_dec_delta(id, value)
+#define __itt_counter_dec_delta_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else  /* INTEL_NO_MACRO_BODY */
+#define __itt_counter_dec_delta_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @ingroup counters
+ * @brief Increment a counter by one.
+ * The first call with a given name creates a counter by that name and sets its
+ * value to zero. Successive calls increment the counter value.
+ * @param[in] domain The domain controlling the call. Counter names are not domain specific.
+ *            The domain argument is used only to enable or disable the API calls.
+ * @param[in] name The name of the counter
+ */
+void ITTAPI __itt_counter_inc_v3(const __itt_domain *domain, __itt_string_handle *name);
+
+/**
+ * @ingroup counters
+ * @brief Increment a counter by the value specified in delta.
+ * @param[in] domain The domain controlling the call. Counter names are not domain specific.
+ *            The domain argument is used only to enable or disable the API calls.
+ * @param[in] name The name of the counter
+ * @param[in] delta The amount by which to increment the counter
+ */
+void ITTAPI __itt_counter_inc_delta_v3(const __itt_domain *domain, __itt_string_handle *name, unsigned long long delta);
+
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, counter_inc_v3,       (const __itt_domain *domain, __itt_string_handle *name))
+ITT_STUBV(ITTAPI, void, counter_inc_delta_v3, (const __itt_domain *domain, __itt_string_handle *name, unsigned long long delta))
+#define __itt_counter_inc_v3(d,x)         ITTNOTIFY_VOID_D1(counter_inc_v3,d,x)
+#define __itt_counter_inc_v3_ptr          ITTNOTIFY_NAME(counter_inc_v3)
+#define __itt_counter_inc_delta_v3(d,x,y) ITTNOTIFY_VOID_D2(counter_inc_delta_v3,d,x,y)
+#define __itt_counter_inc_delta_v3_ptr    ITTNOTIFY_NAME(counter_inc_delta_v3)
+#else  /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_counter_inc_v3(domain,name)
+#define __itt_counter_inc_v3_ptr       0
+#define __itt_counter_inc_delta_v3(domain,name,delta)
+#define __itt_counter_inc_delta_v3_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else  /* INTEL_NO_MACRO_BODY */
+#define __itt_counter_inc_v3_ptr       0
+#define __itt_counter_inc_delta_v3_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+
+/**
+ * @ingroup counters
+ * @brief Decrement a counter by one.
+ * The first call with a given name creates a counter by that name and sets its
+ * value to zero. Successive calls decrement the counter value.
+ * @param[in] domain The domain controlling the call. Counter names are not domain specific.
+ *            The domain argument is used only to enable or disable the API calls.
+ * @param[in] name The name of the counter
+ */
+void ITTAPI __itt_counter_dec_v3(const __itt_domain *domain, __itt_string_handle *name);
+
+/**
+ * @ingroup counters
+ * @brief Decrement a counter by the value specified in delta.
+ * @param[in] domain The domain controlling the call. Counter names are not domain specific.
+ *            The domain argument is used only to enable or disable the API calls.
+ * @param[in] name The name of the counter
+ * @param[in] delta The amount by which to decrement the counter
+ */
+void ITTAPI __itt_counter_dec_delta_v3(const __itt_domain *domain, __itt_string_handle *name, unsigned long long delta);
+
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, counter_dec_v3,       (const __itt_domain *domain, __itt_string_handle *name))
+ITT_STUBV(ITTAPI, void, counter_dec_delta_v3, (const __itt_domain *domain, __itt_string_handle *name, unsigned long long delta))
+#define __itt_counter_dec_v3(d,x)         ITTNOTIFY_VOID_D1(counter_dec_v3,d,x)
+#define __itt_counter_dec_v3_ptr          ITTNOTIFY_NAME(counter_dec_v3)
+#define __itt_counter_dec_delta_v3(d,x,y) ITTNOTIFY_VOID_D2(counter_dec_delta_v3,d,x,y)
+#define __itt_counter_dec_delta_v3_ptr    ITTNOTIFY_NAME(counter_dec_delta_v3)
+#else  /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_counter_dec_v3(domain,name)
+#define __itt_counter_dec_v3_ptr       0
+#define __itt_counter_dec_delta_v3(domain,name,delta)
+#define __itt_counter_dec_delta_v3_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else  /* INTEL_NO_MACRO_BODY */
+#define __itt_counter_dec_v3_ptr       0
+#define __itt_counter_dec_delta_v3_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/** @} counters group */
+
+
+/**
+ * @brief Set the counter value
+ */
+void ITTAPI __itt_counter_set_value(__itt_counter id, void *value_ptr);
+
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, counter_set_value, (__itt_counter id, void *value_ptr))
+#define __itt_counter_set_value     ITTNOTIFY_VOID(counter_set_value)
+#define __itt_counter_set_value_ptr ITTNOTIFY_NAME(counter_set_value)
+#else  /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_counter_set_value(id, value_ptr)
+#define __itt_counter_set_value_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else  /* INTEL_NO_MACRO_BODY */
+#define __itt_counter_set_value_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @brief Set the counter value
+ */
+void ITTAPI __itt_counter_set_value_ex(__itt_counter id, __itt_clock_domain *clock_domain, unsigned long long timestamp, void *value_ptr);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, counter_set_value_ex, (__itt_counter id, __itt_clock_domain *clock_domain, unsigned long long timestamp, void *value_ptr))
+#define __itt_counter_set_value_ex     ITTNOTIFY_VOID(counter_set_value_ex)
+#define __itt_counter_set_value_ex_ptr ITTNOTIFY_NAME(counter_set_value_ex)
+#else  /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_counter_set_value_ex(id, clock_domain, timestamp, value_ptr)
+#define __itt_counter_set_value_ex_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else  /* INTEL_NO_MACRO_BODY */
+#define __itt_counter_set_value_ex_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @brief Create a typed counter with given name/domain
+ *
+ * After __itt_counter_create_typed() is called, __itt_counter_inc(id), __itt_counter_inc_delta(id, delta),
+ * __itt_counter_set_value(id, value_ptr) or __itt_counter_set_value_ex(id, clock_domain, timestamp, value_ptr)
+ * can be used to change the value of the counter
+ */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+__itt_counter ITTAPI __itt_counter_create_typedA(const char    *name, const char    *domain, __itt_metadata_type type);
+__itt_counter ITTAPI __itt_counter_create_typedW(const wchar_t *name, const wchar_t *domain, __itt_metadata_type type);
+#if defined(UNICODE) || defined(_UNICODE)
+#  define __itt_counter_create_typed     __itt_counter_create_typedW
+#  define __itt_counter_create_typed_ptr __itt_counter_create_typedW_ptr
+#else /* UNICODE */
+#  define __itt_counter_create_typed     __itt_counter_create_typedA
+#  define __itt_counter_create_typed_ptr __itt_counter_create_typedA_ptr
+#endif /* UNICODE */
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+__itt_counter ITTAPI __itt_counter_create_typed(const char *name, const char *domain, __itt_metadata_type type);
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+ITT_STUB(ITTAPI, __itt_counter, counter_create_typedA, (const char    *name, const char    *domain, __itt_metadata_type type))
+ITT_STUB(ITTAPI, __itt_counter, counter_create_typedW, (const wchar_t *name, const wchar_t *domain, __itt_metadata_type type))
+#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUB(ITTAPI, __itt_counter, counter_create_typed,  (const char *name, const char *domain, __itt_metadata_type type))
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_counter_create_typedA     ITTNOTIFY_DATA(counter_create_typedA)
+#define __itt_counter_create_typedA_ptr ITTNOTIFY_NAME(counter_create_typedA)
+#define __itt_counter_create_typedW     ITTNOTIFY_DATA(counter_create_typedW)
+#define __itt_counter_create_typedW_ptr ITTNOTIFY_NAME(counter_create_typedW)
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_counter_create_typed     ITTNOTIFY_DATA(counter_create_typed)
+#define __itt_counter_create_typed_ptr ITTNOTIFY_NAME(counter_create_typed)
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#else  /* INTEL_NO_ITTNOTIFY_API */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_counter_create_typedA(name, domain, type)
+#define __itt_counter_create_typedA_ptr 0
+#define __itt_counter_create_typedW(name, domain, type)
+#define __itt_counter_create_typedW_ptr 0
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_counter_create_typed(name, domain, type)
+#define __itt_counter_create_typed_ptr  0
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else  /* INTEL_NO_MACRO_BODY */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_counter_create_typedA_ptr 0
+#define __itt_counter_create_typedW_ptr 0
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_counter_create_typed_ptr  0
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @brief Destroy the counter identified by the pointer previously returned by __itt_counter_create() or
+ * __itt_counter_create_typed()
+ */
+void ITTAPI __itt_counter_destroy(__itt_counter id);
+
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, counter_destroy, (__itt_counter id))
+#define __itt_counter_destroy     ITTNOTIFY_VOID(counter_destroy)
+#define __itt_counter_destroy_ptr ITTNOTIFY_NAME(counter_destroy)
+#else  /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_counter_destroy(id)
+#define __itt_counter_destroy_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else  /* INTEL_NO_MACRO_BODY */
+#define __itt_counter_destroy_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+/** @} counters group */
+
 /**
  * @ingroup markers
  * @brief Create a marker instance.
@@ -3248,6 +3637,67 @@ ITT_STUBV(ITTAPI, void, enable_attach, (void))
 
 /** @endcond */
 
+/**
+ * @brief Module load info
+ * This API is used to report necessary information in case of module relocation
+ * @param[in] start_addr - relocated module start address
+ * @param[in] end_addr - relocated module end address
+ * @param[in] path - file system path to the module
+ */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+void ITTAPI __itt_module_loadA(void *start_addr, void *end_addr, const char *path);
+void ITTAPI __itt_module_loadW(void *start_addr, void *end_addr, const wchar_t *path);
+#if defined(UNICODE) || defined(_UNICODE)
+#  define __itt_module_load     __itt_module_loadW
+#  define __itt_module_load_ptr __itt_module_loadW_ptr
+#else /* UNICODE */
+#  define __itt_module_load     __itt_module_loadA
+#  define __itt_module_load_ptr __itt_module_loadA_ptr
+#endif /* UNICODE */
+#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+void ITTAPI __itt_module_load(void *start_addr, void *end_addr, const char *path);
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+ITT_STUB(ITTAPI, void, module_loadA, (void *start_addr, void *end_addr, const char *path))
+ITT_STUB(ITTAPI, void, module_loadW, (void *start_addr, void *end_addr, const wchar_t *path))
+#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUB(ITTAPI, void, module_load,  (void *start_addr, void *end_addr, const char *path))
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_module_loadA     ITTNOTIFY_VOID(module_loadA)
+#define __itt_module_loadA_ptr ITTNOTIFY_NAME(module_loadA)
+#define __itt_module_loadW     ITTNOTIFY_VOID(module_loadW)
+#define __itt_module_loadW_ptr ITTNOTIFY_NAME(module_loadW)
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_module_load     ITTNOTIFY_VOID(module_load)
+#define __itt_module_load_ptr ITTNOTIFY_NAME(module_load)
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#else  /* INTEL_NO_ITTNOTIFY_API */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_module_loadA(start_addr, end_addr, path)
+#define __itt_module_loadA_ptr 0
+#define __itt_module_loadW(start_addr, end_addr, path)
+#define __itt_module_loadW_ptr 0
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_module_load(start_addr, end_addr, path)
+#define __itt_module_load_ptr 0
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else  /* INTEL_NO_MACRO_BODY */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_module_loadA_ptr 0
+#define __itt_module_loadW_ptr 0
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_module_load_ptr  0
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+
 
 #ifdef __cplusplus
 }
@@ -3561,130 +4011,7 @@ ITT_STUB(ITTAPI, int, mark_global_off, (__itt_mark_type mt))
  * Counters group
  * @{
  */
-/**
- * @brief opaque structure for counter identification
- */
-typedef struct ___itt_counter *__itt_counter;
-
-/**
- * @brief Create a counter with given name/domain for the calling thread
- *
- * After __itt_counter_create() is called, __itt_counter_inc() / __itt_counter_inc_delta() can be used
- * to increment the counter on any thread
- */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-__itt_counter ITTAPI __itt_counter_createA(const char    *name, const char    *domain);
-__itt_counter ITTAPI __itt_counter_createW(const wchar_t *name, const wchar_t *domain);
-#if defined(UNICODE) || defined(_UNICODE)
-#  define __itt_counter_create     __itt_counter_createW
-#  define __itt_counter_create_ptr __itt_counter_createW_ptr
-#else /* UNICODE */
-#  define __itt_counter_create     __itt_counter_createA
-#  define __itt_counter_create_ptr __itt_counter_createA_ptr
-#endif /* UNICODE */
-#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-__itt_counter ITTAPI __itt_counter_create(const char *name, const char *domain);
-#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 
-/** @cond exclude_from_documentation */
-#ifndef INTEL_NO_MACRO_BODY
-#ifndef INTEL_NO_ITTNOTIFY_API
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-ITT_STUB(ITTAPI, __itt_counter, counter_createA, (const char    *name, const char    *domain))
-ITT_STUB(ITTAPI, __itt_counter, counter_createW, (const wchar_t *name, const wchar_t *domain))
-#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-ITT_STUB(ITTAPI, __itt_counter, counter_create,  (const char *name, const char *domain))
-#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-#define __itt_counter_createA     ITTNOTIFY_DATA(counter_createA)
-#define __itt_counter_createA_ptr ITTNOTIFY_NAME(counter_createA)
-#define __itt_counter_createW     ITTNOTIFY_DATA(counter_createW)
-#define __itt_counter_createW_ptr ITTNOTIFY_NAME(counter_createW)
-#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#define __itt_counter_create     ITTNOTIFY_DATA(counter_create)
-#define __itt_counter_create_ptr ITTNOTIFY_NAME(counter_create)
-#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#else  /* INTEL_NO_ITTNOTIFY_API */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-#define __itt_counter_createA(name, domain)
-#define __itt_counter_createA_ptr 0
-#define __itt_counter_createW(name, domain)
-#define __itt_counter_createW_ptr 0
-#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#define __itt_counter_create(name, domain)
-#define __itt_counter_create_ptr  0
-#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-#define __itt_counter_createA_ptr 0
-#define __itt_counter_createW_ptr 0
-#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#define __itt_counter_create_ptr  0
-#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#endif /* INTEL_NO_MACRO_BODY */
-/** @endcond */
-
-/**
- * @brief Destroy the counter identified by the pointer previously returned by __itt_counter_create()
- */
-void ITTAPI __itt_counter_destroy(__itt_counter id);
-
-/** @cond exclude_from_documentation */
-#ifndef INTEL_NO_MACRO_BODY
-#ifndef INTEL_NO_ITTNOTIFY_API
-ITT_STUBV(ITTAPI, void, counter_destroy, (__itt_counter id))
-#define __itt_counter_destroy     ITTNOTIFY_VOID(counter_destroy)
-#define __itt_counter_destroy_ptr ITTNOTIFY_NAME(counter_destroy)
-#else  /* INTEL_NO_ITTNOTIFY_API */
-#define __itt_counter_destroy(id)
-#define __itt_counter_destroy_ptr 0
-#endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
-#define __itt_counter_destroy_ptr 0
-#endif /* INTEL_NO_MACRO_BODY */
-/** @endcond */
-
-/**
- * @brief Increment the counter value
- */
-void ITTAPI __itt_counter_inc(__itt_counter id);
-
-/** @cond exclude_from_documentation */
-#ifndef INTEL_NO_MACRO_BODY
-#ifndef INTEL_NO_ITTNOTIFY_API
-ITT_STUBV(ITTAPI, void, counter_inc, (__itt_counter id))
-#define __itt_counter_inc     ITTNOTIFY_VOID(counter_inc)
-#define __itt_counter_inc_ptr ITTNOTIFY_NAME(counter_inc)
-#else  /* INTEL_NO_ITTNOTIFY_API */
-#define __itt_counter_inc(id)
-#define __itt_counter_inc_ptr 0
-#endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
-#define __itt_counter_inc_ptr 0
-#endif /* INTEL_NO_MACRO_BODY */
-/** @endcond */
-
-/**
- * @brief Increment the counter value with x
- */
-void ITTAPI __itt_counter_inc_delta(__itt_counter id, unsigned long long value);
-
-/** @cond exclude_from_documentation */
-#ifndef INTEL_NO_MACRO_BODY
-#ifndef INTEL_NO_ITTNOTIFY_API
-ITT_STUBV(ITTAPI, void, counter_inc_delta, (__itt_counter id, unsigned long long value))
-#define __itt_counter_inc_delta     ITTNOTIFY_VOID(counter_inc_delta)
-#define __itt_counter_inc_delta_ptr ITTNOTIFY_NAME(counter_inc_delta)
-#else  /* INTEL_NO_ITTNOTIFY_API */
-#define __itt_counter_inc_delta(id, value)
-#define __itt_counter_inc_delta_ptr 0
-#endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
-#define __itt_counter_inc_delta_ptr 0
-#endif /* INTEL_NO_MACRO_BODY */
-/** @endcond */
-/** @} counters group */
 
 /**
  * @defgroup stitch Stack Stitching
@@ -3719,7 +4046,7 @@ ITT_STUB(ITTAPI, __itt_caller, stack_caller_create, (void))
 /** @endcond */
 
 /**
- * @brief Destroy the inforamtion about stitch point identified by the pointer previously returned by __itt_stack_caller_create()
+ * @brief Destroy the information about stitch point identified by the pointer previously returned by __itt_stack_caller_create()
  */
 void ITTAPI __itt_stack_caller_destroy(__itt_caller id);
 
diff --git a/src/tbb/src/tbb/tools_api/ittnotify_config.h b/src/tbb/src/tbb/tools_api/ittnotify_config.h
index 1f90963b..bdb4ec29 100644
--- a/src/tbb/src/tbb/tools_api/ittnotify_config.h
+++ b/src/tbb/src/tbb/tools_api/ittnotify_config.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef _ITTNOTIFY_CONFIG_H_
@@ -92,17 +88,17 @@
 #endif /* UNICODE || _UNICODE */
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 
-#ifndef CDECL
+#ifndef ITTAPI_CDECL
 #  if ITT_PLATFORM==ITT_PLATFORM_WIN
-#    define CDECL __cdecl
+#    define ITTAPI_CDECL __cdecl
 #  else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #    if defined _M_IX86 || defined __i386__
-#      define CDECL __attribute__ ((cdecl))
+#      define ITTAPI_CDECL __attribute__ ((cdecl))
 #    else  /* _M_IX86 || __i386__ */
-#      define CDECL /* actual only on x86 platform */
+#      define ITTAPI_CDECL /* actual only on x86 platform */
 #    endif /* _M_IX86 || __i386__ */
 #  endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#endif /* CDECL */
+#endif /* ITTAPI_CDECL */
 
 #ifndef STDCALL
 #  if ITT_PLATFORM==ITT_PLATFORM_WIN
@@ -116,12 +112,12 @@
 #  endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #endif /* STDCALL */
 
-#define ITTAPI    CDECL
-#define LIBITTAPI CDECL
+#define ITTAPI    ITTAPI_CDECL
+#define LIBITTAPI ITTAPI_CDECL
 
 /* TODO: Temporary for compatibility! */
-#define ITTAPI_CALL    CDECL
-#define LIBITTAPI_CALL CDECL
+#define ITTAPI_CALL    ITTAPI_CDECL
+#define LIBITTAPI_CALL ITTAPI_CDECL
 
 #if ITT_PLATFORM==ITT_PLATFORM_WIN
 /* use __forceinline (VC++ specific) */
@@ -166,7 +162,7 @@
 #    define ITT_ARCH ITT_ARCH_IA32E
 #  elif defined _M_IA64 || defined __ia64__
 #    define ITT_ARCH ITT_ARCH_IA64
-#  elif defined _M_ARM || __arm__
+#  elif defined _M_ARM || defined __arm__
 #    define ITT_ARCH ITT_ARCH_ARM
 #  elif defined __powerpc64__
 #    define ITT_ARCH ITT_ARCH_PPC64
@@ -196,7 +192,7 @@
 #define ITT_MAGIC { 0xED, 0xAB, 0xAB, 0xEC, 0x0D, 0xEE, 0xDA, 0x30 }
 
 /* Replace with snapshot date YYYYMMDD for promotion build. */
-#define API_VERSION_BUILD    20111111
+#define API_VERSION_BUILD    20180723
 
 #ifndef API_VERSION_NUM
 #define API_VERSION_NUM 0.0.0
@@ -256,6 +252,10 @@ ITT_INLINE long __itt_interlocked_increment(volatile long* ptr)
     return InterlockedIncrement(ptr);
 }
 #endif /* ITT_SIMPLE_INIT */
+
+#define DL_SYMBOLS (1)
+#define PTHREAD_SYMBOLS (1)
+
 #else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
 #define __itt_get_proc(lib, name) dlsym(lib, name)
 #define __itt_mutex_init(mutex)   {\
@@ -294,7 +294,16 @@ ITT_INLINE long __itt_interlocked_increment(volatile long* ptr)
 #ifdef SDL_STRNCPY_S
 #define __itt_fstrcpyn(s1, b, s2, l) SDL_STRNCPY_S(s1, b, s2, l)
 #else
-#define __itt_fstrcpyn(s1, b, s2, l) memcpy(s1, s2, l)
+#define __itt_fstrcpyn(s1, b, s2, l) {                                      \
+    if (b > 0) {                                                            \
+        /* 'volatile' is used to suppress the warning that a destination */ \
+        /*  bound depends on the length of the source.                   */ \
+        volatile size_t num_to_copy = (size_t)(b - 1) < (size_t)(l) ?       \
+                (size_t)(b - 1) : (size_t)(l);                              \
+        strncpy(s1, s2, num_to_copy);                                       \
+        s1[num_to_copy] = 0;                                                \
+    }                                                                       \
+}
 #endif /* SDL_STRNCPY_S */
 
 #define __itt_fstrdup(s)          strdup(s)
@@ -329,6 +338,22 @@ ITT_INLINE long __itt_interlocked_increment(volatile long* ptr)
     return __TBB_machine_fetchadd4(ptr, 1) + 1L;
 }
 #endif /* ITT_SIMPLE_INIT */
+
+void* dlopen(const char*, int) __attribute__((weak));
+void* dlsym(void*, const char*) __attribute__((weak));
+int dlclose(void*) __attribute__((weak));
+#define DL_SYMBOLS (dlopen && dlsym && dlclose)
+
+int pthread_mutex_init(pthread_mutex_t*, const pthread_mutexattr_t*) __attribute__((weak));
+int pthread_mutex_lock(pthread_mutex_t*) __attribute__((weak));
+int pthread_mutex_unlock(pthread_mutex_t*) __attribute__((weak));
+int pthread_mutex_destroy(pthread_mutex_t*) __attribute__((weak));
+int pthread_mutexattr_init(pthread_mutexattr_t*) __attribute__((weak));
+int pthread_mutexattr_settype(pthread_mutexattr_t*, int) __attribute__((weak));
+int pthread_mutexattr_destroy(pthread_mutexattr_t*) __attribute__((weak));
+pthread_t pthread_self(void) __attribute__((weak));
+#define PTHREAD_SYMBOLS (pthread_mutex_init && pthread_mutex_lock && pthread_mutex_unlock && pthread_mutex_destroy && pthread_mutexattr_init && pthread_mutexattr_settype && pthread_mutexattr_destroy && pthread_self)
+
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 
 typedef enum {
@@ -377,6 +402,27 @@ typedef struct ___itt_api_info
     __itt_group_id group;
 }  __itt_api_info;
 
+typedef struct __itt_counter_info
+{
+    const char* nameA;  /*!< Copy of original name in ASCII. */
+#if defined(UNICODE) || defined(_UNICODE)
+    const wchar_t* nameW; /*!< Copy of original name in UNICODE. */
+#else  /* UNICODE || _UNICODE */
+    void* nameW;
+#endif /* UNICODE || _UNICODE */
+    const char* domainA;  /*!< Copy of original name in ASCII. */
+#if defined(UNICODE) || defined(_UNICODE)
+    const wchar_t* domainW; /*!< Copy of original name in UNICODE. */
+#else  /* UNICODE || _UNICODE */
+    void* domainW;
+#endif /* UNICODE || _UNICODE */
+    int type;
+    long index;
+    int   extra1; /*!< Reserved to the runtime */
+    void* extra2; /*!< Reserved to the runtime */
+    struct __itt_counter_info* next;
+}  __itt_counter_info_t;
+
 struct ___itt_domain;
 struct ___itt_string_handle;
 
@@ -400,6 +446,8 @@ typedef struct ___itt_global
     struct ___itt_domain*  domain_list;
     struct ___itt_string_handle* string_list;
     __itt_collection_state state;
+    __itt_counter_info_t* counter_list;
+    unsigned int           ipt_collect_events;
 } __itt_global;
 
 #pragma pack(pop)
@@ -500,4 +548,38 @@ typedef struct ___itt_global
     } \
 }
 
+#define NEW_COUNTER_W(gptr,h,h_tail,name,domain,type) { \
+    h = (__itt_counter_info_t*)malloc(sizeof(__itt_counter_info_t)); \
+    if (h != NULL) { \
+        h->nameA   = NULL; \
+        h->nameW   = name ? _wcsdup(name) : NULL; \
+        h->domainA   = NULL; \
+        h->domainW   = name ? _wcsdup(domain) : NULL; \
+        h->type = type; \
+        h->index = 0; \
+        h->next   = NULL; \
+        if (h_tail == NULL) \
+            (gptr)->counter_list = h; \
+        else \
+            h_tail->next = h; \
+    } \
+}
+
+#define NEW_COUNTER_A(gptr,h,h_tail,name,domain,type) { \
+    h = (__itt_counter_info_t*)malloc(sizeof(__itt_counter_info_t)); \
+    if (h != NULL) { \
+        h->nameA   = name ? __itt_fstrdup(name) : NULL; \
+        h->nameW   = NULL; \
+        h->domainA   = domain ? __itt_fstrdup(domain) : NULL; \
+        h->domainW   = NULL; \
+        h->type = type; \
+        h->index = 0; \
+        h->next   = NULL; \
+        if (h_tail == NULL) \
+            (gptr)->counter_list = h; \
+        else \
+            h_tail->next = h; \
+    } \
+}
+
 #endif /* _ITTNOTIFY_CONFIG_H_ */
diff --git a/src/tbb/src/tbb/tools_api/ittnotify_static.c b/src/tbb/src/tbb/tools_api/ittnotify_static.c
index c0867459..05146973 100644
--- a/src/tbb/src/tbb/tools_api/ittnotify_static.c
+++ b/src/tbb/src/tbb/tools_api/ittnotify_static.c
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 "ittnotify_config.h"
@@ -32,14 +28,14 @@
 #include <stdarg.h>
 #include <string.h>
 
-#define INTEL_NO_MACRO_BODY 
+#define INTEL_NO_MACRO_BODY
 #define INTEL_ITTNOTIFY_API_PRIVATE
 #include "ittnotify.h"
 #include "legacy/ittnotify.h"
 
 #include "disable_warnings.h"
 
-static const char api_version[] = API_VERSION "\0\n@(#) $Revision: 413915 $\n";
+static const char api_version[] = API_VERSION "\0\n@(#) $Revision$\n";
 
 #define _N_(n) ITT_JOIN(INTEL_ITTNOTIFY_PREFIX,n)
 
@@ -97,6 +93,8 @@ static const char* ittnotify_lib_name = "libittnotify.dylib";
 #endif /* LIB_VAR_NAME */
 
 #define ITT_MUTEX_INIT_AND_LOCK(p) {                                 \
+    if (PTHREAD_SYMBOLS)                                             \
+    {                                                                \
         if (!p.mutex_initialized)                                    \
         {                                                            \
             if (__itt_interlocked_increment(&p.atomic_counter) == 1) \
@@ -109,6 +107,7 @@ static const char* ittnotify_lib_name = "libittnotify.dylib";
                     __itt_thread_yield();                            \
         }                                                            \
         __itt_mutex_lock(&p.mutex);                                  \
+    }                                                                \
 }
 
 const int _N_(err) = 0;
@@ -131,6 +130,8 @@ static __itt_fini_ittlib_t* __itt_fini_ittlib_ptr = _N_(fini_ittlib);
 #define __itt_fini_ittlib_name __itt_fini_ittlib_ptr
 #endif /* __itt_fini_ittlib_name */
 
+extern __itt_global _N_(_ittapi_global);
+
 /* building pointers to imported funcs */
 #undef ITT_STUBV
 #undef ITT_STUB
@@ -140,7 +141,8 @@ typedef type api ITT_JOIN(_N_(name),_t) args;                  \
 ITT_EXTERN_C_BEGIN ITT_JOIN(_N_(name),_t)* ITTNOTIFY_NAME(name) = ITT_VERSIONIZE(ITT_JOIN(_N_(name),_init)); ITT_EXTERN_C_END \
 static type api ITT_VERSIONIZE(ITT_JOIN(_N_(name),_init)) args \
 {                                                              \
-    __itt_init_ittlib_name(NULL, __itt_group_all);             \
+    if (!_N_(_ittapi_global).api_initialized && _N_(_ittapi_global).thread_list == NULL) \
+        __itt_init_ittlib_name(NULL, __itt_group_all);         \
     if (ITTNOTIFY_NAME(name) && ITTNOTIFY_NAME(name) != ITT_VERSIONIZE(ITT_JOIN(_N_(name),_init))) \
         return ITTNOTIFY_NAME(name) params;                    \
     else                                                       \
@@ -153,7 +155,8 @@ typedef type api ITT_JOIN(_N_(name),_t) args;                  \
 ITT_EXTERN_C_BEGIN ITT_JOIN(_N_(name),_t)* ITTNOTIFY_NAME(name) = ITT_VERSIONIZE(ITT_JOIN(_N_(name),_init)); ITT_EXTERN_C_END \
 static type api ITT_VERSIONIZE(ITT_JOIN(_N_(name),_init)) args \
 {                                                              \
-    __itt_init_ittlib_name(NULL, __itt_group_all);             \
+    if (!_N_(_ittapi_global).api_initialized && _N_(_ittapi_global).thread_list == NULL) \
+        __itt_init_ittlib_name(NULL, __itt_group_all);         \
     if (ITTNOTIFY_NAME(name) && ITTNOTIFY_NAME(name) != ITT_VERSIONIZE(ITT_JOIN(_N_(name),_init))) \
         ITTNOTIFY_NAME(name) params;                           \
     else                                                       \
@@ -243,7 +246,9 @@ __itt_global _N_(_ittapi_global) = {
     NULL,                                          /* thread_list */
     NULL,                                          /* domain_list */
     NULL,                                          /* string_list */
-    __itt_collection_normal                        /* collection state */
+    __itt_collection_normal,                       /* collection state */
+    NULL,                                          /* counter_list */
+    0                                              /* ipt_collect_events */
 };
 
 typedef void (__itt_api_init_t)(__itt_global*, __itt_group_id);
@@ -310,7 +315,7 @@ static __itt_domain* ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(domain_createW),_init))(
     {
         NEW_DOMAIN_W(&_N_(_ittapi_global),h,h_tail,name);
     }
-    __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
+    if (PTHREAD_SYMBOLS) __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
     return h;
 }
 
@@ -338,7 +343,7 @@ static __itt_domain* ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(domain_create),_init))(c
 #else
         if (ITTNOTIFY_NAME(domain_create) && ITTNOTIFY_NAME(domain_create) != ITT_VERSIONIZE(ITT_JOIN(_N_(domain_create),_init)))
         {
-            __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
+            if (PTHREAD_SYMBOLS) __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
             return ITTNOTIFY_NAME(domain_create)(name);
         }
 #endif
@@ -351,7 +356,7 @@ static __itt_domain* ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(domain_create),_init))(c
     {
         NEW_DOMAIN_A(&_N_(_ittapi_global),h,h_tail,name);
     }
-    __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
+    if (PTHREAD_SYMBOLS) __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
     return h;
 }
 
@@ -378,7 +383,7 @@ static __itt_string_handle* ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(string_handle_cre
     {
         if (h->strW != NULL && !wcscmp(h->strW, name)) break;
     }
-    if (h == NULL) 
+    if (h == NULL)
     {
         NEW_STRING_HANDLE_W(&_N_(_ittapi_global),h,h_tail,name);
     }
@@ -410,7 +415,7 @@ static __itt_string_handle* ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(string_handle_cre
 #else
         if (ITTNOTIFY_NAME(string_handle_create) && ITTNOTIFY_NAME(string_handle_create) != ITT_VERSIONIZE(ITT_JOIN(_N_(string_handle_create),_init)))
         {
-            __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
+            if (PTHREAD_SYMBOLS) __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
             return ITTNOTIFY_NAME(string_handle_create)(name);
         }
 #endif
@@ -423,10 +428,162 @@ static __itt_string_handle* ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(string_handle_cre
     {
         NEW_STRING_HANDLE_A(&_N_(_ittapi_global),h,h_tail,name);
     }
-    __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
+    if (PTHREAD_SYMBOLS) __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
     return h;
 }
 
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+static __itt_counter ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(counter_createW),_init))(const wchar_t *name, const wchar_t *domain)
+{
+    __itt_counter_info_t *h_tail = NULL, *h = NULL;
+    __itt_metadata_type type = __itt_metadata_u64;
+
+    if (name == NULL)
+    {
+        return NULL;
+    }
+
+    ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global));
+    if (_N_(_ittapi_global).api_initialized)
+    {
+        if (ITTNOTIFY_NAME(counter_createW) && ITTNOTIFY_NAME(counter_createW) != ITT_VERSIONIZE(ITT_JOIN(_N_(counter_createW),_init)))
+        {
+            __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
+            return ITTNOTIFY_NAME(counter_createW)(name, domain);
+        }
+    }
+    for (h_tail = NULL, h = _N_(_ittapi_global).counter_list; h != NULL; h_tail = h, h = h->next)
+    {
+        if (h->nameW != NULL  && h->type == type && !wcscmp(h->nameW, name) && ((h->domainW == NULL && domain == NULL) ||
+            (h->domainW != NULL && domain != NULL && !wcscmp(h->domainW, domain)))) break;
+
+    }
+    if (h == NULL)
+    {
+        NEW_COUNTER_W(&_N_(_ittapi_global),h,h_tail,name,domain,type);
+    }
+    __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
+    return (__itt_counter)h;
+}
+
+static __itt_counter ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(counter_createA),_init))(const char *name, const char *domain)
+#else  /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
+static __itt_counter ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(counter_create),_init))(const char *name, const char *domain)
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+{
+    __itt_counter_info_t *h_tail = NULL, *h = NULL;
+    __itt_metadata_type type = __itt_metadata_u64;
+
+    if (name == NULL)
+    {
+        return NULL;
+    }
+
+    ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global));
+    if (_N_(_ittapi_global).api_initialized)
+    {
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+        if (ITTNOTIFY_NAME(counter_createA) && ITTNOTIFY_NAME(counter_createA) != ITT_VERSIONIZE(ITT_JOIN(_N_(counter_createA),_init)))
+        {
+    __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
+            return ITTNOTIFY_NAME(counter_createA)(name, domain);
+        }
+#else
+        if (ITTNOTIFY_NAME(counter_create) && ITTNOTIFY_NAME(counter_create) != ITT_VERSIONIZE(ITT_JOIN(_N_(counter_create),_init)))
+        {
+            if (PTHREAD_SYMBOLS) __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
+            return ITTNOTIFY_NAME(counter_create)(name, domain);
+        }
+#endif
+    }
+    for (h_tail = NULL, h = _N_(_ittapi_global).counter_list; h != NULL; h_tail = h, h = h->next)
+    {
+        if (h->nameA != NULL  && h->type == type && !__itt_fstrcmp(h->nameA, name) && ((h->domainA == NULL && domain == NULL) || 
+            (h->domainA != NULL && domain != NULL && !__itt_fstrcmp(h->domainA, domain)))) break;
+    }
+    if (h == NULL)
+    {
+       NEW_COUNTER_A(&_N_(_ittapi_global),h,h_tail,name,domain,type);
+    }
+    if (PTHREAD_SYMBOLS) __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
+    return (__itt_counter)h;
+}
+
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+static __itt_counter ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(counter_create_typedW),_init))(const wchar_t *name, const wchar_t *domain, __itt_metadata_type type)
+{
+    __itt_counter_info_t *h_tail = NULL, *h = NULL;
+
+    if (name == NULL)
+    {
+        return NULL;
+    }
+
+    ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global));
+    if (_N_(_ittapi_global).api_initialized)
+    {
+        if (ITTNOTIFY_NAME(counter_create_typedW) && ITTNOTIFY_NAME(counter_create_typedW) != ITT_VERSIONIZE(ITT_JOIN(_N_(counter_create_typedW),_init)))
+        {
+            __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
+            return ITTNOTIFY_NAME(counter_create_typedW)(name, domain, type);
+        }
+    }
+    for (h_tail = NULL, h = _N_(_ittapi_global).counter_list; h != NULL; h_tail = h, h = h->next)
+    {
+        if (h->nameW != NULL  && h->type == type && !wcscmp(h->nameW, name) && ((h->domainW == NULL && domain == NULL) ||
+            (h->domainW != NULL && domain != NULL && !wcscmp(h->domainW, domain)))) break;
+
+    }
+    if (h == NULL)
+    {
+        NEW_COUNTER_W(&_N_(_ittapi_global),h,h_tail,name,domain,type);
+    }
+    __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
+    return (__itt_counter)h;
+}
+
+static __itt_counter ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(counter_create_typedA),_init))(const char *name, const char *domain, __itt_metadata_type type)
+#else  /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
+static __itt_counter ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(counter_create_typed),_init))(const char *name, const char *domain, __itt_metadata_type type)
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+{
+    __itt_counter_info_t *h_tail = NULL, *h = NULL;
+
+    if (name == NULL)
+    {
+        return NULL;
+    }
+
+    ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global));
+    if (_N_(_ittapi_global).api_initialized)
+    {
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+        if (ITTNOTIFY_NAME(counter_create_typedA) && ITTNOTIFY_NAME(counter_create_typedA) != ITT_VERSIONIZE(ITT_JOIN(_N_(counter_create_typedA),_init)))
+        {
+            __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
+            return ITTNOTIFY_NAME(counter_create_typedA)(name, domain, type);
+        }
+#else
+        if (ITTNOTIFY_NAME(counter_create_typed) && ITTNOTIFY_NAME(counter_create_typed) != ITT_VERSIONIZE(ITT_JOIN(_N_(counter_create_typed),_init)))
+        {
+            if (PTHREAD_SYMBOLS) __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
+            return ITTNOTIFY_NAME(counter_create_typed)(name, domain, type);
+        }
+#endif
+    }
+    for (h_tail = NULL, h = _N_(_ittapi_global).counter_list; h != NULL; h_tail = h, h = h->next)
+    {
+        if (h->nameA != NULL  && h->type == type && !__itt_fstrcmp(h->nameA, name) && ((h->domainA == NULL && domain == NULL) || 
+            (h->domainA != NULL && domain != NULL && !__itt_fstrcmp(h->domainA, domain)))) break;
+    }
+    if (h == NULL)
+    {
+       NEW_COUNTER_A(&_N_(_ittapi_global),h,h_tail,name,domain,type);
+    }
+    if (PTHREAD_SYMBOLS) __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
+    return (__itt_counter)h;
+}
+
 /* -------------------------------------------------------------------------- */
 
 static void ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(pause),_init))(void)
@@ -607,7 +764,7 @@ static const char* __itt_fsplit(const char* s, const char* sep, const char** out
 
 /* This function return value of env variable that placed into static buffer.
  * !!! The same static buffer is used for subsequent calls. !!!
- * This was done to aviod dynamic allocation for few calls.
+ * This was done to avoid dynamic allocation for few calls.
  * Actually we need this function only four times.
  */
 static const char* __itt_get_env_var(const char* name)
@@ -781,7 +938,7 @@ static const char* __itt_get_lib_name(void)
     return lib_name;
 }
 
-/* Avoid clashes with std::min */
+/* Avoid clashes with std::min, reported by tbb team */
 #define __itt_min(a,b) ((a) < (b) ? (a) : (b))
 
 static __itt_group_id __itt_get_groups(void)
@@ -798,8 +955,9 @@ static __itt_group_id __itt_get_groups(void)
         const char* chunk;
         while ((group_str = __itt_fsplit(group_str, ",; ", &chunk, &len)) != NULL)
         {
-            __itt_fstrcpyn(gr, sizeof(gr) - 1, chunk, len + 1);
-            gr[__itt_min(len, (int)(sizeof(gr) - 1))] = 0;
+            int min_len = __itt_min(len, (int)(sizeof(gr) - 1));
+            __itt_fstrcpyn(gr, sizeof(gr) - 1, chunk,  min_len);
+            gr[min_len] = 0;
 
             for (i = 0; group_list[i].name != NULL; i++)
             {
@@ -829,6 +987,7 @@ static __itt_group_id __itt_get_groups(void)
 
     return res;
 }
+
 #undef __itt_min
 
 static int __itt_lib_version(lib_t lib)
@@ -845,7 +1004,7 @@ static int __itt_lib_version(lib_t lib)
 /* It's not used right now! Comment it out to avoid warnings.
 static void __itt_reinit_all_pointers(void)
 {
-    int i;
+    register int i;
     // Fill all pointers with initial stubs
     for (i = 0; _N_(_ittapi_global).api_list_ptr[i].name != NULL; i++)
         *_N_(_ittapi_global).api_list_ptr[i].func_ptr = _N_(_ittapi_global).api_list_ptr[i].init_func;
@@ -855,7 +1014,7 @@ static void __itt_reinit_all_pointers(void)
 static void __itt_nullify_all_pointers(void)
 {
     int i;
-    /* Nulify all pointers except domain_create and string_handle_create */
+    /* Nulify all pointers except domain_create, string_handle_create  and counter_create */
     for (i = 0; _N_(_ittapi_global).api_list_ptr[i].name != NULL; i++)
         *_N_(_ittapi_global).api_list_ptr[i].func_ptr = _N_(_ittapi_global).api_list_ptr[i].null_func;
 }
@@ -873,12 +1032,12 @@ ITT_EXTERN_C void _N_(fini_ittlib)(void)
 
     if (_N_(_ittapi_global).api_initialized)
     {
-        __itt_mutex_lock(&_N_(_ittapi_global).mutex);
+        ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global));
         if (_N_(_ittapi_global).api_initialized)
         {
             if (current_thread == 0)
             {
-                current_thread = __itt_thread_id();
+                if (PTHREAD_SYMBOLS) current_thread = __itt_thread_id();
                 if (_N_(_ittapi_global).lib != NULL)
                 {
                     __itt_api_fini_ptr = (__itt_api_fini_t*)(size_t)__itt_get_proc(_N_(_ittapi_global).lib, "__itt_api_fini");
@@ -899,7 +1058,7 @@ ITT_EXTERN_C void _N_(fini_ittlib)(void)
                 current_thread = 0;
             }
         }
-        __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
+        if (PTHREAD_SYMBOLS) __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
     }
 }
 
@@ -922,13 +1081,13 @@ ITT_EXTERN_C int _N_(init_ittlib)(const char* lib_name, __itt_group_id init_grou
         {
             if (current_thread == 0)
             {
-                current_thread = __itt_thread_id();
+                if (PTHREAD_SYMBOLS) current_thread = __itt_thread_id();
                 if (lib_name == NULL)
                 {
                     lib_name = __itt_get_lib_name();
                 }
                 groups = __itt_get_groups();
-                if (groups != __itt_group_none || lib_name != NULL)
+                if (DL_SYMBOLS && (groups != __itt_group_none || lib_name != NULL))
                 {
                     _N_(_ittapi_global).lib = __itt_load_lib((lib_name == NULL) ? ittnotify_lib_name : lib_name);
 
@@ -940,6 +1099,7 @@ ITT_EXTERN_C int _N_(init_ittlib)(const char* lib_name, __itt_group_id init_grou
                         switch (lib_version) {
                         case 0:
                             groups = __itt_group_legacy;
+                            /* Falls through */
                         case 1:
                             /* Fill all pointers from dynamic library */
                             for (i = 0; _N_(_ittapi_global).api_list_ptr[i].name != NULL; i++)
@@ -993,6 +1153,7 @@ ITT_EXTERN_C int _N_(init_ittlib)(const char* lib_name, __itt_group_id init_grou
                     else
                     {
                         __itt_nullify_all_pointers();
+
 #if ITT_PLATFORM==ITT_PLATFORM_WIN
                         int error = __itt_system_error();
 #else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
@@ -1013,7 +1174,7 @@ ITT_EXTERN_C int _N_(init_ittlib)(const char* lib_name, __itt_group_id init_grou
         }
 
 #ifndef ITT_SIMPLE_INIT
-        __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
+        if (PTHREAD_SYMBOLS) __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
 #endif /* ITT_SIMPLE_INIT */
     }
 
@@ -1040,3 +1201,44 @@ ITT_EXTERN_C __itt_error_handler_t* _N_(set_error_handler)(__itt_error_handler_t
 #pragma warning(pop)
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 
+/** __itt_mark_pt_region functions marks region of interest
+ * region parameter defines different regions.
+ * 0 <= region < 8 */
+
+#if defined(ITT_API_IPT_SUPPORT) && (ITT_PLATFORM==ITT_PLATFORM_WIN || ITT_PLATFORM==ITT_PLATFORM_POSIX) && !defined(__ANDROID__)
+void __itt_pt_mark(__itt_pt_region region);
+void __itt_pt_mark_event(__itt_pt_region region);
+#endif
+
+ITT_EXTERN_C void _N_(mark_pt_region_begin)(__itt_pt_region region)
+{
+#if defined(ITT_API_IPT_SUPPORT) && (ITT_PLATFORM==ITT_PLATFORM_WIN || ITT_PLATFORM==ITT_PLATFORM_POSIX) && !defined(__ANDROID__)
+    if (_N_(_ittapi_global).ipt_collect_events == 1)
+    {
+        __itt_pt_mark_event(2*region);
+    }
+    else
+    {
+        __itt_pt_mark(2*region);
+    }
+#else
+    (void)region;
+#endif
+}
+
+ITT_EXTERN_C void _N_(mark_pt_region_end)(__itt_pt_region region)
+{
+#if defined(ITT_API_IPT_SUPPORT) && (ITT_PLATFORM==ITT_PLATFORM_WIN || ITT_PLATFORM==ITT_PLATFORM_POSIX) && !defined(__ANDROID__)
+    if (_N_(_ittapi_global).ipt_collect_events == 1)
+    {
+        __itt_pt_mark_event(2*region + 1);
+    }
+    else
+    {
+        __itt_pt_mark(2*region + 1);
+    }
+#else
+     (void)region;
+#endif
+}
+
diff --git a/src/tbb/src/tbb/tools_api/ittnotify_static.h b/src/tbb/src/tbb/tools_api/ittnotify_static.h
index 6907b835..21ebf951 100644
--- a/src/tbb/src/tbb/tools_api/ittnotify_static.h
+++ b/src/tbb/src/tbb/tools_api/ittnotify_static.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 "ittnotify_config.h"
@@ -50,6 +46,21 @@ ITT_STUB(ITTAPI, __itt_string_handle*, string_handle_createW, (const wchar_t *na
 ITT_STUB(ITTAPI, __itt_string_handle*, string_handle_create,  (const char    *name), (ITT_FORMAT name), string_handle_create,  __itt_group_structure, "\"%s\"")
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+ITT_STUB(ITTAPI, __itt_counter, counter_createA, (const char    *name, const char    *domain), (ITT_FORMAT name, domain), counter_createA, __itt_group_counter, "\"%s\", \"%s\"")
+ITT_STUB(ITTAPI, __itt_counter, counter_createW, (const wchar_t *name, const wchar_t *domain), (ITT_FORMAT name, domain), counter_createW, __itt_group_counter, "\"%s\", \"%s\"")
+#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUB(ITTAPI, __itt_counter, counter_create,  (const char    *name, const char    *domain), (ITT_FORMAT name, domain), counter_create,  __itt_group_counter, "\"%s\", \"%s\"")
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+ITT_STUB(ITTAPI, __itt_counter, counter_create_typedA, (const char    *name, const char    *domain, __itt_metadata_type type), (ITT_FORMAT name, domain, type), counter_create_typedA, __itt_group_counter, "\"%s\", \"%s\", %d")
+ITT_STUB(ITTAPI, __itt_counter, counter_create_typedW, (const wchar_t *name, const wchar_t *domain, __itt_metadata_type type), (ITT_FORMAT name, domain, type), counter_create_typedW, __itt_group_counter, "\"%s\", \"%s\", %d")
+#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUB(ITTAPI, __itt_counter, counter_create_typed,  (const char    *name, const char    *domain, __itt_metadata_type type), (ITT_FORMAT name, domain, type), counter_create_typed,  __itt_group_counter, "\"%s\", \"%s\", %d")
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+
+
 ITT_STUBV(ITTAPI, void, pause,  (void), (ITT_NO_PARAMS), pause,  __itt_group_control | __itt_group_legacy, "no args")
 ITT_STUBV(ITTAPI, void, resume, (void), (ITT_NO_PARAMS), resume, __itt_group_control | __itt_group_legacy, "no args")
 
@@ -179,6 +190,8 @@ ITT_STUBV(ITTAPI, void, task_end,      (const __itt_domain *domain),
 
 ITT_STUBV(ITTAPI, void, counter_inc_v3,       (const __itt_domain *domain, __itt_string_handle *name),                           (ITT_FORMAT domain, name),        counter_inc_v3,       __itt_group_structure, "%p, %p")
 ITT_STUBV(ITTAPI, void, counter_inc_delta_v3, (const __itt_domain *domain, __itt_string_handle *name, unsigned long long value), (ITT_FORMAT domain, name, value), counter_inc_delta_v3, __itt_group_structure, "%p, %p, %lu")
+ITT_STUBV(ITTAPI, void, counter_dec_v3,       (const __itt_domain *domain, __itt_string_handle *name),                           (ITT_FORMAT domain, name),        counter_dec_v3,       __itt_group_structure, "%p, %p")
+ITT_STUBV(ITTAPI, void, counter_dec_delta_v3, (const __itt_domain *domain, __itt_string_handle *name, unsigned long long value), (ITT_FORMAT domain, name, value), counter_dec_delta_v3, __itt_group_structure, "%p, %p, %lu")
 
 ITT_STUBV(ITTAPI, void, marker, (const __itt_domain *domain, __itt_id id, __itt_string_handle *name, __itt_scope scope), (ITT_FORMAT domain, id, name, scope), marker, __itt_group_structure, "%p, %lu, %p, %d")
 
@@ -241,21 +254,24 @@ ITT_STUB(ITTAPI, __itt_frame, frame_createW, (const wchar_t *domain), (ITT_FORMA
 #else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 ITT_STUB(ITTAPI, __itt_frame, frame_create,  (const char    *domain), (ITT_FORMAT domain), frame_create,  __itt_group_frame, "\"%s\"")
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#endif /* __ITT_INTERNAL_BODY */
-ITT_STUBV(ITTAPI, void, frame_begin,         (__itt_frame frame),     (ITT_FORMAT frame),  frame_begin,   __itt_group_frame, "%p")
-ITT_STUBV(ITTAPI, void, frame_end,           (__itt_frame frame),     (ITT_FORMAT frame),  frame_end,     __itt_group_frame, "%p")
 
-#ifndef __ITT_INTERNAL_BODY
 #if ITT_PLATFORM==ITT_PLATFORM_WIN
-ITT_STUB(ITTAPI, __itt_counter, counter_createA, (const char    *name, const char    *domain), (ITT_FORMAT name, domain), counter_createA, __itt_group_counter, "\"%s\", \"%s\"")
-ITT_STUB(ITTAPI, __itt_counter, counter_createW, (const wchar_t *name, const wchar_t *domain), (ITT_FORMAT name, domain), counter_createW, __itt_group_counter, "\"%s\", \"%s\"")
-#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-ITT_STUB(ITTAPI, __itt_counter, counter_create,  (const char    *name, const char    *domain), (ITT_FORMAT name, domain), counter_create,  __itt_group_counter, "\"%s\", \"%s\"")
+ITT_STUB(ITTAPI, __itt_pt_region, pt_region_createA, (const char    *name), (ITT_FORMAT name), pt_region_createA, __itt_group_structure, "\"%s\"")
+ITT_STUB(ITTAPI, __itt_pt_region, pt_region_createW, (const wchar_t *name), (ITT_FORMAT name), pt_region_createW, __itt_group_structure, "\"%S\"")
+#else  /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
+ITT_STUB(ITTAPI, __itt_pt_region, pt_region_create,  (const char    *name), (ITT_FORMAT name), pt_region_create,  __itt_group_structure, "\"%s\"")
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #endif /* __ITT_INTERNAL_BODY */
-ITT_STUBV(ITTAPI, void, counter_destroy,   (__itt_counter id),                           (ITT_FORMAT id),        counter_destroy,   __itt_group_counter, "%p")
-ITT_STUBV(ITTAPI, void, counter_inc,       (__itt_counter id),                           (ITT_FORMAT id),        counter_inc,       __itt_group_counter, "%p")
-ITT_STUBV(ITTAPI, void, counter_inc_delta, (__itt_counter id, unsigned long long value), (ITT_FORMAT id, value), counter_inc_delta, __itt_group_counter, "%p, %lu")
+ITT_STUBV(ITTAPI, void, frame_begin,         (__itt_frame frame),     (ITT_FORMAT frame),  frame_begin,   __itt_group_frame, "%p")
+ITT_STUBV(ITTAPI, void, frame_end,           (__itt_frame frame),     (ITT_FORMAT frame),  frame_end,     __itt_group_frame, "%p")
+
+ITT_STUBV(ITTAPI, void, counter_destroy,      (__itt_counter id),                                                                                  (ITT_FORMAT id),        counter_destroy,   __itt_group_counter, "%p")
+ITT_STUBV(ITTAPI, void, counter_inc,          (__itt_counter id),                                                                                  (ITT_FORMAT id),        counter_inc,       __itt_group_counter, "%p")
+ITT_STUBV(ITTAPI, void, counter_inc_delta,    (__itt_counter id, unsigned long long value),                                                        (ITT_FORMAT id, value), counter_inc_delta, __itt_group_counter, "%p, %lu")
+ITT_STUBV(ITTAPI, void, counter_dec,          (__itt_counter id),                                                                                  (ITT_FORMAT id),        counter_dec,       __itt_group_counter, "%p")
+ITT_STUBV(ITTAPI, void, counter_dec_delta,    (__itt_counter id, unsigned long long value),                                                        (ITT_FORMAT id, value), counter_dec_delta, __itt_group_counter, "%p, %lu")
+ITT_STUBV(ITTAPI, void, counter_set_value,    (__itt_counter id, void *value_ptr),                                                                 (ITT_FORMAT id, value_ptr),                          counter_set_value,    __itt_group_counter, "%p, %p")
+ITT_STUBV(ITTAPI, void, counter_set_value_ex, (__itt_counter id, __itt_clock_domain *clock_domain, unsigned long long timestamp, void *value_ptr), (ITT_FORMAT id, clock_domain, timestamp, value_ptr), counter_set_value_ex, __itt_group_counter, "%p, %p, %llu, %p")
 
 #ifndef __ITT_INTERNAL_BODY
 #if ITT_PLATFORM==ITT_PLATFORM_WIN
@@ -325,4 +341,14 @@ ITT_STUB(ITTAPI, int, av_save,  (void *data, int rank, const int *dimensions, in
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #endif /* __ITT_INTERNAL_BODY */
 
+#ifndef __ITT_INTERNAL_BODY
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+ITT_STUBV(ITTAPI, void, module_loadA, (void *start_addr, void* end_addr, const char *path), (ITT_FORMAT start_addr, end_addr, path), module_loadA, __itt_group_none, "%p, %p, %p")
+ITT_STUBV(ITTAPI, void, module_loadW, (void *start_addr, void* end_addr, const wchar_t *path), (ITT_FORMAT start_addr, end_addr, path), module_loadW, __itt_group_none, "%p, %p, %p")
+#else  /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
+ITT_STUBV(ITTAPI, void, module_load, (void *start_addr, void *end_addr, const char *path), (ITT_FORMAT start_addr, end_addr, path), module_load, __itt_group_none, "%p, %p, %p")
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#endif /* __ITT_INTERNAL_BODY */
+
+
 #endif /* __ITT_INTERNAL_INIT */
diff --git a/src/tbb/src/tbb/tools_api/ittnotify_types.h b/src/tbb/src/tbb/tools_api/ittnotify_types.h
index 83cb0ddf..281f1ac2 100644
--- a/src/tbb/src/tbb/tools_api/ittnotify_types.h
+++ b/src/tbb/src/tbb/tools_api/ittnotify_types.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef _ITTNOTIFY_TYPES_H_
diff --git a/src/tbb/src/tbb/tools_api/legacy/ittnotify.h b/src/tbb/src/tbb/tools_api/legacy/ittnotify.h
index e15734a4..5e9834a7 100644
--- a/src/tbb/src/tbb/tools_api/legacy/ittnotify.h
+++ b/src/tbb/src/tbb/tools_api/legacy/ittnotify.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef _LEGACY_ITTNOTIFY_H_
@@ -97,17 +93,17 @@
 #endif /* UNICODE || _UNICODE */
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 
-#ifndef CDECL
+#ifndef ITTAPI_CDECL
 #  if ITT_PLATFORM==ITT_PLATFORM_WIN
-#    define CDECL __cdecl
+#    define ITTAPI_CDECL __cdecl
 #  else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #    if defined _M_IX86 || defined __i386__ 
-#      define CDECL __attribute__ ((cdecl))
+#      define ITTAPI_CDECL __attribute__ ((cdecl))
 #    else  /* _M_IX86 || __i386__ */
-#      define CDECL /* actual only on x86 platform */
+#      define ITTAPI_CDECL /* actual only on x86 platform */
 #    endif /* _M_IX86 || __i386__ */
 #  endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#endif /* CDECL */
+#endif /* ITTAPI_CDECL */
 
 #ifndef STDCALL
 #  if ITT_PLATFORM==ITT_PLATFORM_WIN
@@ -121,12 +117,12 @@
 #  endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #endif /* STDCALL */
 
-#define ITTAPI    CDECL
-#define LIBITTAPI CDECL
+#define ITTAPI    ITTAPI_CDECL
+#define LIBITTAPI ITTAPI_CDECL
 
 /* TODO: Temporary for compatibility! */
-#define ITTAPI_CALL    CDECL
-#define LIBITTAPI_CALL CDECL
+#define ITTAPI_CALL    ITTAPI_CDECL
+#define LIBITTAPI_CALL ITTAPI_CDECL
 
 #if ITT_PLATFORM==ITT_PLATFORM_WIN
 /* use __forceinline (VC++ specific) */
diff --git a/src/tbb/src/tbb/win32-tbb-export.def b/src/tbb/src/tbb/win32-tbb-export.def
index 9f1b7dca..1941c886 100644
--- a/src/tbb/src/tbb/win32-tbb-export.def
+++ b/src/tbb/src/tbb/win32-tbb-export.def
@@ -1,4 +1,4 @@
-; Copyright (c) 2005-2017 Intel Corporation
+; Copyright (c) 2005-2020 Intel Corporation
 ;
 ; Licensed under the Apache License, Version 2.0 (the "License");
 ; you may not use this file except in compliance with the License.
@@ -11,10 +11,6 @@
 ; 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.
-;
-;
-;
-;
 
 EXPORTS
 
diff --git a/src/tbb/src/tbb/win32-tbb-export.lst b/src/tbb/src/tbb/win32-tbb-export.lst
index 35b1833a..42d2a399 100644
--- a/src/tbb/src/tbb/win32-tbb-export.lst
+++ b/src/tbb/src/tbb/win32-tbb-export.lst
@@ -1,4 +1,4 @@
-; Copyright (c) 2005-2017 Intel Corporation
+; Copyright (c) 2005-2020 Intel Corporation
 ;
 ; Licensed under the Apache License, Version 2.0 (the "License");
 ; you may not use this file except in compliance with the License.
@@ -11,10 +11,6 @@
 ; 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 "tbb/tbb_config.h"
 
@@ -81,6 +77,11 @@ __TBB_SYMBOL( ?internal_attach@task_arena_base@internal@interface7@tbb@@IAEXXZ )
 __TBB_SYMBOL( ?internal_enqueue@task_arena_base@internal@interface7@tbb@@IBEXAAVtask@4@H@Z )
 __TBB_SYMBOL( ?internal_execute@task_arena_base@internal@interface7@tbb@@IBEXAAVdelegate_base@234@@Z )
 __TBB_SYMBOL( ?internal_wait@task_arena_base@internal@interface7@tbb@@IBEXXZ )
+#if __TBB_NUMA_SUPPORT
+__TBB_SYMBOL( ?nodes_count@numa_topology@internal@tbb@@YAIXZ )
+__TBB_SYMBOL( ?fill@numa_topology@internal@tbb@@YAXPAH@Z )
+__TBB_SYMBOL( ?default_concurrency@numa_topology@internal@tbb@@YAHH@Z )
+#endif /*__TBB_NUMA_SUPPORT*/
 #if __TBB_TASK_ISOLATION
 __TBB_SYMBOL( ?isolate_within_arena@internal@interface7@tbb@@YAXAAVdelegate_base@123@H@Z )
 #endif /* __TBB_TASK_ISOLATION */
@@ -138,7 +139,6 @@ __TBB_SYMBOL( ?itt_store_pointer_with_release_v3@internal@tbb@@YAXPAX0@Z )
 __TBB_SYMBOL( ?call_itt_notify_v5@internal@tbb@@YAXHPAX@Z )
 __TBB_SYMBOL( ?itt_set_sync_name_v3@internal@tbb@@YAXPAXPB_W@Z )
 __TBB_SYMBOL( ?itt_load_pointer_v3@internal@tbb@@YAPAXPBX@Z )
-#if __TBB_ITT_STRUCTURE_API
 __TBB_SYMBOL( ?itt_make_task_group_v7@internal@tbb@@YAXW4itt_domain_enum@12@PAX_K12W4string_index@12@@Z )
 __TBB_SYMBOL( ?itt_metadata_str_add_v7@internal@tbb@@YAXW4itt_domain_enum@12@PAX_KW4string_index@12@PBD@Z )
 __TBB_SYMBOL( ?itt_relation_add_v7@internal@tbb@@YAXW4itt_domain_enum@12@PAX_KW4itt_relation@12@12@Z )
@@ -146,7 +146,7 @@ __TBB_SYMBOL( ?itt_task_begin_v7@internal@tbb@@YAXW4itt_domain_enum@12@PAX_K12W4
 __TBB_SYMBOL( ?itt_task_end_v7@internal@tbb@@YAXW4itt_domain_enum@12@@Z )
 __TBB_SYMBOL( ?itt_region_begin_v9@internal@tbb@@YAXW4itt_domain_enum@12@PAX_K12W4string_index@12@@Z )
 __TBB_SYMBOL( ?itt_region_end_v9@internal@tbb@@YAXW4itt_domain_enum@12@PAX_K@Z )
-#endif
+__TBB_SYMBOL( ?itt_metadata_ptr_add_v11@internal@tbb@@YAXW4itt_domain_enum@12@PAX_KW4string_index@12@1@Z )
 
 // pipeline.cpp
 __TBB_SYMBOL( ??0pipeline@tbb@@QAE@XZ )
@@ -341,4 +341,10 @@ __TBB_SYMBOL( ?active_value@global_control@interface9@tbb@@CAIH@Z )
 __TBB_SYMBOL( ?internal_create@global_control@interface9@tbb@@AAEXXZ )
 __TBB_SYMBOL( ?internal_destroy@global_control@interface9@tbb@@AAEXXZ )
 
+#if __TBB_PREVIEW_RESUMABLE_TASKS
+__TBB_SYMBOL( ?internal_suspend@internal@tbb@@YAXPAX0@Z )
+__TBB_SYMBOL( ?internal_resume@internal@tbb@@YAXPAX@Z )
+__TBB_SYMBOL( ?internal_current_suspend_point@internal@tbb@@YAPAXXZ )
+#endif
+
 #undef __TBB_SYMBOL
diff --git a/src/tbb/src/tbb/win32-tbbbind-export.def b/src/tbb/src/tbb/win32-tbbbind-export.def
new file mode 100644
index 00000000..557c9056
--- /dev/null
+++ b/src/tbb/src/tbb/win32-tbbbind-export.def
@@ -0,0 +1,22 @@
+; Copyright (c) 2005-2020 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.
+
+EXPORTS
+
+global
+initialize_numa_topology
+bind_to_node
+restore_affinity
+allocate_binding_handler
+deallocate_binding_handler
diff --git a/src/tbb/src/tbb/win64-gcc-tbb-export.def b/src/tbb/src/tbb/win64-gcc-tbb-export.def
index 6159cf85..4444ad88 100644
--- a/src/tbb/src/tbb/win64-gcc-tbb-export.def
+++ b/src/tbb/src/tbb/win64-gcc-tbb-export.def
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 {
diff --git a/src/tbb/src/tbb/win64-gcc-tbb-export.lst b/src/tbb/src/tbb/win64-gcc-tbb-export.lst
index 46cb2985..0e98ff41 100644
--- a/src/tbb/src/tbb/win64-gcc-tbb-export.lst
+++ b/src/tbb/src/tbb/win64-gcc-tbb-export.lst
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 "tbb/tbb_config.h"
@@ -72,6 +68,11 @@ __TBB_SYMBOL( _ZNK3tbb10interface78internal15task_arena_base16internal_executeER
 __TBB_SYMBOL( _ZNK3tbb10interface78internal15task_arena_base13internal_waitEv )
 __TBB_SYMBOL( _ZN3tbb10interface78internal15task_arena_base21internal_current_slotEv )
 __TBB_SYMBOL( _ZN3tbb10interface78internal15task_arena_base24internal_max_concurrencyEPKNS0_10task_arenaE )
+#if __TBB_NUMA_SUPPORT
+__TBB_SYMBOL( _ZN3tbb8internal13numa_topology11nodes_countEv )
+__TBB_SYMBOL( _ZN3tbb8internal13numa_topology4fillEPi )
+__TBB_SYMBOL( _ZN3tbb8internal13numa_topology19default_concurrencyEi )
+#endif /*__TBB_NUMA_SUPPORT*/
 #if __TBB_TASK_ISOLATION
 __TBB_SYMBOL( _ZN3tbb10interface78internal20isolate_within_arenaERNS1_13delegate_baseEx )
 #endif /* __TBB_TASK_ISOLATION */
@@ -166,6 +167,14 @@ __TBB_SYMBOL( _ZN3tbb8internal33itt_store_pointer_with_release_v3EPvS1_ )
 __TBB_SYMBOL( _ZN3tbb8internal18call_itt_notify_v5EiPv )
 __TBB_SYMBOL( _ZN3tbb8internal20itt_set_sync_name_v3EPvPKc )
 __TBB_SYMBOL( _ZN3tbb8internal19itt_load_pointer_v3EPKv )
+__TBB_SYMBOL( _ZN3tbb8internal22itt_make_task_group_v7ENS0_15itt_domain_enumEPvyS2_yNS0_12string_indexE )
+__TBB_SYMBOL( _ZN3tbb8internal23itt_metadata_str_add_v7ENS0_15itt_domain_enumEPvyNS0_12string_indexEPKc )
+__TBB_SYMBOL( _ZN3tbb8internal19itt_relation_add_v7ENS0_15itt_domain_enumEPvyNS0_12itt_relationES2_y )
+__TBB_SYMBOL( _ZN3tbb8internal17itt_task_begin_v7ENS0_15itt_domain_enumEPvyS2_yNS0_12string_indexE )
+__TBB_SYMBOL( _ZN3tbb8internal15itt_task_end_v7ENS0_15itt_domain_enumE )
+__TBB_SYMBOL( _ZN3tbb8internal19itt_region_begin_v9ENS0_15itt_domain_enumEPvyS2_yNS0_12string_indexE )
+__TBB_SYMBOL( _ZN3tbb8internal17itt_region_end_v9ENS0_15itt_domain_enumEPvy )
+__TBB_SYMBOL( _ZN3tbb8internal24itt_metadata_ptr_add_v11ENS0_15itt_domain_enumEPvyNS0_12string_indexES2_ )
 
 /* pipeline.cpp */
 __TBB_SYMBOL( _ZTIN3tbb6filterE )
@@ -381,4 +390,10 @@ __TBB_SYMBOL( _ZN3tbb10interface914global_control12active_valueEi )
 __TBB_SYMBOL( _ZN3tbb10interface914global_control15internal_createEv )
 __TBB_SYMBOL( _ZN3tbb10interface914global_control16internal_destroyEv )
 
+#if __TBB_PREVIEW_RESUMABLE_TASKS
+__TBB_SYMBOL( _ZN3tbb8internal16internal_suspendEPvS1_ )
+__TBB_SYMBOL( _ZN3tbb8internal15internal_resumeEPv )
+__TBB_SYMBOL( _ZN3tbb8internal30internal_current_suspend_pointEv )
+#endif
+
 #undef __TBB_SYMBOL
diff --git a/src/tbb/src/tbb/win64-tbb-export.def b/src/tbb/src/tbb/win64-tbb-export.def
index d3f3d1a5..ea7b3ea9 100644
--- a/src/tbb/src/tbb/win64-tbb-export.def
+++ b/src/tbb/src/tbb/win64-tbb-export.def
@@ -1,4 +1,4 @@
-; Copyright (c) 2005-2017 Intel Corporation
+; Copyright (c) 2005-2020 Intel Corporation
 ;
 ; Licensed under the Apache License, Version 2.0 (the "License");
 ; you may not use this file except in compliance with the License.
@@ -11,10 +11,6 @@
 ; 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.
-;
-;
-;
-;
 
 ; This file is organized with a section for each .cpp file.
 ; Each of these sections is in alphabetical order.
diff --git a/src/tbb/src/tbb/win64-tbb-export.lst b/src/tbb/src/tbb/win64-tbb-export.lst
index 3bca01a9..978651f7 100644
--- a/src/tbb/src/tbb/win64-tbb-export.lst
+++ b/src/tbb/src/tbb/win64-tbb-export.lst
@@ -1,4 +1,4 @@
-; Copyright (c) 2005-2017 Intel Corporation
+; Copyright (c) 2005-2020 Intel Corporation
 ;
 ; Licensed under the Apache License, Version 2.0 (the "License");
 ; you may not use this file except in compliance with the License.
@@ -11,10 +11,6 @@
 ; 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.
-;
-;
-;
-;
 
 // This file is organized with a section for each .cpp file.
 // Each of these sections is in alphabetical order.
@@ -77,6 +73,11 @@ __TBB_SYMBOL( ?internal_attach@task_arena_base@internal@interface7@tbb@@IEAAXXZ
 __TBB_SYMBOL( ?internal_enqueue@task_arena_base@internal@interface7@tbb@@IEBAXAEAVtask@4@_J@Z )
 __TBB_SYMBOL( ?internal_execute@task_arena_base@internal@interface7@tbb@@IEBAXAEAVdelegate_base@234@@Z )
 __TBB_SYMBOL( ?internal_wait@task_arena_base@internal@interface7@tbb@@IEBAXXZ )
+#if __TBB_NUMA_SUPPORT
+__TBB_SYMBOL( ?nodes_count@numa_topology@internal@tbb@@YAIXZ )
+__TBB_SYMBOL( ?fill@numa_topology@internal@tbb@@YAXPEAH@Z )
+__TBB_SYMBOL( ?default_concurrency@numa_topology@internal@tbb@@YAHH@Z )
+#endif /*__TBB_NUMA_SUPPORT*/
 #if __TBB_TASK_ISOLATION
 __TBB_SYMBOL( ?isolate_within_arena@internal@interface7@tbb@@YAXAEAVdelegate_base@123@_J@Z )
 #endif /* __TBB_TASK_ISOLATION */
@@ -133,7 +134,6 @@ __TBB_SYMBOL( ?itt_store_pointer_with_release_v3@internal@tbb@@YAXPEAX0@Z )
 __TBB_SYMBOL( ?call_itt_notify_v5@internal@tbb@@YAXHPEAX@Z )
 __TBB_SYMBOL( ?itt_load_pointer_v3@internal@tbb@@YAPEAXPEBX@Z )
 __TBB_SYMBOL( ?itt_set_sync_name_v3@internal@tbb@@YAXPEAXPEB_W@Z )
-#if __TBB_ITT_STRUCTURE_API
 __TBB_SYMBOL( ?itt_make_task_group_v7@internal@tbb@@YAXW4itt_domain_enum@12@PEAX_K12W4string_index@12@@Z )
 __TBB_SYMBOL( ?itt_metadata_str_add_v7@internal@tbb@@YAXW4itt_domain_enum@12@PEAX_KW4string_index@12@PEBD@Z )
 __TBB_SYMBOL( ?itt_relation_add_v7@internal@tbb@@YAXW4itt_domain_enum@12@PEAX_KW4itt_relation@12@12@Z )
@@ -141,7 +141,7 @@ __TBB_SYMBOL( ?itt_task_begin_v7@internal@tbb@@YAXW4itt_domain_enum@12@PEAX_K12W
 __TBB_SYMBOL( ?itt_task_end_v7@internal@tbb@@YAXW4itt_domain_enum@12@@Z )
 __TBB_SYMBOL( ?itt_region_begin_v9@internal@tbb@@YAXW4itt_domain_enum@12@PEAX_K12W4string_index@12@@Z )
 __TBB_SYMBOL( ?itt_region_end_v9@internal@tbb@@YAXW4itt_domain_enum@12@PEAX_K@Z )
-#endif
+__TBB_SYMBOL( ?itt_metadata_ptr_add_v11@internal@tbb@@YAXW4itt_domain_enum@12@PEAX_KW4string_index@12@1@Z )
 
 // pipeline.cpp
 __TBB_SYMBOL( ??_7pipeline@tbb@@6B@ )
@@ -336,4 +336,10 @@ __TBB_SYMBOL( ?active_value@global_control@interface9@tbb@@CA_KH@Z )
 __TBB_SYMBOL( ?internal_create@global_control@interface9@tbb@@AEAAXXZ )
 __TBB_SYMBOL( ?internal_destroy@global_control@interface9@tbb@@AEAAXXZ )
 
+#if __TBB_PREVIEW_RESUMABLE_TASKS
+__TBB_SYMBOL( ?internal_suspend@internal@tbb@@YAXPEAX0@Z )
+__TBB_SYMBOL( ?internal_resume@internal@tbb@@YAXPEAX@Z )
+__TBB_SYMBOL( ?internal_current_suspend_point@internal@tbb@@YAPEAXXZ )
+#endif
+
 #undef __TBB_SYMBOL
diff --git a/src/tbb/src/tbb/win64-tbbbind-export.def b/src/tbb/src/tbb/win64-tbbbind-export.def
new file mode 100644
index 00000000..557c9056
--- /dev/null
+++ b/src/tbb/src/tbb/win64-tbbbind-export.def
@@ -0,0 +1,22 @@
+; Copyright (c) 2005-2020 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.
+
+EXPORTS
+
+global
+initialize_numa_topology
+bind_to_node
+restore_affinity
+allocate_binding_handler
+deallocate_binding_handler
diff --git a/src/tbb/src/tbb/winrt-tbb-export.lst b/src/tbb/src/tbb/winrt-tbb-export.lst
index da551170..b4b3ea53 100644
--- a/src/tbb/src/tbb/winrt-tbb-export.lst
+++ b/src/tbb/src/tbb/winrt-tbb-export.lst
@@ -1,4 +1,4 @@
-; Copyright (c) 2005-2017 Intel Corporation
+; Copyright (c) 2005-2020 Intel Corporation
 ;
 ; Licensed under the Apache License, Version 2.0 (the "License");
 ; you may not use this file except in compliance with the License.
@@ -11,10 +11,6 @@
 ; 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 "tbb/tbb_config.h"
 
diff --git a/src/tbb/src/tbb/x86_rtm_rw_mutex.cpp b/src/tbb/src/tbb/x86_rtm_rw_mutex.cpp
index 7f2027fa..e321b593 100644
--- a/src/tbb/src/tbb/x86_rtm_rw_mutex.cpp
+++ b/src/tbb/src/tbb/x86_rtm_rw_mutex.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 "tbb/tbb_config.h"
@@ -80,7 +76,7 @@ void x86_rtm_rw_mutex::internal_release(x86_rtm_rw_mutex::scoped_lock& s) {
             }
 #endif
             __TBB_machine_end_transaction();
-            s.my_scoped_lock.internal_set_mutex(NULL);
+            s.my_scoped_lock.mutex = NULL;
         }
         break;
     case RTM_real_reader:
@@ -94,6 +90,7 @@ void x86_rtm_rw_mutex::internal_release(x86_rtm_rw_mutex::scoped_lock& s) {
         break;
     case RTM_not_in_mutex:
         __TBB_ASSERT(false, "RTM_not_in_mutex, but in release");
+        break;
     default:
         __TBB_ASSERT(false, "invalid transaction_state");
     }
@@ -126,7 +123,9 @@ void x86_rtm_rw_mutex::internal_acquire_writer(x86_rtm_rw_mutex::scoped_lock& s,
                 }
 #endif
                 s.transaction_state = RTM_transacting_writer;
-                s.my_scoped_lock.internal_set_mutex(this);  // need mutex for release()
+                // Don not wrap the following assignment to a function,
+                // because it can abort the transaction in debug. Need mutex for release().
+                s.my_scoped_lock.mutex = this;
                 return;  // successfully started speculation
             }
             ++num_retries;
@@ -169,7 +168,9 @@ void x86_rtm_rw_mutex::internal_acquire_reader(x86_rtm_rw_mutex::scoped_lock& s,
                 }
 #endif
                 s.transaction_state = RTM_transacting_reader;
-                s.my_scoped_lock.internal_set_mutex(this);  // need mutex for release()
+                // Don not wrap the following assignment to a function,
+                // because it can abort the transaction in debug. Need mutex for release().
+                s.my_scoped_lock.mutex = this;
                 return;  // successfully started speculation
             }
             // fallback path
diff --git a/src/tbb/src/tbbmalloc/Customize.h b/src/tbb/src/tbbmalloc/Customize.h
index 4fdf0689..7493b0ec 100644
--- a/src/tbb/src/tbbmalloc/Customize.h
+++ b/src/tbb/src/tbbmalloc/Customize.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef _TBB_malloc_Customize_H_
@@ -24,12 +20,13 @@
 // customizing MALLOC_ASSERT macro
 #include "tbb/tbb_stddef.h"
 #define MALLOC_ASSERT(assertion, message) __TBB_ASSERT(assertion, message)
+#define MALLOC_ASSERT_EX(assertion, message) __TBB_ASSERT_EX(assertion, message)
 
 #ifndef MALLOC_DEBUG
 #define MALLOC_DEBUG TBB_USE_DEBUG
 #endif
 
-#include "tbb/tbb_machine.h"
+#include "Synchronize.h"
 
 #if DO_ITT_NOTIFY
 #include "tbb/itt_notify.h"
@@ -46,88 +43,6 @@
 #define MALLOC_ITT_FINI_ITTLIB()        ((void)0)
 #endif
 
-//! Stripped down version of spin_mutex.
-/** Instances of MallocMutex must be declared in memory that is zero-initialized.
-    There are no constructors.  This is a feature that lets it be
-    used in situations where the mutex might be used while file-scope constructors
-    are running.
-
-    There are no methods "acquire" or "release".  The scoped_lock must be used
-    in a strict block-scoped locking pattern.  Omitting these methods permitted
-    further simplification. */
-class MallocMutex : tbb::internal::no_copy {
-    __TBB_atomic_flag flag;
-
-public:
-    class scoped_lock : tbb::internal::no_copy {
-        MallocMutex& mutex;
-        bool taken;
-    public:
-        scoped_lock( MallocMutex& m ) : mutex(m), taken(true) { __TBB_LockByte(m.flag); }
-        scoped_lock( MallocMutex& m, bool block, bool *locked ) : mutex(m), taken(false) {
-            if (block) {
-                __TBB_LockByte(m.flag);
-                taken = true;
-            } else {
-                taken = __TBB_TryLockByte(m.flag);
-            }
-            if (locked) *locked = taken;
-        }
-        ~scoped_lock() {
-            if (taken) __TBB_UnlockByte(mutex.flag);
-        }
-    };
-    friend class scoped_lock;
-};
-
-// TODO: use signed/unsigned in atomics more consistently
-inline intptr_t AtomicIncrement( volatile intptr_t& counter ) {
-    return __TBB_FetchAndAddW( &counter, 1 )+1;
-}
-
-inline uintptr_t AtomicAdd( volatile intptr_t& counter, intptr_t value ) {
-    return __TBB_FetchAndAddW( &counter, value );
-}
-
-inline intptr_t AtomicCompareExchange( volatile intptr_t& location, intptr_t new_value, intptr_t comparand) {
-    return __TBB_CompareAndSwapW( &location, new_value, comparand );
-}
-
-inline uintptr_t AtomicFetchStore(volatile void* location, uintptr_t value) {
-    return __TBB_FetchAndStoreW(location, value);
-}
-
-inline void AtomicOr(volatile void *operand, uintptr_t addend) {
-    __TBB_AtomicOR(operand, addend);
-}
-
-inline void AtomicAnd(volatile void *operand, uintptr_t addend) {
-    __TBB_AtomicAND(operand, addend);
-}
-
-inline intptr_t FencedLoad( const volatile intptr_t &location ) {
-    return __TBB_load_with_acquire(location);
-}
-
-inline void FencedStore( volatile intptr_t &location, intptr_t value ) {
-    __TBB_store_with_release(location, value);
-}
-
-inline void SpinWaitWhileEq(const volatile intptr_t &location, const intptr_t value) {
-    tbb::internal::spin_wait_while_eq(location, value);
-}
-
-class AtomicBackoff {
-    tbb::internal::atomic_backoff backoff;
-public:
-    AtomicBackoff() {}
-    void pause() { backoff.pause(); }
-};
-
-inline void SpinWaitUntilEq(const volatile intptr_t &location, const intptr_t value) {
-    tbb::internal::spin_wait_until_eq(location, value);
-}
-
 inline intptr_t BitScanRev(uintptr_t x) {
     return !x? -1 : __TBB_Log2(x);
 }
diff --git a/src/tbb/src/tbbmalloc/MapMemory.h b/src/tbb/src/tbbmalloc/MapMemory.h
index 552917a4..bb0a109b 100644
--- a/src/tbb/src/tbbmalloc/MapMemory.h
+++ b/src/tbb/src/tbbmalloc/MapMemory.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef _itt_shared_malloc_MapMemory_H
@@ -57,20 +53,108 @@ void *ErrnoPreservingMalloc(size_t bytes)
  #undef XPG4_WAS_DEFINED
 #endif
 
-#define MEMORY_MAPPING_USES_MALLOC 0
-void* MapMemory (size_t bytes, bool hugePages)
-{
-    void* result = 0;
-    int prevErrno = errno;
+inline void* mmap_impl(size_t map_size, void* map_hint = NULL, int map_flags = 0) {
 #ifndef MAP_ANONYMOUS
 // macOS* defines MAP_ANON, which is deprecated in Linux*.
 #define MAP_ANONYMOUS MAP_ANON
 #endif /* MAP_ANONYMOUS */
-    int addFlags = hugePages? __TBB_MAP_HUGETLB : 0;
-    result = mmap(NULL, bytes, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS|addFlags, -1, 0);
-    if (result==MAP_FAILED)
+    return mmap(map_hint, map_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS | map_flags, -1, 0);
+}
+
+inline void* mmapTHP(size_t bytes) {
+    // Initializes in zero-initialized data section
+    static void* hint;
+
+    // Optimistically try to use a last huge page aligned region end
+    // as a hint for mmap.
+    hint = hint ? (void*)((uintptr_t)hint - bytes) : hint;
+    void* result = mmap_impl(bytes, hint);
+
+    // Something went wrong
+    if (result == MAP_FAILED) {
+        hint = NULL;
+        return MAP_FAILED;
+    }
+
+    // Otherwise, fall back to the slow path - map oversized region
+    // and trim excess parts.
+    if (!isAligned(result, HUGE_PAGE_SIZE)) {
+        // Undo previous try
+        munmap(result, bytes);
+
+        // Map oversized on huge page size region
+        result = mmap_impl(bytes + HUGE_PAGE_SIZE);
+
+        // Something went wrong
+        if (result == MAP_FAILED) {
+            hint = NULL;
+            return MAP_FAILED;
+        }
+
+        // Misalignment offset
+        uintptr_t offset = 0;
+
+        if (!isAligned(result, HUGE_PAGE_SIZE)) {
+            // Trim excess head of a region if it is no aligned
+            offset = HUGE_PAGE_SIZE - ((uintptr_t)result & (HUGE_PAGE_SIZE - 1));
+            munmap(result, offset);
+
+            // New region beginning
+            result = (void*)((uintptr_t)result + offset);
+        }
+
+        // Trim excess tail of a region
+        munmap((void*)((uintptr_t)result + bytes), HUGE_PAGE_SIZE - offset);
+    }
+
+    // Assume, that mmap virtual addresses grow down by default
+    // So, set a hint as a result of a last successful allocation
+    // and then use it minus requested size as a new mapping point.
+    // TODO: Atomic store is meant here, fence not needed, but
+    // currently we don't have such function.
+    hint = result;
+
+    MALLOC_ASSERT(isAligned(result, HUGE_PAGE_SIZE), "Mapped address is not aligned on huge page size.");
+
+    return result;
+}
+
+#define MEMORY_MAPPING_USES_MALLOC 0
+void* MapMemory (size_t bytes, PageType pageType)
+{
+    void* result = 0;
+    int prevErrno = errno;
+
+    switch (pageType) {
+        case REGULAR:
+        {
+            result = mmap_impl(bytes);
+            break;
+        }
+        case PREALLOCATED_HUGE_PAGE:
+        {
+            MALLOC_ASSERT((bytes % HUGE_PAGE_SIZE) == 0, "Mapping size should be divisible by huge page size");
+            result = mmap_impl(bytes, NULL, __TBB_MAP_HUGETLB);
+            break;
+        }
+        case TRANSPARENT_HUGE_PAGE:
+        {
+            MALLOC_ASSERT((bytes % HUGE_PAGE_SIZE) == 0, "Mapping size should be divisible by huge page size");
+            result = mmapTHP(bytes);
+            break;
+        }
+        default:
+        {
+            MALLOC_ASSERT(false, "Unknown page type");
+        }
+    }
+
+    if (result == MAP_FAILED) {
         errno = prevErrno;
-    return result==MAP_FAILED? 0: result;
+        return 0;
+    }
+
+    return result;
 }
 
 int UnmapMemory(void *area, size_t bytes)
@@ -86,7 +170,7 @@ int UnmapMemory(void *area, size_t bytes)
 #include <windows.h>
 
 #define MEMORY_MAPPING_USES_MALLOC 0
-void* MapMemory (size_t bytes, bool)
+void* MapMemory (size_t bytes, PageType)
 {
     /* Is VirtualAlloc thread safe? */
     return VirtualAlloc(NULL, bytes, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
@@ -101,7 +185,7 @@ int UnmapMemory(void *area, size_t /*bytes*/)
 #else
 
 #define MEMORY_MAPPING_USES_MALLOC 1
-void* MapMemory (size_t bytes, bool)
+void* MapMemory (size_t bytes, PageType)
 {
     return ErrnoPreservingMalloc( bytes );
 }
diff --git a/src/tbb/src/tbbmalloc/Statistics.h b/src/tbb/src/tbbmalloc/Statistics.h
index 392442e9..09fc9c56 100644
--- a/src/tbb/src/tbbmalloc/Statistics.h
+++ b/src/tbb/src/tbbmalloc/Statistics.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #define MAX_THREADS 1024
diff --git a/src/tbb/src/tbbmalloc/Synchronize.h b/src/tbb/src/tbbmalloc/Synchronize.h
new file mode 100644
index 00000000..0d11a296
--- /dev/null
+++ b/src/tbb/src/tbbmalloc/Synchronize.h
@@ -0,0 +1,104 @@
+/*
+    Copyright (c) 2005-2020 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.
+*/
+
+#ifndef __TBB_malloc_Synchronize_H_
+#define __TBB_malloc_Synchronize_H_
+
+#include "tbb/tbb_machine.h"
+
+//! Stripped down version of spin_mutex.
+/** Instances of MallocMutex must be declared in memory that is zero-initialized.
+    There are no constructors.  This is a feature that lets it be
+    used in situations where the mutex might be used while file-scope constructors
+    are running.
+
+    There are no methods "acquire" or "release".  The scoped_lock must be used
+    in a strict block-scoped locking pattern.  Omitting these methods permitted
+    further simplification. */
+class MallocMutex : tbb::internal::no_copy {
+    __TBB_atomic_flag flag;
+
+public:
+    class scoped_lock : tbb::internal::no_copy {
+        MallocMutex& mutex;
+        bool taken;
+    public:
+        scoped_lock( MallocMutex& m ) : mutex(m), taken(true) { __TBB_LockByte(m.flag); }
+        scoped_lock( MallocMutex& m, bool block, bool *locked ) : mutex(m), taken(false) {
+            if (block) {
+                __TBB_LockByte(m.flag);
+                taken = true;
+            } else {
+                taken = __TBB_TryLockByte(m.flag);
+            }
+            if (locked) *locked = taken;
+        }
+        ~scoped_lock() {
+            if (taken) __TBB_UnlockByte(mutex.flag);
+        }
+    };
+    friend class scoped_lock;
+};
+
+// TODO: use signed/unsigned in atomics more consistently
+inline intptr_t AtomicIncrement( volatile intptr_t& counter ) {
+    return __TBB_FetchAndAddW( &counter, 1 )+1;
+}
+
+inline uintptr_t AtomicAdd( volatile intptr_t& counter, intptr_t value ) {
+    return __TBB_FetchAndAddW( &counter, value );
+}
+
+inline intptr_t AtomicCompareExchange( volatile intptr_t& location, intptr_t new_value, intptr_t comparand) {
+    return __TBB_CompareAndSwapW( &location, new_value, comparand );
+}
+
+inline uintptr_t AtomicFetchStore(volatile void* location, uintptr_t value) {
+    return __TBB_FetchAndStoreW(location, value);
+}
+
+inline void AtomicOr(volatile void *operand, uintptr_t addend) {
+    __TBB_AtomicOR(operand, addend);
+}
+
+inline void AtomicAnd(volatile void *operand, uintptr_t addend) {
+    __TBB_AtomicAND(operand, addend);
+}
+
+inline intptr_t FencedLoad( const volatile intptr_t &location ) {
+    return __TBB_load_with_acquire(location);
+}
+
+inline void FencedStore( volatile intptr_t &location, intptr_t value ) {
+    __TBB_store_with_release(location, value);
+}
+
+inline void SpinWaitWhileEq(const volatile intptr_t &location, const intptr_t value) {
+    tbb::internal::spin_wait_while_eq(location, value);
+}
+
+class AtomicBackoff {
+    tbb::internal::atomic_backoff backoff;
+public:
+    AtomicBackoff() {}
+    void pause() { backoff.pause(); }
+};
+
+inline void SpinWaitUntilEq(const volatile intptr_t &location, const intptr_t value) {
+    tbb::internal::spin_wait_until_eq(location, value);
+}
+
+#endif /* __TBB_malloc_Synchronize_H_ */
diff --git a/src/tbb/src/tbbmalloc/TypeDefinitions.h b/src/tbb/src/tbbmalloc/TypeDefinitions.h
index 9b514ca4..aa6763b0 100644
--- a/src/tbb/src/tbbmalloc/TypeDefinitions.h
+++ b/src/tbb/src/tbbmalloc/TypeDefinitions.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef _itt_shared_malloc_TypeDefinitions_H_
diff --git a/src/tbb/src/tbbmalloc/backend.cpp b/src/tbb/src/tbbmalloc/backend.cpp
index 88212dd6..f78630f0 100644
--- a/src/tbb/src/tbbmalloc/backend.cpp
+++ b/src/tbb/src/tbbmalloc/backend.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 <string.h>   /* for memset */
@@ -43,60 +39,14 @@ namespace internal {
 /* assume MapMemory and UnmapMemory are customized */
 #endif
 
-void* getRawMemory (size_t size, bool hugePages) {
-    return MapMemory(size, hugePages);
+void* getRawMemory (size_t size, PageType pageType) {
+    return MapMemory(size, pageType);
 }
 
 int freeRawMemory (void *object, size_t size) {
     return UnmapMemory(object, size);
 }
 
-void HugePagesStatus::registerAllocation(bool gotPage)
-{
-    if (gotPage) {
-        if (!wasObserved)
-            FencedStore(wasObserved, 1);
-    } else
-        FencedStore(enabled, 0);
-    // reports huge page status only once
-    if (needActualStatusPrint
-        && AtomicCompareExchange(needActualStatusPrint, 0, 1))
-        doPrintStatus(gotPage, "available");
-}
-
-void HugePagesStatus::registerReleasing(void* addr, size_t size)
-{
-    // We: 1) got huge page at least once,
-    // 2) something that looks like a huge page is been released,
-    // and 3) user requested huge pages,
-    // so a huge page might be available at next allocation.
-    // TODO: keep page status in regions and use exact check here
-    if (FencedLoad(wasObserved) && size>=pageSize && isAligned(addr, pageSize))
-        FencedStore(enabled, requestedMode.get());
-}
-
-void HugePagesStatus::printStatus() {
-    doPrintStatus(requestedMode.get(), "requested");
-    if (requestedMode.get()) { // report actual status iff requested
-        if (pageSize)
-            FencedStore(needActualStatusPrint, 1);
-        else
-            doPrintStatus(/*state=*/false, "available");
-    }
-}
-
-void HugePagesStatus::doPrintStatus(bool state, const char *stateName)
-{
-    // Under macOS* fprintf/snprintf acquires an internal lock, so when
-    // 1st allocation is done under the lock, we got a deadlock.
-    // Do not use fprintf etc during initialization.
-    fputs("TBBmalloc: huge pages\t", stderr);
-    if (!state)
-        fputs("not ", stderr);
-    fputs(stateName, stderr);
-    fputs("\n", stderr);
-}
-
 #if CHECK_ALLOCATION_RANGE
 
 void Backend::UsedAddressRange::registerAlloc(uintptr_t left, uintptr_t right)
@@ -127,34 +77,43 @@ void Backend::UsedAddressRange::registerFree(uintptr_t left, uintptr_t right)
 }
 #endif // CHECK_ALLOCATION_RANGE
 
+// Initialized in frontend inside defaultMemPool
+extern HugePagesStatus hugePages;
+
 void *Backend::allocRawMem(size_t &size)
 {
     void *res = NULL;
-    size_t allocSize;
+    size_t allocSize = 0;
 
     if (extMemPool->userPool()) {
-        if (extMemPool->fixedPool && bootsrapMemDone==FencedLoad(bootsrapMemStatus))
+        if (extMemPool->fixedPool && bootsrapMemDone == FencedLoad(bootsrapMemStatus))
             return NULL;
-        MALLOC_ASSERT(bootsrapMemStatus!=bootsrapMemNotDone,
+        MALLOC_ASSERT(bootsrapMemStatus != bootsrapMemNotDone,
                       "Backend::allocRawMem() called prematurely?");
         // TODO: support for raw mem not aligned at sizeof(uintptr_t)
         // memory from fixed pool is asked once and only once
         allocSize = alignUpGeneric(size, extMemPool->granularity);
         res = (*extMemPool->rawAlloc)(extMemPool->poolId, allocSize);
     } else {
-        // check if alignment to huge page size is recommended
-        size_t hugePageSize = hugePages.recommendedGranularity();
-        allocSize = alignUpGeneric(size, hugePageSize? hugePageSize : extMemPool->granularity);
-        // try to get them at 1st allocation and still use, if successful
-        // if 1st try is unsuccessful, no more trying
-        if (FencedLoad(hugePages.enabled)) {
-            MALLOC_ASSERT(hugePageSize, "Inconsistent state of HugePagesStatus");
-            res = getRawMemory(allocSize, /*hugePages=*/true);
-            hugePages.registerAllocation(res);
+        // Align allocation on page size
+        size_t pageSize = hugePages.isEnabled ? hugePages.getGranularity() : extMemPool->granularity;
+        MALLOC_ASSERT(pageSize, "Page size cannot be zero.");
+        allocSize = alignUpGeneric(size, pageSize);
+
+        // If user requested huge pages and they are available, try to use preallocated ones firstly.
+        // If there are none, lets check transparent huge pages support and use them instead.
+        if (hugePages.isEnabled) {
+            if (hugePages.isHPAvailable) {
+                res = getRawMemory(allocSize, PREALLOCATED_HUGE_PAGE);
+            }
+            if (!res && hugePages.isTHPAvailable) {
+                res = getRawMemory(allocSize, TRANSPARENT_HUGE_PAGE);
+            }
         }
 
-        if (!res)
-            res = getRawMemory(allocSize, /*hugePages=*/false);
+        if (!res) {
+            res = getRawMemory(allocSize, REGULAR);
+        }
     }
 
     if (res) {
@@ -185,7 +144,6 @@ bool Backend::freeRawMem(void *object, size_t size)
         fail = (*extMemPool->rawFree)(extMemPool->poolId, object, size);
     } else {
         usedAddrRange.registerFree((uintptr_t)object, (uintptr_t)object + size);
-        hugePages.registerReleasing(object, size);
         fail = freeRawMemory(object, size);
     }
     // TODO: use result in all freeRawMem() callers
@@ -263,7 +221,7 @@ class FreeBlock : BlockMutexes {
     // valid only when block is in processing, i.e. one is not free and not
     size_t        sizeTmp;    // used outside of backend
     int           myBin;      // bin that is owner of the block
-    bool          aligned;
+    bool          slabAligned;
     bool          blockInBin; // this block in myBin already
 
     FreeBlock *rightNeig(size_t sz) const {
@@ -419,9 +377,8 @@ inline void CoalRequestQ::blockWasProcessed()
 //     split the block without removing it.
 // If the free space should go to other bin(s), remove the block.
 // alignedBin is true, if all blocks in the bin have slab-aligned right side.
-FreeBlock *Backend::IndexedBins::getFromBin(int binIdx, BackendSync *sync,
-                size_t size, bool needAlignedRes, bool alignedBin, bool wait,
-                int *binLocked)
+FreeBlock *Backend::IndexedBins::getFromBin(int binIdx, BackendSync *sync, size_t size,
+        bool needAlignedRes, bool alignedBin,  bool wait, int *binLocked)
 {
     Bin *b = &freeBins[binIdx];
 try_next:
@@ -443,50 +400,36 @@ FreeBlock *Backend::IndexedBins::getFromBin(int binIdx, BackendSync *sync,
                 goto try_next;
             }
 
+            // GENERAL CASE
             if (alignedBin || !needAlignedRes) {
                 size_t splitSz = szBlock - size;
-                // If we got a block as split result,
-                // it must have a room for control structures.
-                if (szBlock >= size && (splitSz >= FreeBlock::minBlockSize ||
-                                        !splitSz))
+                // If we got a block as split result, it must have a room for control structures.
+                if (szBlock >= size && (splitSz >= FreeBlock::minBlockSize || !splitSz))
                     fBlock = curr;
             } else {
+                // SPECIAL CASE, to get aligned block from unaligned bin we have to cut the middle of a block
+                // and return remaining left and right part. Possible only in fixed pool scenario, assert for this
+                // is set inside splitBlock() function.
+
                 void *newB = alignUp(curr, slabSize);
                 uintptr_t rightNew = (uintptr_t)newB + size;
                 uintptr_t rightCurr = (uintptr_t)curr + szBlock;
-                // appropriate size, and left and right split results
-                // are either big enough or non-existent
+                // Check if the block size is sufficient,
+                // and also left and right split results are either big enough or non-existent
                 if (rightNew <= rightCurr
-                    && (newB==curr ||
-                        (uintptr_t)newB-(uintptr_t)curr >= FreeBlock::minBlockSize)
-                    && (rightNew==rightCurr ||
-                        rightCurr - rightNew >= FreeBlock::minBlockSize))
+                        && (newB == curr || ((uintptr_t)newB - (uintptr_t)curr) >= FreeBlock::minBlockSize)
+                        && (rightNew == rightCurr || (rightCurr - rightNew) >= FreeBlock::minBlockSize))
                     fBlock = curr;
             }
+
             if (fBlock) {
-                // consume must be called before result of removing from a bin
-                // is visible externally.
+                // consume must be called before result of removing from a bin is visible externally.
                 sync->blockConsumed();
-                if (alignedBin && needAlignedRes &&
-                    Backend::sizeToBin(szBlock-size) == Backend::sizeToBin(szBlock)) {
-                    // free remainder of fBlock stay in same bin,
-                    // so no need to remove it from the bin
-                    // TODO: add more "still here" cases
-                    FreeBlock *newFBlock = fBlock;
-                    // return block from right side of fBlock
-                    fBlock = (FreeBlock*)((uintptr_t)newFBlock + szBlock - size);
-                    MALLOC_ASSERT(isAligned(fBlock, slabSize), "Invalid free block");
-                    fBlock->initHeader();
-                    fBlock->setLeftFree(szBlock - size);
-                    newFBlock->setMeFree(szBlock - size);
-
-                    fBlock->sizeTmp = size;
-                } else {
-                    b->removeBlock(fBlock);
-                    if (freeBins[binIdx].empty())
-                        bitMask.set(binIdx, false);
-                    fBlock->sizeTmp = szBlock;
-                }
+                // TODO: think about cases when block stays in the same bin
+                b->removeBlock(fBlock);
+                if (freeBins[binIdx].empty())
+                    bitMask.set(binIdx, false);
+                fBlock->sizeTmp = szBlock;
                 break;
             } else { // block size is not valid, search for next block in the bin
                 curr->setMeFree(szBlock);
@@ -542,9 +485,7 @@ void Backend::Bin::removeBlock(FreeBlock *fBlock)
 void Backend::IndexedBins::addBlock(int binIdx, FreeBlock *fBlock, size_t blockSz, bool addToTail)
 {
     Bin *b = &freeBins[binIdx];
-
     fBlock->myBin = binIdx;
-    fBlock->aligned = toAlignedBin(fBlock, blockSz);
     fBlock->next = fBlock->prev = NULL;
     {
         MallocMutex::scoped_lock scopedLock(b->tLock);
@@ -571,9 +512,7 @@ bool Backend::IndexedBins::tryAddBlock(int binIdx, FreeBlock *fBlock, bool addTo
 {
     bool locked;
     Bin *b = &freeBins[binIdx];
-
     fBlock->myBin = binIdx;
-    fBlock->aligned = toAlignedBin(fBlock, fBlock->sizeTmp);
     if (addToTail) {
         fBlock->next = NULL;
         {
@@ -625,77 +564,65 @@ bool ExtMemoryPool::regionsAreReleaseable() const
     return !keepAllMemory && !delayRegsReleasing;
 }
 
-FreeBlock *Backend::splitUnalignedBlock(FreeBlock *fBlock, int num, size_t size,
-                                        bool needAlignedBlock)
+FreeBlock *Backend::splitBlock(FreeBlock *fBlock, int num, size_t size, bool blockIsAligned, bool needAlignedBlock)
 {
-    const size_t totalSize = num*size;
-    if (needAlignedBlock) {
-        size_t fBlockSz = fBlock->sizeTmp;
-        uintptr_t fBlockEnd = (uintptr_t)fBlock + fBlockSz;
-        FreeBlock *newB = alignUp(fBlock, slabSize);
-        FreeBlock *rightPart = (FreeBlock*)((uintptr_t)newB + totalSize);
-
-        // Space to use is in the middle,
-        // ... return free right part
+    const size_t totalSize = num * size;
+
+    // SPECIAL CASE, for unaligned block we have to cut the middle of a block
+    // and return remaining left and right part. Possible only in a fixed pool scenario.
+    if (needAlignedBlock && !blockIsAligned) {
+        MALLOC_ASSERT(extMemPool->fixedPool,
+                "Aligned block request from unaligned bin possible only in fixed pool scenario.");
+
+        // Space to use is in the middle
+        FreeBlock *newBlock = alignUp(fBlock, slabSize);
+        FreeBlock *rightPart = (FreeBlock*)((uintptr_t)newBlock + totalSize);
+        uintptr_t fBlockEnd = (uintptr_t)fBlock + fBlock->sizeTmp;
+
+        // Return free right part
         if ((uintptr_t)rightPart != fBlockEnd) {
             rightPart->initHeader();  // to prevent coalescing rightPart with fBlock
-            coalescAndPut(rightPart, fBlockEnd - (uintptr_t)rightPart);
-        }
-        // ... and free left part
-        if (newB != fBlock) {
-            newB->initHeader(); // to prevent coalescing fBlock with newB
-            coalescAndPut(fBlock, (uintptr_t)newB - (uintptr_t)fBlock);
+            size_t rightSize = fBlockEnd - (uintptr_t)rightPart;
+            coalescAndPut(rightPart, rightSize, toAlignedBin(rightPart, rightSize));
         }
-
-        fBlock = newB;
-        MALLOC_ASSERT(isAligned(fBlock, slabSize), ASSERT_TEXT);
-    } else {
-        if (size_t splitSz = fBlock->sizeTmp - totalSize) {
-            // split block and return free right part
-            FreeBlock *splitB = (FreeBlock*)((uintptr_t)fBlock + totalSize);
-            splitB->initHeader();
-            coalescAndPut(splitB, splitSz);
+        // And free left part
+        if (newBlock != fBlock) {
+            newBlock->initHeader(); // to prevent coalescing fBlock with newB
+            size_t leftSize = (uintptr_t)newBlock - (uintptr_t)fBlock;
+            coalescAndPut(fBlock, leftSize, toAlignedBin(fBlock, leftSize));
         }
-    }
-    FreeBlock::markBlocks(fBlock, num, size);
-    return fBlock;
-}
-
-FreeBlock *Backend::splitAlignedBlock(FreeBlock *fBlock, int num, size_t size,
-                                      bool needAlignedBlock)
-{
-    if (fBlock->sizeTmp != num*size) { // i.e., need to split the block
-        FreeBlock *newAlgnd;
-        size_t newSz;
-
+        fBlock = newBlock;
+    } else if (size_t splitSize = fBlock->sizeTmp - totalSize) { // need to split the block
+        // GENERAL CASE, cut the left or right part of the block
+        FreeBlock *splitBlock = NULL;
         if (needAlignedBlock) {
-            newAlgnd = fBlock;
-            fBlock = (FreeBlock*)((uintptr_t)newAlgnd + newAlgnd->sizeTmp
-                                  - num*size);
-            MALLOC_ASSERT(isAligned(fBlock, slabSize), "Invalid free block");
+            // For slab aligned blocks cut the right side of the block
+            // and return it to a requester, original block returns to backend
+            splitBlock = fBlock;
+            fBlock = (FreeBlock*)((uintptr_t)splitBlock + splitSize);
             fBlock->initHeader();
-            newSz = newAlgnd->sizeTmp - num*size;
         } else {
-            newAlgnd = (FreeBlock*)((uintptr_t)fBlock + num*size);
-            newSz = fBlock->sizeTmp - num*size;
-            newAlgnd->initHeader();
+            // For large object blocks cut original block and put free righ part to backend
+            splitBlock = (FreeBlock*)((uintptr_t)fBlock + totalSize);
+            splitBlock->initHeader();
         }
-        coalescAndPut(newAlgnd, newSz);
+        // Mark free block as it`s parent only when the requested type (needAlignedBlock)
+        // and returned from Bins/OS block (isAligned) are equal (XOR operation used)
+        bool markAligned = (blockIsAligned ^ needAlignedBlock) ? toAlignedBin(splitBlock, splitSize) : blockIsAligned;
+        coalescAndPut(splitBlock, splitSize, markAligned);
     }
-    MALLOC_ASSERT(!needAlignedBlock || isAligned(fBlock, slabSize),
-                  "Expect to get aligned block, if one was requested.");
+    MALLOC_ASSERT(!needAlignedBlock || isAligned(fBlock, slabSize), "Expect to get aligned block, if one was requested.");
     FreeBlock::markBlocks(fBlock, num, size);
     return fBlock;
 }
 
-inline size_t Backend::getMaxBinnedSize() const
+size_t Backend::getMaxBinnedSize() const
 {
-    return hugePages.wasObserved && !inUserPool()?
+    return hugePages.isEnabled && !inUserPool() ?
         maxBinned_HugePage : maxBinned_SmallPage;
 }
 
-inline bool Backend::MaxRequestComparator::operator()(size_t oldMaxReq,
-                                                      size_t requestSize) const
+inline bool Backend::MaxRequestComparator::operator()(size_t oldMaxReq, size_t requestSize) const
 {
     return requestSize > oldMaxReq && requestSize < backend->getMaxBinnedSize();
 }
@@ -719,7 +646,7 @@ FreeBlock *Backend::releaseMemInCaches(intptr_t startModifiedCnt,
 
 FreeBlock *Backend::askMemFromOS(size_t blockSize, intptr_t startModifiedCnt,
                                  int *lockedBinsThreshold, int numOfLockedBins,
-                                 bool *splittableRet)
+                                 bool *splittableRet, bool needSlabRegion)
 {
     FreeBlock *block;
     // The block sizes can be divided into 3 groups:
@@ -768,20 +695,21 @@ FreeBlock *Backend::askMemFromOS(size_t blockSize, intptr_t startModifiedCnt,
             // This must be done carefully, because blocks in bins can be released
             // in releaseCachesToLimit().
             const unsigned NUM_OF_REG = 3;
-            block = addNewRegion(regSz_sizeBased, MEMREG_FLEXIBLE_SIZE, /*addToBin=*/false);
+            MemRegionType regType = needSlabRegion ? MEMREG_SLAB_BLOCKS : MEMREG_LARGE_BLOCKS;
+            block = addNewRegion(regSz_sizeBased, regType, /*addToBin=*/false);
             if (block)
                 for (unsigned idx=0; idx<NUM_OF_REG; idx++)
-                    if (! addNewRegion(regSz_sizeBased, MEMREG_FLEXIBLE_SIZE, /*addToBin=*/true))
+                    if (! addNewRegion(regSz_sizeBased, regType, /*addToBin=*/true))
                         break;
         } else {
-            block = addNewRegion(regSz_sizeBased, MEMREG_SEVERAL_BLOCKS, /*addToBin=*/false);
+            block = addNewRegion(regSz_sizeBased, MEMREG_LARGE_BLOCKS, /*addToBin=*/false);
         }
         memExtendingSema.signal();
 
         // no regions found, try to clean cache
         if (!block || block == (FreeBlock*)VALID_BLOCK_IN_BIN)
             return releaseMemInCaches(startModifiedCnt, lockedBinsThreshold, numOfLockedBins);
-        // Since a region can hold more than one block it can be splitted.
+        // Since a region can hold more than one block it can be split.
         *splittableRet = true;
     }
     // after asking memory from OS, release caches if we above the memory limits
@@ -805,9 +733,9 @@ void Backend::releaseCachesToLimit()
     // do this in several tries, because backend fragmentation can prevent
     // region from releasing
     for (int cleanLocal = 0; cleanLocal<2; cleanLocal++)
-        while (cleanLocal?
-               extMemPool->allLocalCaches.cleanup(extMemPool, /*cleanOnlyUnused=*/true)
-               : extMemPool->loc.decreasingCleanup())
+        while (cleanLocal ?
+                 extMemPool->allLocalCaches.cleanup(/*cleanOnlyUnused=*/true) :
+                 extMemPool->loc.decreasingCleanup())
             if ((locTotalMemSize = FencedLoad((intptr_t&)totalMemSize)) <=
                 (locMemSoftLimit = FencedLoad((intptr_t&)memSoftLimit)))
                 return;
@@ -815,13 +743,17 @@ void Backend::releaseCachesToLimit()
     extMemPool->hardCachesCleanup();
 }
 
-FreeBlock *Backend::IndexedBins::
-    findBlock(int nativeBin, BackendSync *sync, size_t size,
-              bool resSlabAligned, bool alignedBin, int *numOfLockedBins)
+int Backend::IndexedBins::getMinNonemptyBin(unsigned startBin) const
+{
+    int p = bitMask.getMinTrue(startBin);
+    return p == -1 ? Backend::freeBinsNum : p;
+}
+
+FreeBlock *Backend::IndexedBins::findBlock(int nativeBin, BackendSync *sync, size_t size,
+        bool needAlignedBlock, bool alignedBin, int *numOfLockedBins)
 {
     for (int i=getMinNonemptyBin(nativeBin); i<freeBinsNum; i=getMinNonemptyBin(i+1))
-        if (FreeBlock *block = getFromBin(i, sync, size, resSlabAligned, alignedBin,
-                                          /*wait=*/false, numOfLockedBins))
+        if (FreeBlock *block = getFromBin(i, sync, size, needAlignedBlock, alignedBin, /*wait=*/false, numOfLockedBins))
             return block;
 
     return NULL;
@@ -838,7 +770,7 @@ void Backend::requestBootstrapMem()
     bootsrapMemStatus = bootsrapMemInitializing;
     // request some rather big region during bootstrap in advance
     // ok to get NULL here, as later we re-do a request with more modest size
-    addNewRegion(2*1024*1024, MEMREG_FLEXIBLE_SIZE, /*addToBin=*/true);
+    addNewRegion(2*1024*1024, MEMREG_SLAB_BLOCKS, /*addToBin=*/true);
     bootsrapMemStatus = bootsrapMemDone;
 }
 
@@ -868,37 +800,29 @@ FreeBlock *Backend::genericGetBlock(int num, size_t size, bool needAlignedBlock)
 
         do {
             numOfLockedBins = 0;
-
-            // TODO: try different bin search order
             if (needAlignedBlock) {
-                block = freeAlignedBins.findBlock(nativeBin, &bkndSync, num*size,
-                                    /*needAlignedBlock=*/true, /*alignedBin=*/true,
-                                    &numOfLockedBins);
-                if (!block)
-                    block = freeLargeBins.findBlock(nativeBin, &bkndSync, num*size,
-                                    /*needAlignedBlock=*/true, /*alignedBin=*/false,
-                                    &numOfLockedBins);
+                block = freeSlabAlignedBins.findBlock(nativeBin, &bkndSync, num*size, needAlignedBlock,
+                                                        /*alignedBin=*/true, &numOfLockedBins);
+                if (!block && extMemPool->fixedPool)
+                    block = freeLargeBlockBins.findBlock(nativeBin, &bkndSync, num*size, needAlignedBlock,
+                                                        /*alignedBin=*/false, &numOfLockedBins);
             } else {
-                block = freeLargeBins.findBlock(nativeBin, &bkndSync, num*size,
-                                    /*needAlignedBlock=*/false, /*alignedBin=*/false,
-                                    &numOfLockedBins);
-                if (!block)
-                    block = freeAlignedBins.findBlock(nativeBin, &bkndSync, num*size,
-                                    /*needAlignedBlock=*/false, /*alignedBin=*/true,
-                                    &numOfLockedBins);
+                block = freeLargeBlockBins.findBlock(nativeBin, &bkndSync, num*size, needAlignedBlock,
+                                                        /*alignedBin=*/false, &numOfLockedBins);
+                if (!block && extMemPool->fixedPool)
+                    block = freeSlabAlignedBins.findBlock(nativeBin, &bkndSync, num*size, needAlignedBlock,
+                                                        /*alignedBin=*/true, &numOfLockedBins);
             }
         } while (!block && numOfLockedBins>lockedBinsThreshold);
 
         if (block)
             break;
 
-        if (!(scanCoalescQ(/*forceCoalescQDrop=*/true)
-              | extMemPool->softCachesCleanup())) {
+        if (!(scanCoalescQ(/*forceCoalescQDrop=*/true) | extMemPool->softCachesCleanup())) {
             // bins are not updated,
             // only remaining possibility is to ask for more memory
-            block =
-                askMemFromOS(totalReqSize, startModifiedCnt, &lockedBinsThreshold,
-                             numOfLockedBins, &splittable);
+            block = askMemFromOS(totalReqSize, startModifiedCnt, &lockedBinsThreshold,
+                        numOfLockedBins, &splittable, needAlignedBlock);
             if (!block)
                 return NULL;
             if (block != (FreeBlock*)VALID_BLOCK_IN_BIN) {
@@ -911,10 +835,10 @@ FreeBlock *Backend::genericGetBlock(int num, size_t size, bool needAlignedBlock)
         }
     }
     MALLOC_ASSERT(block, ASSERT_TEXT);
-    if (splittable)
-        block = toAlignedBin(block, block->sizeTmp)?
-            splitAlignedBlock(block, num, size, needAlignedBlock) :
-            splitUnalignedBlock(block, num, size, needAlignedBlock);
+    if (splittable) {
+        // At this point we have to be sure that slabAligned attribute describes the right block state
+        block = splitBlock(block, num, size, block->slabAligned, needAlignedBlock);
+    }
     // matched blockConsumed() from startUseBlock()
     bkndSync.blockReleased();
 
@@ -933,12 +857,22 @@ LargeMemoryBlock *Backend::getLargeBlock(size_t size)
     return lmb;
 }
 
+BlockI *Backend::getSlabBlock(int num) {
+    BlockI *b = (BlockI*)genericGetBlock(num, slabSize, /*slabAligned=*/true);
+    MALLOC_ASSERT(isAligned(b, slabSize), ASSERT_TEXT);
+    return b;
+}
+
+void Backend::putSlabBlock(BlockI *block) {
+    genericPutBlock((FreeBlock *)block, slabSize, /*slabAligned=*/true);
+}
+
 void *Backend::getBackRefSpace(size_t size, bool *rawMemUsed)
 {
     // This block is released only at shutdown, so it can prevent
     // a entire region releasing when it's received from the backend,
     // so prefer getRawMemory using.
-    if (void *ret = getRawMemory(size, /*hugePages=*/false)) {
+    if (void *ret = getRawMemory(size, REGULAR)) {
         *rawMemUsed = true;
         return ret;
     }
@@ -957,17 +891,17 @@ void Backend::putBackRefSpace(void *b, size_t size, bool rawMemUsed)
 void Backend::removeBlockFromBin(FreeBlock *fBlock)
 {
     if (fBlock->myBin != Backend::NO_BIN) {
-        if (fBlock->aligned)
-            freeAlignedBins.lockRemoveBlock(fBlock->myBin, fBlock);
+        if (fBlock->slabAligned)
+            freeSlabAlignedBins.lockRemoveBlock(fBlock->myBin, fBlock);
         else
-            freeLargeBins.lockRemoveBlock(fBlock->myBin, fBlock);
+            freeLargeBlockBins.lockRemoveBlock(fBlock->myBin, fBlock);
     }
 }
 
-void Backend::genericPutBlock(FreeBlock *fBlock, size_t blockSz)
+void Backend::genericPutBlock(FreeBlock *fBlock, size_t blockSz, bool slabAligned)
 {
     bkndSync.blockConsumed();
-    coalescAndPut(fBlock, blockSz);
+    coalescAndPut(fBlock, blockSz, slabAligned);
     bkndSync.blockReleased();
 }
 
@@ -996,7 +930,7 @@ void Backend::putLargeBlock(LargeMemoryBlock *lmb)
 {
     if (extMemPool->userPool())
         extMemPool->lmbList.remove(lmb);
-    genericPutBlock((FreeBlock *)lmb, lmb->unalignedSize);
+    genericPutBlock((FreeBlock *)lmb, lmb->unalignedSize, false);
 }
 
 void Backend::returnLargeObject(LargeMemoryBlock *lmb)
@@ -1030,9 +964,10 @@ void *Backend::remap(void *ptr, size_t oldSize, size_t newSize, size_t alignment
     if (oldRegion->type != MEMREG_ONE_BLOCK)
         return NULL;  // we are not single in the region
     const size_t userOffset = (uintptr_t)ptr - (uintptr_t)oldRegion;
+    const size_t alignedSize = LargeObjectCache::alignToBin(newSize + userOffset);
     const size_t requestSize =
-        alignUp(userOffset + newSize + sizeof(LastFreeBlock), extMemPool->granularity);
-    if (requestSize < newSize) // is wrapped around?
+        alignUp(sizeof(MemRegion) + alignedSize + sizeof(LastFreeBlock), extMemPool->granularity);
+    if (requestSize < alignedSize) // is wrapped around?
         return NULL;
     regionList.remove(oldRegion);
 
@@ -1044,12 +979,10 @@ void *Backend::remap(void *ptr, size_t oldSize, size_t newSize, size_t alignment
     MemRegion *region = (MemRegion*)ret;
     MALLOC_ASSERT(region->type == MEMREG_ONE_BLOCK, ASSERT_TEXT);
     region->allocSz = requestSize;
+    region->blockSz = alignedSize;
 
     FreeBlock *fBlock = (FreeBlock *)alignUp((uintptr_t)region + sizeof(MemRegion),
                                              largeObjectAlignment);
-    // put LastFreeBlock at the very end of region
-    const uintptr_t fBlockEnd = (uintptr_t)region + requestSize - sizeof(LastFreeBlock);
-    region->blockSz = fBlockEnd - (uintptr_t)fBlock;
 
     regionList.add(region);
     startUseBlock(region, fBlock, /*addToBin=*/false);
@@ -1058,7 +991,7 @@ void *Backend::remap(void *ptr, size_t oldSize, size_t newSize, size_t alignment
     // TODO: get rid of useless pair blockConsumed()/blockReleased()
     bkndSync.blockReleased();
 
-    // object must start at same offest from region's start
+    // object must start at same offset from region's start
     void *object = (void*)((uintptr_t)region + userOffset);
     MALLOC_ASSERT(isAligned(object, alignment), ASSERT_TEXT);
     LargeObjectHdr *header = (LargeObjectHdr*)object - 1;
@@ -1173,8 +1106,7 @@ FreeBlock *Backend::doCoalesc(FreeBlock *fBlock, MemRegion **mRegion)
     return resBlock;
 }
 
-bool Backend::coalescAndPutList(FreeBlock *list, bool forceCoalescQDrop,
-                                bool reportBlocksProcessed)
+bool Backend::coalescAndPutList(FreeBlock *list, bool forceCoalescQDrop, bool reportBlocksProcessed)
 {
     bool regionReleased = false;
 
@@ -1204,12 +1136,12 @@ bool Backend::coalescAndPutList(FreeBlock *list, bool forceCoalescQDrop,
         }
         size_t currSz = toRet->sizeTmp;
         int bin = sizeToBin(currSz);
-        bool toAligned = toAlignedBin(toRet, currSz);
+        bool toAligned = extMemPool->fixedPool ? toAlignedBin(toRet, currSz) : toRet->slabAligned;
         bool needAddToBin = true;
 
         if (toRet->blockInBin) {
             // Does it stay in same bin?
-            if (toRet->myBin == bin && toRet->aligned == toAligned)
+            if (toRet->myBin == bin && toRet->slabAligned == toAligned)
                 needAddToBin = false;
             else {
                 toRet->blockInBin = false;
@@ -1221,12 +1153,13 @@ bool Backend::coalescAndPutList(FreeBlock *list, bool forceCoalescQDrop,
         if (needAddToBin) {
             toRet->prev = toRet->next = toRet->nextToFree = NULL;
             toRet->myBin = NO_BIN;
+            toRet->slabAligned = toAligned;
 
             // If the block is too small to fit in any bin, keep it bin-less.
             // It's not a leak because the block later can be coalesced.
             if (currSz >= minBinnedSize) {
                 toRet->sizeTmp = currSz;
-                IndexedBins *target = toAligned? &freeAlignedBins : &freeLargeBins;
+                IndexedBins *target = toRet->slabAligned ? &freeSlabAlignedBins : &freeLargeBlockBins;
                 if (forceCoalescQDrop) {
                     target->addBlock(bin, toRet, toRet->sizeTmp, addToTail);
                 } else if (!target->tryAddBlock(bin, toRet, addToTail)) {
@@ -1249,10 +1182,11 @@ bool Backend::coalescAndPutList(FreeBlock *list, bool forceCoalescQDrop,
 
 // Coalesce fBlock and add it back to a bin;
 // processing delayed coalescing requests.
-void Backend::coalescAndPut(FreeBlock *fBlock, size_t blockSz)
+void Backend::coalescAndPut(FreeBlock *fBlock, size_t blockSz, bool slabAligned)
 {
     fBlock->sizeTmp = blockSz;
     fBlock->nextToFree = NULL;
+    fBlock->slabAligned = slabAligned;
 
     coalescAndPutList(fBlock, /*forceCoalescQDrop=*/false, /*reportBlocksProcessed=*/false);
 }
@@ -1266,7 +1200,7 @@ bool Backend::scanCoalescQ(bool forceCoalescQDrop)
         // matches blockConsumed() from CoalRequestQ::putBlock()
         coalescAndPutList(currCoalescList, forceCoalescQDrop,
                           /*reportBlocksProcessed=*/true);
-    // returns status of coalescQ.getAll(), as an indication of possibe changes in backend
+    // returns status of coalescQ.getAll(), as an indication of possible changes in backend
     // TODO: coalescAndPutList() may report is some new free blocks became available or not
     return currCoalescList;
 }
@@ -1282,13 +1216,11 @@ FreeBlock *Backend::findBlockInRegion(MemRegion *region, size_t exactBlockSize)
         "Atomic applied on LastFreeBlock, and we put it at the end of region, that"
         " is uintptr_t-aligned, so no unaligned atomic operations are possible.");
      // right bound is slab-aligned, keep LastFreeBlock after it
-    if (region->type==MEMREG_FLEXIBLE_SIZE) {
-        fBlock = (FreeBlock *)alignUp((uintptr_t)region + sizeof(MemRegion),
-                                      sizeof(uintptr_t));
+    if (region->type == MEMREG_SLAB_BLOCKS) {
+        fBlock = (FreeBlock *)alignUp((uintptr_t)region + sizeof(MemRegion), sizeof(uintptr_t));
         fBlockEnd = alignDown(lastFreeBlock, slabSize);
     } else {
-        fBlock = (FreeBlock *)alignUp((uintptr_t)region + sizeof(MemRegion),
-                                      largeObjectAlignment);
+        fBlock = (FreeBlock *)alignUp((uintptr_t)region + sizeof(MemRegion), largeObjectAlignment);
         fBlockEnd = (uintptr_t)fBlock + exactBlockSize;
         MALLOC_ASSERT(fBlockEnd <= lastFreeBlock, ASSERT_TEXT);
     }
@@ -1305,7 +1237,7 @@ FreeBlock *Backend::findBlockInRegion(MemRegion *region, size_t exactBlockSize)
     return fBlock;
 }
 
-// startUseBlock adds free block to a bin, the block can be used and
+// startUseBlock may add the free block to a bin, the block can be used and
 // even released after this, so the region must be added to regionList already
 void Backend::startUseBlock(MemRegion *region, FreeBlock *fBlock, bool addToBin)
 {
@@ -1326,17 +1258,20 @@ void Backend::startUseBlock(MemRegion *region, FreeBlock *fBlock, bool addToBin)
         unsigned targetBin = sizeToBin(blockSz);
         // during adding advance regions, register bin for a largest block in region
         advRegBins.registerBin(targetBin);
-        if (region->type!=MEMREG_ONE_BLOCK && toAlignedBin(fBlock, blockSz)) {
-            freeAlignedBins.addBlock(targetBin, fBlock, blockSz, /*addToTail=*/false);
+        if (region->type == MEMREG_SLAB_BLOCKS) {
+            fBlock->slabAligned = true;
+            freeSlabAlignedBins.addBlock(targetBin, fBlock, blockSz, /*addToTail=*/false);
         } else {
-            freeLargeBins.addBlock(targetBin, fBlock, blockSz, /*addToTail=*/false);
+            fBlock->slabAligned = false;
+            freeLargeBlockBins.addBlock(targetBin, fBlock, blockSz, /*addToTail=*/false);
         }
     } else {
         // to match with blockReleased() in genericGetBlock
         bkndSync.blockConsumed();
+        // Understand our alignment for correct splitBlock operation
+        fBlock->slabAligned = region->type == MEMREG_SLAB_BLOCKS ? true : false;
         fBlock->sizeTmp = fBlock->tryLockBlock();
-        MALLOC_ASSERT(fBlock->sizeTmp >= FreeBlock::minBlockSize,
-                      "Locking must be successful");
+        MALLOC_ASSERT(fBlock->sizeTmp >= FreeBlock::minBlockSize, "Locking must be successful");
     }
 }
 
@@ -1380,9 +1315,9 @@ FreeBlock *Backend::addNewRegion(size_t size, MemRegionType memRegType, bool add
                  "Header must be not overwritten in used blocks");
     MALLOC_ASSERT(FreeBlock::minBlockSize > GuardedSize::MAX_SPEC_VAL,
           "Block length must not conflict with special values of GuardedSize");
-    // If the region is not "flexible size" we should reserve some space for
+    // If the region is not "for slabs" we should reserve some space for
     // a region header, the worst case alignment and the last block mark.
-    const size_t requestSize = memRegType == MEMREG_FLEXIBLE_SIZE ? size :
+    const size_t requestSize = memRegType == MEMREG_SLAB_BLOCKS ? size :
         size + sizeof(MemRegion) + largeObjectAlignment
              +  FreeBlock::minBlockSize + sizeof(LastFreeBlock);
 
@@ -1426,8 +1361,8 @@ void Backend::reset()
     // no active threads are allowed in backend while reset() called
     verify();
 
-    freeLargeBins.reset();
-    freeAlignedBins.reset();
+    freeLargeBlockBins.reset();
+    freeSlabAlignedBins.reset();
     advRegBins.reset();
 
     for (MemRegion *curr = regionList.head; curr; curr = curr->next) {
@@ -1443,8 +1378,8 @@ bool Backend::destroy()
     // no active threads are allowed in backend while destroy() called
     verify();
     if (!inUserPool()) {
-        freeLargeBins.reset();
-        freeAlignedBins.reset();
+        freeLargeBlockBins.reset();
+        freeSlabAlignedBins.reset();
     }
     while (regionList.head) {
         MemRegion *helper = regionList.head->next;
@@ -1463,10 +1398,10 @@ bool Backend::clean()
     // because such regions are added in advance (see askMemFromOS() and reset()),
     // and never used. Release them all.
     for (int i = advRegBins.getMinUsedBin(0); i != -1; i = advRegBins.getMinUsedBin(i+1)) {
-        if (i == freeAlignedBins.getMinNonemptyBin(i))
-            res |= freeAlignedBins.tryReleaseRegions(i, this);
-        if (i == freeLargeBins.getMinNonemptyBin(i))
-            res |= freeLargeBins.tryReleaseRegions(i, this);
+        if (i == freeSlabAlignedBins.getMinNonemptyBin(i))
+            res |= freeSlabAlignedBins.tryReleaseRegions(i, this);
+        if (i == freeLargeBlockBins.getMinNonemptyBin(i))
+            res |= freeLargeBlockBins.tryReleaseRegions(i, this);
     }
 
     return res;
@@ -1494,8 +1429,8 @@ void Backend::verify()
 #if MALLOC_DEBUG
     scanCoalescQ(/*forceCoalescQDrop=*/false);
 
-    freeLargeBins.verify();
-    freeAlignedBins.verify();
+    freeLargeBlockBins.verify();
+    freeSlabAlignedBins.verify();
 #endif // MALLOC_DEBUG
 }
 
@@ -1544,9 +1479,9 @@ void Backend::reportStat(FILE *f)
     int regNum = regionList.reportStat(f);
     fprintf(f, "\n%d regions, %lu KB in all regions\n  free bins:\nlarge bins: ",
             regNum, totalMemSize/1024);
-    freeLargeBins.reportStat(f);
+    freeLargeBlockBins.reportStat(f);
     fprintf(f, "\naligned bins: ");
-    freeAlignedBins.reportStat(f);
+    freeSlabAlignedBins.reportStat(f);
     fprintf(f, "\n");
 }
 #endif // __TBB_MALLOC_BACKEND_STAT
diff --git a/src/tbb/src/tbbmalloc/backend.h b/src/tbb/src/tbbmalloc/backend.h
new file mode 100644
index 00000000..197775ac
--- /dev/null
+++ b/src/tbb/src/tbbmalloc/backend.h
@@ -0,0 +1,385 @@
+/*
+    Copyright (c) 2005-2020 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.
+*/
+
+#ifndef __TBB_tbbmalloc_internal_H
+    #error tbbmalloc_internal.h must be included at this point
+#endif
+
+#ifndef __TBB_backend_H
+#define __TBB_backend_H
+
+// Included from namespace rml::internal
+
+// global state of blocks currently in processing
+class BackendSync {
+    // Class instances should reside in zero-initialized memory!
+    // The number of blocks currently removed from a bin and not returned back
+    intptr_t inFlyBlocks;         // to another
+    intptr_t binsModifications;   // incremented on every bin modification
+    Backend *backend;
+public:
+    void init(Backend *b) { backend = b; }
+    void blockConsumed() { AtomicIncrement(inFlyBlocks); }
+    void binsModified() { AtomicIncrement(binsModifications); }
+    void blockReleased() {
+#if __TBB_MALLOC_BACKEND_STAT
+        MALLOC_ITT_SYNC_RELEASING(&inFlyBlocks);
+#endif
+        AtomicIncrement(binsModifications);
+        intptr_t prev = AtomicAdd(inFlyBlocks, -1);
+        MALLOC_ASSERT(prev > 0, ASSERT_TEXT);
+        suppress_unused_warning(prev);
+    }
+    intptr_t getNumOfMods() const { return FencedLoad(binsModifications); }
+    // return true if need re-do the blocks search
+    inline bool waitTillBlockReleased(intptr_t startModifiedCnt);
+};
+
+class CoalRequestQ { // queue of free blocks that coalescing was delayed
+private:
+    FreeBlock   *blocksToFree;
+    BackendSync *bkndSync;
+    // counted blocks in blocksToFree and that are leaved blocksToFree
+    // and still in active coalescing
+    intptr_t     inFlyBlocks;
+public:
+    void init(BackendSync *bSync) { bkndSync = bSync; }
+    FreeBlock *getAll(); // return current list of blocks and make queue empty
+    void putBlock(FreeBlock *fBlock);
+    inline void blockWasProcessed();
+    intptr_t blocksInFly() const { return FencedLoad(inFlyBlocks); }
+};
+
+class MemExtendingSema {
+    intptr_t     active;
+public:
+    bool wait() {
+        bool rescanBins = false;
+        // up to 3 threads can add more memory from OS simultaneously,
+        // rest of threads have to wait
+        for (;;) {
+            intptr_t prevCnt = FencedLoad(active);
+            if (prevCnt < 3) {
+                intptr_t n = AtomicCompareExchange(active, prevCnt+1, prevCnt);
+                if (n == prevCnt)
+                    break;
+            } else {
+                SpinWaitWhileEq(active, prevCnt);
+                rescanBins = true;
+                break;
+            }
+        }
+        return rescanBins;
+    }
+    void signal() { AtomicAdd(active, -1); }
+};
+
+enum MemRegionType {
+    // The region holds only slabs
+    MEMREG_SLAB_BLOCKS = 0,
+    // The region can hold several large object blocks
+    MEMREG_LARGE_BLOCKS,
+    // The region holds only one block with a requested size
+    MEMREG_ONE_BLOCK
+};
+
+class MemRegionList {
+    MallocMutex regionListLock;
+public:
+    MemRegion  *head;
+    void add(MemRegion *r);
+    void remove(MemRegion *r);
+    int reportStat(FILE *f);
+};
+
+class Backend {
+private:
+/* Blocks in range [minBinnedSize; getMaxBinnedSize()] are kept in bins,
+   one region can contains several blocks. Larger blocks are allocated directly
+   and one region always contains one block.
+*/
+    enum {
+        minBinnedSize = 8*1024UL,
+        /*   If huge pages are available, maxBinned_HugePage used.
+             If not, maxBinned_SmallPage is the threshold.
+             TODO: use pool's granularity for upper bound setting.*/
+        maxBinned_SmallPage = 1024*1024UL,
+        // TODO: support other page sizes
+        maxBinned_HugePage = 4*1024*1024UL
+    };
+    enum {
+        VALID_BLOCK_IN_BIN = 1 // valid block added to bin, not returned as result
+    };
+public:
+    // Backend bins step is the same as CacheStep for large object cache
+    static const size_t   freeBinsStep = LargeObjectCache::LargeBSProps::CacheStep;
+    static const unsigned freeBinsNum = (maxBinned_HugePage-minBinnedSize)/freeBinsStep + 1;
+
+    // if previous access missed per-thread slabs pool,
+    // allocate numOfSlabAllocOnMiss blocks in advance
+    static const int numOfSlabAllocOnMiss = 2;
+
+    enum {
+        NO_BIN = -1,
+        // special bin for blocks >= maxBinned_HugePage, blocks go to this bin
+        // when pool is created with keepAllMemory policy
+        // TODO: currently this bin is scanned using "1st fit", as it accumulates
+        // blocks of different sizes, "best fit" is preferred in terms of fragmentation
+        HUGE_BIN = freeBinsNum-1
+    };
+
+    // Bin keeps 2-linked list of free blocks. It must be 2-linked
+    // because during coalescing a block it's removed from a middle of the list.
+    struct Bin {
+        FreeBlock   *head,
+                    *tail;
+        MallocMutex  tLock;
+
+        void removeBlock(FreeBlock *fBlock);
+        void reset() { head = tail = 0; }
+        bool empty() const { return !head; }
+
+        size_t countFreeBlocks();
+        size_t reportFreeBlocks(FILE *f);
+        void reportStat(FILE *f);
+    };
+
+    typedef BitMaskMin<Backend::freeBinsNum> BitMaskBins;
+
+    // array of bins supplemented with bitmask for fast finding of non-empty bins
+    class IndexedBins {
+        BitMaskBins bitMask;
+        Bin         freeBins[Backend::freeBinsNum];
+        FreeBlock *getFromBin(int binIdx, BackendSync *sync, size_t size,
+                bool needAlignedBlock, bool alignedBin, bool wait, int *resLocked);
+    public:
+        FreeBlock *findBlock(int nativeBin, BackendSync *sync, size_t size,
+                bool needAlignedBlock, bool alignedBin,int *numOfLockedBins);
+        bool tryReleaseRegions(int binIdx, Backend *backend);
+        void lockRemoveBlock(int binIdx, FreeBlock *fBlock);
+        void addBlock(int binIdx, FreeBlock *fBlock, size_t blockSz, bool addToTail);
+        bool tryAddBlock(int binIdx, FreeBlock *fBlock, bool addToTail);
+        int  getMinNonemptyBin(unsigned startBin) const;
+        void verify();
+        void reset();
+        void reportStat(FILE *f);
+    };
+
+private:
+    class AdvRegionsBins {
+        BitMaskBins bins;
+    public:
+        void registerBin(int regBin) { bins.set(regBin, 1); }
+        int getMinUsedBin(int start) const { return bins.getMinTrue(start); }
+        void reset() { bins.reset(); }
+    };
+    // auxiliary class to atomic maximum request finding
+    class MaxRequestComparator {
+        const Backend *backend;
+    public:
+        MaxRequestComparator(const Backend *be) : backend(be) {}
+        inline bool operator()(size_t oldMaxReq, size_t requestSize) const;
+    };
+
+#if CHECK_ALLOCATION_RANGE
+    // Keep min and max of all addresses requested from OS,
+    // use it for checking memory possibly allocated by replaced allocators
+    // and for debugging purposes. Valid only for default memory pool.
+    class UsedAddressRange {
+        static const uintptr_t ADDRESS_UPPER_BOUND = UINTPTR_MAX;
+
+        uintptr_t   leftBound,
+                    rightBound;
+        MallocMutex mutex;
+    public:
+        // rightBound is zero-initialized
+        void init() { leftBound = ADDRESS_UPPER_BOUND; }
+        void registerAlloc(uintptr_t left, uintptr_t right);
+        void registerFree(uintptr_t left, uintptr_t right);
+        // as only left and right bounds are kept, we can return true
+        // for pointer not allocated by us, if more than single region
+        // was requested from OS
+        bool inRange(void *ptr) const {
+            const uintptr_t p = (uintptr_t)ptr;
+            return leftBound<=p && p<=rightBound;
+        }
+    };
+#else
+    class UsedAddressRange {
+    public:
+        void init() { }
+        void registerAlloc(uintptr_t, uintptr_t) {}
+        void registerFree(uintptr_t, uintptr_t) {}
+        bool inRange(void *) const { return true; }
+    };
+#endif
+
+    ExtMemoryPool   *extMemPool;
+    // used for release every region on pool destroying
+    MemRegionList    regionList;
+
+    CoalRequestQ     coalescQ; // queue of coalescing requests
+    BackendSync      bkndSync;
+    // semaphore protecting adding more more memory from OS
+    MemExtendingSema memExtendingSema;
+    size_t           totalMemSize,
+                     memSoftLimit;
+    UsedAddressRange usedAddrRange;
+    // to keep 1st allocation large than requested, keep bootstrapping status
+    enum {
+        bootsrapMemNotDone = 0,
+        bootsrapMemInitializing,
+        bootsrapMemDone
+    };
+    intptr_t         bootsrapMemStatus;
+    MallocMutex      bootsrapMemStatusMutex;
+
+    // Using of maximal observed requested size allows decrease
+    // memory consumption for small requests and decrease fragmentation
+    // for workloads when small and large allocation requests are mixed.
+    // TODO: decrease, not only increase it
+    size_t           maxRequestedSize;
+
+    // register bins related to advance regions
+    AdvRegionsBins advRegBins;
+    // Storage for split FreeBlocks
+    IndexedBins freeLargeBlockBins,
+                freeSlabAlignedBins;
+
+    // Our friends
+    friend class BackendSync;
+
+    /******************************** Backend methods ******************************/
+
+    /*--------------------------- Coalescing functions ----------------------------*/
+    void coalescAndPut(FreeBlock *fBlock, size_t blockSz, bool slabAligned);
+    bool coalescAndPutList(FreeBlock *head, bool forceCoalescQDrop, bool reportBlocksProcessed);
+
+    // Main coalescing operation
+    FreeBlock *doCoalesc(FreeBlock *fBlock, MemRegion **memRegion);
+
+    // Queue for conflicted blocks during coalescing
+    bool scanCoalescQ(bool forceCoalescQDrop);
+    intptr_t blocksInCoalescing() const { return coalescQ.blocksInFly(); }
+
+    /*--------------------- FreeBlock backend accessors ---------------------------*/
+    FreeBlock *genericGetBlock(int num, size_t size, bool slabAligned);
+    void genericPutBlock(FreeBlock *fBlock, size_t blockSz, bool slabAligned);
+
+    // Split the block and return remaining parts to backend if possible
+    FreeBlock *splitBlock(FreeBlock *fBlock, int num, size_t size, bool isAligned, bool needAlignedBlock);
+
+    void removeBlockFromBin(FreeBlock *fBlock);
+
+    // TODO: combine with returnLargeObject
+    void putLargeBlock(LargeMemoryBlock *lmb);
+
+    /*------------------- Starting point for OS allocation ------------------------*/
+    void requestBootstrapMem();
+    FreeBlock *askMemFromOS(size_t totalReqSize, intptr_t startModifiedCnt,
+                            int *lockedBinsThreshold, int numOfLockedBins,
+                            bool *splittable, bool needSlabRegion);
+
+    /*---------------------- Memory regions allocation ----------------------------*/
+    FreeBlock *addNewRegion(size_t size, MemRegionType type, bool addToBin);
+    void releaseRegion(MemRegion *region);
+
+    // TODO: combine in one initMemoryRegion function
+    FreeBlock *findBlockInRegion(MemRegion *region, size_t exactBlockSize);
+    void startUseBlock(MemRegion *region, FreeBlock *fBlock, bool addToBin);
+
+    /*------------------------- Raw memory accessors ------------------------------*/
+    void *allocRawMem(size_t &size);
+    bool freeRawMem(void *object, size_t size);
+
+    /*------------------------------ Cleanup functions ----------------------------*/
+    // Clean all memory from all caches (extMemPool hard cleanup)
+    FreeBlock *releaseMemInCaches(intptr_t startModifiedCnt, int *lockedBinsThreshold, int numOfLockedBins);
+    // Soft heap limit (regular cleanup, then maybe hard cleanup)
+    void releaseCachesToLimit();
+
+    /*---------------------------------- Utility ----------------------------------*/
+    // TODO: move inside IndexedBins class
+    static int sizeToBin(size_t size) {
+        if (size >= maxBinned_HugePage)
+            return HUGE_BIN;
+        else if (size < minBinnedSize)
+            return NO_BIN;
+
+        int bin = (size - minBinnedSize)/freeBinsStep;
+
+        MALLOC_ASSERT(bin < HUGE_BIN, "Invalid size.");
+        return bin;
+    }
+    static bool toAlignedBin(FreeBlock *block, size_t size) {
+        return isAligned((char*)block + size, slabSize) && size >= slabSize;
+    }
+
+public:
+    /*--------------------- Init, reset, destroy, verify  -------------------------*/
+    void init(ExtMemoryPool *extMemoryPool);
+    bool destroy();
+
+    void verify();
+    void reset();
+    bool clean(); // clean on caches cleanup
+
+    /*------------------------- Slab block request --------------------------------*/
+    BlockI *getSlabBlock(int num);
+    void putSlabBlock(BlockI *block);
+
+    /*-------------------------- Large object request -----------------------------*/
+    LargeMemoryBlock *getLargeBlock(size_t size);
+    // TODO: make consistent with getLargeBlock
+    void returnLargeObject(LargeMemoryBlock *lmb);
+
+    /*-------------------------- Backreference memory request ----------------------*/
+    void *getBackRefSpace(size_t size, bool *rawMemUsed);
+    void putBackRefSpace(void *b, size_t size, bool rawMemUsed);
+
+    /*----------------------------- Remap object ----------------------------------*/
+    void *remap(void *ptr, size_t oldSize, size_t newSize, size_t alignment);
+
+    /*---------------------------- Validation -------------------------------------*/
+    bool inUserPool() const;
+    bool ptrCanBeValid(void *ptr) const { return usedAddrRange.inRange(ptr); }
+
+    /*-------------------------- Configuration API --------------------------------*/
+    // Soft heap limit
+    void setRecommendedMaxSize(size_t softLimit) {
+        memSoftLimit = softLimit;
+        releaseCachesToLimit();
+    }
+
+    /*------------------------------- Info ----------------------------------------*/
+    size_t getMaxBinnedSize() const;
+
+    /*-------------------------- Testing, statistics ------------------------------*/
+#if __TBB_MALLOC_WHITEBOX_TEST
+    size_t getTotalMemSize() const { return totalMemSize; }
+#endif
+#if __TBB_MALLOC_BACKEND_STAT
+    void reportStat(FILE *f);
+private:
+    static size_t binToSize(int bin) {
+        MALLOC_ASSERT(bin <= HUGE_BIN, "Invalid bin.");
+
+        return bin*freeBinsStep + minBinnedSize;
+    }
+#endif
+};
+
+#endif // __TBB_backend_H
diff --git a/src/tbb/src/tbbmalloc/backref.cpp b/src/tbb/src/tbbmalloc/backref.cpp
index 3343e5b7..eeea2b90 100644
--- a/src/tbb/src/tbbmalloc/backref.cpp
+++ b/src/tbb/src/tbbmalloc/backref.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 "tbbmalloc_internal.h"
@@ -159,7 +155,7 @@ void BackRefMaster::initEmptyBackRefBlock(BackRefBlock *newBl)
 
 bool BackRefMaster::requestNewSpace()
 {
-    bool rawMemUsed;
+    bool isRawMemUsed;
     MALLOC_STATIC_ASSERT(!(blockSpaceSize % BackRefBlock::bytes),
                          "Must request space for whole number of blocks.");
 
@@ -172,7 +168,7 @@ bool BackRefMaster::requestNewSpace()
     if (listForUse) // double check that only one block is available
         return true;
     BackRefBlock *newBl =
-        (BackRefBlock*)backend->getBackRefSpace(blockSpaceSize, &rawMemUsed);
+        (BackRefBlock*)backend->getBackRefSpace(blockSpaceSize, &isRawMemUsed);
     if (!newBl) return false;
 
     // touch a page for the 1st time without taking masterMutex ...
@@ -184,7 +180,7 @@ bool BackRefMaster::requestNewSpace()
 
     const size_t numOfUnusedIdxs = backRefMaster->dataSz - lastUsed - 1;
     if (numOfUnusedIdxs <= 0) { // no space in master under lock, roll back
-        backend->putBackRefSpace(newBl, blockSpaceSize, rawMemUsed);
+        backend->putBackRefSpace(newBl, blockSpaceSize, isRawMemUsed);
         return false;
     }
     // It's possible that only part of newBl is used, due to lack of indices in master.
@@ -193,7 +189,7 @@ bool BackRefMaster::requestNewSpace()
 
     // use the first block in the batch to maintain the list of "raw" memory
     // to be released at shutdown
-    if (rawMemUsed) {
+    if (isRawMemUsed) {
         newBl->nextRawMemBlock = backRefMaster->allRawMemBlocks;
         backRefMaster->allRawMemBlocks = newBl;
     }
diff --git a/src/tbb/src/tbbmalloc/frontend.cpp b/src/tbb/src/tbbmalloc/frontend.cpp
index 9aa9a135..9f16d8e4 100644
--- a/src/tbb/src/tbbmalloc/frontend.cpp
+++ b/src/tbb/src/tbbmalloc/frontend.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 
@@ -25,6 +21,7 @@
 #include <string.h>   /* for memset */
 
 #include "../tbb/tbb_version.h"
+#include "../tbb/tbb_environment.h"
 #include "../tbb/itt_notify.h" // for __TBB_load_ittnotify()
 
 #if USE_PTHREAD
@@ -139,16 +136,19 @@ class ThreadId {
         return result;
     }
 public:
-    static void init() {
+    static bool init() {
 #if USE_WINTHREAD
         Tid_key = TlsAlloc();
+        if (Tid_key == TLS_ALLOC_FAILURE)
+            return false;
 #else
         int status = pthread_key_create( &Tid_key, NULL );
         if ( status ) {
-            fprintf (stderr, "The memory manager cannot create tls key during initialization; exiting \n");
-            exit(1);
+            fprintf (stderr, "The memory manager cannot create tls key during initialization\n");
+            return false;
         }
 #endif /* USE_WINTHREAD */
+        return true;
     }
     static void destroy() {
         if( Tid_key ) {
@@ -157,10 +157,8 @@ class ThreadId {
 #else
             int status = pthread_key_delete( Tid_key );
 #endif /* USE_WINTHREAD */
-            if ( status ) {
-                fprintf (stderr, "The memory manager cannot delete tls key; exiting \n");
-                exit(1);
-            }
+            if ( status )
+                fprintf (stderr, "The memory manager cannot delete tls key\n");
             Tid_key = 0;
         }
     }
@@ -203,7 +201,7 @@ class ThreadId {
 #else
     bool isCurrentThreadId() const { return GetCurrentThreadId() == tid; }
 #endif
-    static void init() {}
+    static bool init() { return true; }
     static void destroy() {}
 };
 
@@ -277,11 +275,12 @@ class MemoryPool {
     ExtMemoryPool  extMemPool;
     BootStrapBlocks bootStrapBlocks;
 
-    bool init(intptr_t poolId, const MemPoolPolicy* memPoolPolicy);
     static void initDefaultPool();
+
+    bool init(intptr_t poolId, const MemPoolPolicy* memPoolPolicy);
     bool reset();
     bool destroy();
-    void processThreadShutdown(TLSData *tlsData);
+    void onThreadShutdown(TLSData *tlsData);
 
     inline TLSData *getTLS(bool create);
     void clearTLS() { extMemPool.tlsPointerKey.setThreadMallocTLS(NULL); }
@@ -355,17 +354,25 @@ class LocalBlockFields : public GlobalBlockFields, Padding<blockHeaderAlignment
 class Block : public LocalBlockFields,
               Padding<2*blockHeaderAlignment - sizeof(LocalBlockFields)> {
 public:
-    bool empty() const { return allocatedCount==0 && !isSolidPtr(publicFreeList); }
+    bool empty() const {
+        if (allocatedCount > 0) return false;
+        MALLOC_ASSERT(!isSolidPtr(publicFreeList), ASSERT_TEXT);
+        return true;
+    }
     inline FreeObject* allocate();
     inline FreeObject *allocateFromFreeList();
-    inline bool emptyEnoughToUse();
+
+    inline bool adjustFullness();
+    void adjustPositionInBin(Bin* bin = NULL);
+
     bool freeListNonNull() { return freeList; }
     void freePublicObject(FreeObject *objectToFree);
     inline void freeOwnObject(void *object);
     void reset();
-    void privatizePublicFreeList( bool cleanup = false );
+    void privatizePublicFreeList( bool reset = true );
     void restoreBumpPtr();
     void privatizeOrphaned(TLSData *tls, unsigned index);
+    bool readyToShare();
     void shareOrphaned(intptr_t binTag, unsigned index);
     unsigned int getSize() const {
         MALLOC_ASSERT(isStartupAllocObject() || objectSize<minLargeObjectSize,
@@ -414,7 +421,7 @@ class Block : public LocalBlockFields,
     void cleanBlockHeader();
 
 private:
-    static const float emptyEnoughRatio; /* "Reactivate" a block if this share of its objects is free. */
+    static const float emptyEnoughRatio; /* Threshold on free space needed to "reactivate" a block */
 
     inline FreeObject *allocateFromBumpPtr();
     inline FreeObject *findAllocatedObject(const void *address) const;
@@ -441,27 +448,30 @@ MALLOC_STATIC_ASSERT(sizeof(Block) <= 2*estimatedCacheLineSize,
     "Defining USE_INTERNAL_TID may help to fix it.");
 
 class Bin {
+private:
     Block      *activeBlk;
     Block      *mailbox;
     MallocMutex mailLock;
 
 public:
     inline Block* getActiveBlock() const { return activeBlk; }
-    void resetActiveBlock() { activeBlk = 0; }
+    void resetActiveBlock() { activeBlk = NULL; }
     bool activeBlockUnused() const { return activeBlk && !activeBlk->allocatedCount; }
     inline void setActiveBlock(Block *block);
     inline Block* setPreviousBlockActive();
-    Block* getPublicFreeListBlock();
+    Block* getPrivatizedFreeListBlock();
     void moveBlockToFront(Block *block);
-    void processLessUsedBlock(MemoryPool *memPool, Block *block);
+    bool cleanPublicFreeLists();
+    void processEmptyBlock(Block *block, bool poolTheBlock);
+    void addPublicFreeListBlock(Block* block);
 
     void outofTLSBin(Block* block);
     void verifyTLSBin(size_t size) const;
     void pushTLSBin(Block* block);
 
     void verifyInitState() const {
-        MALLOC_ASSERT( activeBlk == 0, ASSERT_TEXT );
-        MALLOC_ASSERT( mailbox == 0, ASSERT_TEXT );
+        MALLOC_ASSERT( !activeBlk, ASSERT_TEXT );
+        MALLOC_ASSERT( !mailbox, ASSERT_TEXT );
     }
 
     friend void Block::freePublicObject (FreeObject *objectToFree);
@@ -518,6 +528,7 @@ const uint32_t minLargeObjectSize = fittingSize5 + 1;
  * threads memory that are likely in local cache(s) of our CPU.
  */
 class FreeBlockPool {
+private:
     Block      *head;
     int         size;
     Backend    *backend;
@@ -543,6 +554,7 @@ class FreeBlockPool {
 
 template<int LOW_MARK, int HIGH_MARK>
 class LocalLOCImpl {
+private:
     static const size_t MAX_TOTAL_SIZE = 4*1024*1024;
     // TODO: can single-linked list be faster here?
     LargeMemoryBlock *head,
@@ -577,13 +589,16 @@ class TLSData : public TLSRemote {
     TLSData(MemoryPool *mPool, Backend *bknd) : memPool(mPool), freeSlabBlocks(bknd) {}
     MemoryPool *getMemPool() const { return memPool; }
     Bin* getAllocationBin(size_t size);
-    void release(MemoryPool *mPool);
-    bool externalCleanup(ExtMemoryPool *mPool, bool cleanOnlyUnused) {
+    void release();
+    bool externalCleanup(bool cleanOnlyUnused, bool cleanBins) {
         if (!unused && cleanOnlyUnused) return false;
+        // Heavy operation in terms of synchronization complexity,
+        // should be called only for the current thread
+        bool released = cleanBins ? cleanupBlockBins() : false;
         // both cleanups to be called, and the order is not important
-        return lloc.externalCleanup(mPool) | freeSlabBlocks.externalCleanup();
+        return released | lloc.externalCleanup(&memPool->extMemPool) | freeSlabBlocks.externalCleanup();
     }
-    bool cleanUnusedActiveBlocks(Backend *backend, bool userPool);
+    bool cleanupBlockBins();
     void markUsed() { unused = false; } // called by owner when TLS touched
     void markUnused() { unused =  true; } // can be called by not owner thread
 };
@@ -605,31 +620,31 @@ TLSData *TLSKey::createTLS(MemoryPool *memPool, Backend *backend)
     return tls;
 }
 
-bool TLSData::cleanUnusedActiveBlocks(Backend *backend, bool userPool)
+bool TLSData::cleanupBlockBins()
 {
     bool released = false;
-    // active blocks can be not used, so return them to backend
-    for (uint32_t i=0; i<numBlockBinLimit; i++)
-        if (bin[i].activeBlockUnused()) {
-            Block *block = bin[i].getActiveBlock();
+    for (uint32_t i = 0; i < numBlockBinLimit; i++) {
+        released |= bin[i].cleanPublicFreeLists();
+        // After cleaning public free lists, only the active block might be empty.
+        // Do not use processEmptyBlock because it will just restore bumpPtr.
+        Block *block = bin[i].getActiveBlock();
+        if (block && block->empty()) {
             bin[i].outofTLSBin(block);
-            // slab blocks in user's pools do not have valid backRefIdx
-            if (!userPool)
-                removeBackRef(*(block->getBackRefIdx()));
-            backend->putSlabBlock(block);
-
+            memPool->returnEmptyBlock(block, /*poolTheBlock=*/false);
             released = true;
         }
+    }
     return released;
 }
 
 bool ExtMemoryPool::releaseAllLocalCaches()
 {
-    bool released = allLocalCaches.cleanup(this, /*cleanOnlyUnused=*/false);
+    // Iterate all registered TLS data and clean LLOC and Slab pools
+    bool released = allLocalCaches.cleanup(/*cleanOnlyUnused=*/false);
 
+    // Bins privatization is done only for the current thread
     if (TLSData *tlsData = tlsPointerKey.getThreadMallocTLS())
-        // released only for current thread for now
-        released |= tlsData->cleanUnusedActiveBlocks(&backend, userPool());
+        released |= tlsData->cleanupBlockBins();
 
     return released;
 }
@@ -659,17 +674,15 @@ void AllLocalCaches::unregisterThread(TLSRemote *tls)
     MALLOC_ASSERT(!tls->next || tls->next->next!=tls->next, ASSERT_TEXT);
 }
 
-bool AllLocalCaches::cleanup(ExtMemoryPool *extPool, bool cleanOnlyUnused)
+bool AllLocalCaches::cleanup(bool cleanOnlyUnused)
 {
-    bool total = false;
+    bool released = false;
     {
         MallocMutex::scoped_lock lock(listLock);
-
         for (TLSRemote *curr=head; curr; curr=curr->next)
-            total |= static_cast<TLSData*>(curr)->
-                         externalCleanup(extPool, cleanOnlyUnused);
+            released |= static_cast<TLSData*>(curr)->externalCleanup(cleanOnlyUnused, /*cleanBins=*/false);
     }
-    return total;
+    return released;
 }
 
 void AllLocalCaches::markUnused()
@@ -677,7 +690,7 @@ void AllLocalCaches::markUnused()
     bool locked;
     MallocMutex::scoped_lock lock(listLock, /*block=*/false, &locked);
     if (!locked) // not wait for marking if someone doing something with it
-        return;
+        return; 
 
     for (TLSRemote *curr=head; curr; curr=curr->next)
         static_cast<TLSData*>(curr)->markUnused();
@@ -747,7 +760,7 @@ static inline unsigned int highestBitPos(unsigned int n)
     unsigned int pos;
 #if __ARCH_x86_32||__ARCH_x86_64
 
-# if __linux__||__APPLE__||__FreeBSD__||__NetBSD__||__sun||__MINGW32__
+# if __linux__||__APPLE__||__FreeBSD__||__NetBSD__||__OpenBSD__||__sun||__MINGW32__
     __asm__ ("bsr %1,%0" : "=r"(pos) : "r"(n));
 # elif (_WIN32 && (!_WIN64 || __INTEL_COMPILER))
     __asm
@@ -980,7 +993,7 @@ inline Bin* TLSData::getAllocationBin(size_t size)
 /* Return an empty uninitialized block in a non-blocking fashion. */
 Block *MemoryPool::getEmptyBlock(size_t size)
 {
-    TLSData* tls = extMemPool.tlsPointerKey.getThreadMallocTLS();
+    TLSData* tls = getTLS(/*create=*/false);
     // try to use per-thread cache, if TLS available
     FreeBlockPool::ResOfGet resOfGet = tls?
         tls->freeSlabBlocks.getBlock() : FreeBlockPool::ResOfGet(NULL, false);
@@ -1035,9 +1048,8 @@ void MemoryPool::returnEmptyBlock(Block *block, bool poolTheBlock)
 {
     block->reset();
     if (poolTheBlock) {
-        extMemPool.tlsPointerKey.getThreadMallocTLS()->freeSlabBlocks.returnBlock(block);
-    }
-    else {
+        getTLS(/*create=*/false)->freeSlabBlocks.returnBlock(block);
+    } else {
         // slab blocks in user's pools do not have valid backRefIdx
         if (!extMemPool.userPool())
             removeBackRef(*(block->getBackRefIdx()));
@@ -1056,7 +1068,7 @@ bool ExtMemoryPool::init(intptr_t poolId, rawAllocType rawAlloc,
     this->keepAllMemory = keepAllMemory;
     this->fixedPool = fixedPool;
     this->delayRegsReleasing = false;
-    if (! initTLS())
+    if (!initTLS())
         return false;
     loc.init(this);
     backend.init(this);
@@ -1133,11 +1145,13 @@ bool MemoryPool::destroy()
     return extMemPool.destroy();
 }
 
-void MemoryPool::processThreadShutdown(TLSData *tlsData)
+void MemoryPool::onThreadShutdown(TLSData *tlsData)
 {
-    tlsData->release(this);
-    bootStrapBlocks.free(tlsData);
-    clearTLS();
+    if (tlsData) { // might be called for "empty" TLS
+        tlsData->release();
+        bootStrapBlocks.free(tlsData);
+        clearTLS();
+    }
 }
 
 #if MALLOC_DEBUG
@@ -1221,7 +1235,7 @@ void Bin::outofTLSBin(Block* block)
     if (block == activeBlk) {
         activeBlk = block->previous? block->previous : block->next;
     }
-    /* Delink the block */
+    /* Unlink the block */
     if (block->previous) {
         MALLOC_ASSERT( block->previous->next == block, ASSERT_TEXT );
         block->previous->next = block->next;
@@ -1236,7 +1250,7 @@ void Bin::outofTLSBin(Block* block)
     verifyTLSBin(size);
 }
 
-Block* Bin::getPublicFreeListBlock()
+Block* Bin::getPrivatizedFreeListBlock()
 {
     Block* block;
     MALLOC_ASSERT( this, ASSERT_TEXT );
@@ -1259,42 +1273,90 @@ Block* Bin::getPublicFreeListBlock()
     if( block ) {
         MALLOC_ASSERT( isSolidPtr(block->publicFreeList), ASSERT_TEXT );
         block->privatizePublicFreeList();
+        block->adjustPositionInBin(this);
     }
     return block;
 }
 
-bool Block::emptyEnoughToUse()
+void Bin::addPublicFreeListBlock(Block* block)
+{
+    MallocMutex::scoped_lock scoped_cs(mailLock);
+    block->nextPrivatizable = mailbox;
+    mailbox = block;
+}
+
+// Process publicly freed objects in all blocks and return empty blocks
+// to the backend in order to reduce overall footprint.
+bool Bin::cleanPublicFreeLists()
 {
-    const float threshold = (slabSize - sizeof(Block)) * (1-emptyEnoughRatio);
+    Block* block;
+    if (!FencedLoad((intptr_t&)mailbox))
+        return false;
+    else {
+        // Grab all the blocks in the mailbox
+        MallocMutex::scoped_lock scoped_cs(mailLock);
+        block = mailbox;
+        mailbox = NULL;
+    }
+    bool released = false;
+    while (block) {
+        MALLOC_ASSERT( block->isOwnedByCurrentThread(), ASSERT_TEXT );
+        Block* tmp = block->nextPrivatizable;
+        block->nextPrivatizable = (Block*) this;
+        block->privatizePublicFreeList();
+        if (block->empty()) {
+            processEmptyBlock(block, /*poolTheBlock=*/false);
+            released = true;
+        } else
+            block->adjustPositionInBin(this);
+        block = tmp;
+    }
+    return released;
+}
 
+bool Block::adjustFullness()
+{
     if (bumpPtr) {
         /* If we are still using a bump ptr for this block it is empty enough to use. */
         STAT_increment(getThreadId(), getIndex(objectSize), examineEmptyEnough);
         isFull = false;
-        return 1;
-    }
-
-    /* allocatedCount shows how many objects in the block are in use; however it still counts
-       blocks freed by other threads; so prior call to privatizePublicFreeList() is recommended */
-    isFull = (allocatedCount*objectSize > threshold)? true: false;
+    } else {
+        const float threshold = (slabSize - sizeof(Block)) * (1 - emptyEnoughRatio);
+        /* allocatedCount shows how many objects in the block are in use; however it still counts
+         * blocks freed by other threads; so prior call to privatizePublicFreeList() is recommended */
+        isFull = (allocatedCount*objectSize > threshold) ? true : false;
 #if COLLECT_STATISTICS
-    if (isFull)
-        STAT_increment(getThreadId(), getIndex(objectSize), examineNotEmpty);
-    else
-        STAT_increment(getThreadId(), getIndex(objectSize), examineEmptyEnough);
+        if (isFull)
+            STAT_increment(getThreadId(), getIndex(objectSize), examineNotEmpty);
+        else
+            STAT_increment(getThreadId(), getIndex(objectSize), examineEmptyEnough);
 #endif
-    return !isFull;
+    }
+    return isFull;
+}
+
+// This method resides in class Block, and not in class Bin, in order to avoid
+// calling getAllocationBin on a reasonably hot path in Block::freeOwnObject
+void Block::adjustPositionInBin(Bin* bin/*=NULL*/)
+{
+    // If the block were full, but became empty enough to use,
+    // move it to the front of the list 
+    if (isFull && !adjustFullness()) {
+        if (!bin)
+            bin = tlsPtr->getAllocationBin(objectSize);
+        bin->moveBlockToFront(this);
+    }
 }
 
 /* Restore the bump pointer for an empty block that is planned to use */
 void Block::restoreBumpPtr()
 {
     MALLOC_ASSERT( allocatedCount == 0, ASSERT_TEXT );
-    MALLOC_ASSERT( publicFreeList == NULL, ASSERT_TEXT );
+    MALLOC_ASSERT( !isSolidPtr(publicFreeList), ASSERT_TEXT );
     STAT_increment(getThreadId(), getIndex(objectSize), freeRestoreBumpPtr);
     bumpPtr = (FreeObject *)((uintptr_t)this + slabSize - objectSize);
     freeList = NULL;
-    isFull = 0;
+    isFull = false;
 }
 
 void Block::freeOwnObject(void *object)
@@ -1310,19 +1372,14 @@ void Block::freeOwnObject(void *object)
         STAT_increment(getThreadId(), getIndex(objectSize), freeToActiveBlock);
 #endif
     if (empty()) {
-        // The bump pointer is about to be restored for the block,
-        // no need to find objectToFree here (this is costly).
-
-        // if the last object of a slab is freed, the slab cannot be marked full
+        // If the last object of a slab is freed, the slab cannot be marked full
         MALLOC_ASSERT(!isFull, ASSERT_TEXT);
-        tlsPtr->getAllocationBin(objectSize)->processLessUsedBlock(poolPtr, this);
-    } else {
+        tlsPtr->getAllocationBin(objectSize)->processEmptyBlock(this, /*poolTheBlock=*/true);
+    } else { // hot path
         FreeObject *objectToFree = findObjectToFree(object);
         objectToFree->next = freeList;
         freeList = objectToFree;
-
-        if (isFull && emptyEnoughToUse())
-            tlsPtr->getAllocationBin(objectSize)->moveBlockToFront(this);
+        adjustPositionInBin();
     }
 }
 
@@ -1360,30 +1417,25 @@ void Block::freePublicObject (FreeObject *objectToFree)
         if( !isNotForUse(nextPrivatizable) ) {
             MALLOC_ASSERT( nextPrivatizable!=NULL, ASSERT_TEXT );
             Bin* theBin = (Bin*) nextPrivatizable;
-            MallocMutex::scoped_lock scoped_cs(theBin->mailLock);
-            nextPrivatizable = theBin->mailbox;
-            theBin->mailbox = this;
+            theBin->addPublicFreeListBlock(this);
         }
     }
     STAT_increment(getThreadId(), ThreadCommonCounters, freeToOtherThread);
     STAT_increment(ownerTid, getIndex(objectSize), freeByOtherThread);
 }
 
-void Block::privatizePublicFreeList( bool cleanup )
+// Make objects freed by other threads available for use again
+void Block::privatizePublicFreeList( bool reset )
 {
-    FreeObject *temp, *localPublicFreeList;
-    const intptr_t endMarker = cleanup? UNUSABLE : 0;
+    FreeObject *localPublicFreeList;
+    // If reset is false, publicFreeList should not be zeroed but set to UNUSABLE
+    // to properly synchronize with other threads freeing objects to this slab.
+    const intptr_t endMarker = reset ? 0 : UNUSABLE;
 
-    // During cleanup of orphaned blocks, the calling thread is not registered as the owner 
-    MALLOC_ASSERT( cleanup || isOwnedByCurrentThread(), ASSERT_TEXT );
+    // Only the owner thread may reset the pointer to NULL
+    MALLOC_ASSERT( isOwnedByCurrentThread() || !reset, ASSERT_TEXT );
 #if FREELIST_NONBLOCKING
-    temp = publicFreeList;
-    do {
-        localPublicFreeList = temp;
-        temp = (FreeObject*)AtomicCompareExchange( (intptr_t&)publicFreeList,
-                                        endMarker, (intptr_t)localPublicFreeList);
-        // no backoff necessary because trying to make change, not waiting for a change
-    } while( temp != localPublicFreeList );
+    localPublicFreeList = (FreeObject*)AtomicFetchStore( &publicFreeList, endMarker );
 #else
     STAT_increment(getThreadId(), ThreadCommonCounters, lockPublicFreeList);
     {
@@ -1391,17 +1443,17 @@ void Block::privatizePublicFreeList( bool cleanup )
         localPublicFreeList = publicFreeList;
         publicFreeList = endMarker;
     }
-    temp = localPublicFreeList;
 #endif
     MALLOC_ITT_SYNC_ACQUIRED(&publicFreeList);
+    MALLOC_ASSERT( !(reset && isNotForUse(publicFreeList)), ASSERT_TEXT );
 
-     // publicFreeList must have been UNUSABLE (possible for orphaned blocks) or valid, but not NULL
+    // publicFreeList must have been UNUSABLE or valid, but not NULL
     MALLOC_ASSERT( localPublicFreeList!=NULL, ASSERT_TEXT );
-    MALLOC_ASSERT( localPublicFreeList==temp, ASSERT_TEXT );
-    if( isSolidPtr(temp) ) {
+    if( isSolidPtr(localPublicFreeList) ) {
         MALLOC_ASSERT( allocatedCount <= (slabSize-sizeof(Block))/objectSize, ASSERT_TEXT );
         /* other threads did not change the counter freeing our blocks */
         allocatedCount--;
+        FreeObject *temp = localPublicFreeList;
         while( isSolidPtr(temp->next) ){ // the list will end with either NULL or UNUSABLE
             temp = temp->next;
             allocatedCount--;
@@ -1428,34 +1480,41 @@ void Block::privatizeOrphaned(TLSData *tls, unsigned index)
     nextPrivatizable = (Block*)bin;
     // the next call is required to change publicFreeList to 0
     privatizePublicFreeList();
-    if( allocatedCount ) {
-        emptyEnoughToUse(); // check its fullness and set result->isFull
-    } else {
+    if( empty() ) {
         restoreBumpPtr();
+    } else {
+        adjustFullness(); // check the block fullness and set isFull
     }
     MALLOC_ASSERT( !isNotForUse(publicFreeList), ASSERT_TEXT );
 }
 
+
+bool Block::readyToShare()
+{
+    void* oldval;
+#if FREELIST_NONBLOCKING
+    oldval = (void*)AtomicCompareExchange((intptr_t&)publicFreeList, UNUSABLE, 0);
+#else
+    STAT_increment(getThreadId(), ThreadCommonCounters, lockPublicFreeList);
+    {
+        MallocMutex::scoped_lock scoped_cs(publicFreeListLock);
+        if ( (oldval=publicFreeList)==NULL )
+            (intptr_t&)(publicFreeList) = UNUSABLE;
+    }
+#endif
+    return oldval==NULL;
+}
+
 void Block::shareOrphaned(intptr_t binTag, unsigned index)
 {
     MALLOC_ASSERT( binTag, ASSERT_TEXT );
     STAT_increment(getThreadId(), index, freeBlockPublic);
     markOrphaned();
-    // need to set publicFreeList to non-zero, so other threads
-    // will not change nextPrivatizable and it can be zeroed.
     if ((intptr_t)nextPrivatizable==binTag) {
-        void* oldval;
-#if FREELIST_NONBLOCKING
-        oldval = (void*)AtomicCompareExchange((intptr_t&)publicFreeList, UNUSABLE, 0);
-#else
-        STAT_increment(getThreadId(), ThreadCommonCounters, lockPublicFreeList);
-        {
-            MallocMutex::scoped_lock scoped_cs(publicFreeListLock);
-            if ( (oldval=publicFreeList)==NULL )
-                (intptr_t&)(publicFreeList) = UNUSABLE;
-        }
-#endif
-        if ( oldval!=NULL ) {
+        // First check passed: the block is not in mailbox yet.
+        // Need to set publicFreeList to non-zero, so other threads
+        // will not change nextPrivatizable and it can be zeroed.
+        if ( !readyToShare() ) {
             // another thread freed an object; we need to wait until it finishes.
             // There is no need for exponential backoff, as the wait here is not for a lock;
             // but need to yield, so the thread we wait has a chance to run.
@@ -1468,8 +1527,6 @@ void Block::shareOrphaned(intptr_t binTag, unsigned index)
                 }
             }
         }
-    } else {
-        MALLOC_ASSERT( isSolidPtr(publicFreeList), ASSERT_TEXT );
     }
     MALLOC_ASSERT( publicFreeList!=NULL, ASSERT_TEXT );
     // now it is safe to change our data
@@ -1486,7 +1543,7 @@ void Block::cleanBlockHeader()
     previous = NULL;
     freeList = NULL;
     allocatedCount = 0;
-    isFull = 0;
+    isFull = false;
     tlsPtr = NULL;
 
     publicFreeList = NULL;
@@ -1540,20 +1597,20 @@ void OrphanedBlocks::reset()
 
 bool OrphanedBlocks::cleanup(Backend* backend)
 {
-    bool result = false;
+    bool released = false;
     for (uint32_t i=0; i<numBlockBinLimit; i++) {
         Block* block = bins[i].grab();
         MALLOC_ITT_SYNC_ACQUIRED(bins+i);
         while (block) {
             Block* next = block->next;
-            block->privatizePublicFreeList( /*cleanup=*/true );
+            block->privatizePublicFreeList( /*reset=*/false ); // do not set publicFreeList to NULL
             if (block->empty()) {
                 block->reset();
                 // slab blocks in user's pools do not have valid backRefIdx
                 if (!backend->inUserPool())
                     removeBackRef(*(block->getBackRefIdx()));
                 backend->putSlabBlock(block);
-                result = true;
+                released = true;
             } else {
                 MALLOC_ITT_SYNC_RELEASING(bins+i);
                 bins[i].push(block);
@@ -1561,7 +1618,7 @@ bool OrphanedBlocks::cleanup(Backend* backend)
             block = next;
         }
     }
-    return result;
+    return released;
 }
 
 FreeBlockPool::ResOfGet FreeBlockPool::getBlock()
@@ -1612,7 +1669,7 @@ void FreeBlockPool::returnBlock(Block *block)
 bool FreeBlockPool::externalCleanup()
 {
     Block *helper;
-    bool nonEmpty = false;
+    bool released = false;
 
     for (Block *currBl=(Block*)AtomicFetchStore(&head, 0); currBl; currBl=helper) {
         helper = currBl->next;
@@ -1620,9 +1677,9 @@ bool FreeBlockPool::externalCleanup()
         if (!backend->inUserPool())
             removeBackRef(currBl->backRefIdx);
         backend->putSlabBlock(currBl);
-        nonEmpty = true;
+        released = true;
     }
-    return nonEmpty;
+    return released;
 }
 
 /* Prepare the block for returning to FreeBlockPool */
@@ -1656,7 +1713,7 @@ inline Block* Bin::setPreviousBlockActive()
     MALLOC_ASSERT( activeBlk, ASSERT_TEXT );
     Block* temp = activeBlk->previous;
     if( temp ) {
-        MALLOC_ASSERT( temp->isFull == 0, ASSERT_TEXT );
+        MALLOC_ASSERT( !(temp->isFull), ASSERT_TEXT );
         activeBlk = temp;
     }
     return temp;
@@ -1691,10 +1748,10 @@ FreeObject *Block::findObjectToFree(const void *object) const
     return objectToFree;
 }
 
-void TLSData::release(MemoryPool *mPool)
+void TLSData::release()
 {
-    mPool->extMemPool.allLocalCaches.unregisterThread(this);
-    externalCleanup(&mPool->extMemPool, /*cleanOnlyUnused=*/false);
+    memPool->extMemPool.allLocalCaches.unregisterThread(this);
+    externalCleanup(/*cleanOnlyUnused=*/false, /*cleanBins=*/false);
 
     for (unsigned index = 0; index < numBlockBins; index++) {
         Block *activeBlk = bin[index].getActiveBlock();
@@ -1705,9 +1762,9 @@ void TLSData::release(MemoryPool *mPool)
             Block *threadBlock = threadlessBlock->previous;
             if (threadlessBlock->empty()) {
                 /* we destroy the thread, so not use its block pool */
-                mPool->returnEmptyBlock(threadlessBlock, /*poolTheBlock=*/false);
+                memPool->returnEmptyBlock(threadlessBlock, /*poolTheBlock=*/false);
             } else {
-                mPool->extMemPool.orphanedBlocks.put(intptr_t(bin+index), threadlessBlock);
+                memPool->extMemPool.orphanedBlocks.put(intptr_t(bin+index), threadlessBlock);
             }
             threadlessBlock = threadBlock;
         }
@@ -1716,9 +1773,9 @@ void TLSData::release(MemoryPool *mPool)
             Block *threadBlock = threadlessBlock->next;
             if (threadlessBlock->empty()) {
                 /* we destroy the thread, so not use its block pool */
-                mPool->returnEmptyBlock(threadlessBlock, /*poolTheBlock=*/false);
+                memPool->returnEmptyBlock(threadlessBlock, /*poolTheBlock=*/false);
             } else {
-                mPool->extMemPool.orphanedBlocks.put(intptr_t(bin+index), threadlessBlock);
+                memPool->extMemPool.orphanedBlocks.put(intptr_t(bin+index), threadlessBlock);
             }
             threadlessBlock = threadBlock;
         }
@@ -1873,54 +1930,6 @@ static MallocMutex initMutex;
     delivers a clean result. */
 static char VersionString[] = "\0" TBBMALLOC_VERSION_STRINGS;
 
-#if __TBB_WIN8UI_SUPPORT
-bool GetBoolEnvironmentVariable(const char *) { return false; }
-#else
-bool GetBoolEnvironmentVariable(const char *name)
-{
-    if (const char* s = getenv(name))
-        return strcmp(s,"0") != 0;
-    return false;
-}
-#endif
-
-void AllocControlledMode::initReadEnv(const char *envName, intptr_t defaultVal)
-{
-    if (!setDone) {
-#if !__TBB_WIN8UI_SUPPORT
-    // TODO: use strtol to get the actual value of the envirable
-        const char *envVal = getenv(envName);
-        if (envVal && !strcmp(envVal, "1"))
-            val = 1;
-        else
-#endif
-            val = defaultVal;
-        setDone = true;
-    }
-}
-
-void MemoryPool::initDefaultPool()
-{
-    long long unsigned hugePageSize = 0;
-#if __linux__
-    if (FILE *f = fopen("/proc/meminfo", "r")) {
-        const int READ_BUF_SIZE = 100;
-        char buf[READ_BUF_SIZE];
-        MALLOC_STATIC_ASSERT(sizeof(hugePageSize) >= 8,
-              "At least 64 bits required for keeping page size/numbers.");
-
-        while (fgets(buf, READ_BUF_SIZE, f)) {
-            if (1 == sscanf(buf, "Hugepagesize: %llu kB", &hugePageSize)) {
-                hugePageSize *= 1024;
-                break;
-            }
-        }
-        fclose(f);
-    }
-#endif
-    hugePages.init(hugePageSize);
-}
-
 #if USE_PTHREAD && (__TBB_SOURCE_DIRECTLY_INCLUDED || __TBB_USE_DLOPEN_REENTRANCY_WORKAROUND)
 
 /* Decrease race interval between dynamic library unloading and pthread key
@@ -1933,8 +1942,8 @@ class ShutdownSync {
     static const intptr_t skipDtor = INTPTR_MIN/2;
 public:
     void init() { flag = 0; }
-/* Suppose that 2*abs(skipDtor) or more threads never call threadExitStart()
-   simultaneously, so flag is never becomes negative because of that. */
+/* Suppose that 2*abs(skipDtor) or more threads never call threadDtorStart()
+   simultaneously, so flag never becomes negative because of that. */
     bool threadDtorStart() {
         if (flag < 0)
             return false;
@@ -1977,7 +1986,7 @@ bool isMallocInitializedExt() {
     return isMallocInitialized();
 }
 
-/** Caller is responsible for ensuring this routine is called exactly once. */
+/* Caller is responsible for ensuring this routine is called exactly once. */
 extern "C" void MallocInitializeITT() {
 #if DO_ITT_NOTIFY
     if (!usedBySrcIncluded)
@@ -1985,6 +1994,10 @@ extern "C" void MallocInitializeITT() {
 #endif
 }
 
+void MemoryPool::initDefaultPool() {
+    hugePages.init();
+}
+
 /*
  * Allocator initialization routine;
  * it is called lazily on the very first scalable_malloc call.
@@ -2004,13 +2017,17 @@ static bool initMemoryManager()
     // POSIX.1-2001-compliant way to get page size
     const size_t granularity = sysconf(_SC_PAGESIZE);
 #endif
+    if (!defaultMemPool) {
+        // Do not rely on static constructors and do the assignment in case
+        // of library static section not initialized at this call yet.
+        defaultMemPool = (MemoryPool*)defaultMemPool_space;
+    }
     bool initOk = defaultMemPool->
         extMemPool.init(0, NULL, NULL, granularity,
                         /*keepAllMemory=*/false, /*fixedPool=*/false);
 // TODO: extMemPool.init() to not allocate memory
-    if (!initOk || !initBackRefMaster(&defaultMemPool->extMemPool.backend))
+    if (!initOk || !initBackRefMaster(&defaultMemPool->extMemPool.backend) || !ThreadId::init())
         return false;
-    ThreadId::init();      // Create keys for thread id
     MemoryPool::initDefaultPool();
     // init() is required iff initMemoryManager() is called
     // after mallocProcessShutdownNotification()
@@ -2021,6 +2038,10 @@ static bool initMemoryManager()
     return true;
 }
 
+static bool GetBoolEnvironmentVariable(const char* name) {
+    return tbb::internal::GetBoolEnvironmentVariable(name);
+}
+
 //! Ensures that initMemoryManager() is called once and only once.
 /** Does not return until initMemoryManager() has been completed by a thread.
     There is no need to call this routine if mallocInitialized==2 . */
@@ -2110,7 +2131,7 @@ inline FreeObject* Block::allocate()
     MALLOC_ASSERT( !bumpPtr, ASSERT_TEXT );
 
     /* the block is considered full. */
-    isFull = 1;
+    isFull = true;
     return NULL;
 }
 
@@ -2139,12 +2160,12 @@ void Bin::moveBlockToFront(Block *block)
     pushTLSBin(block);
 }
 
-void Bin::processLessUsedBlock(MemoryPool *memPool, Block *block)
+void Bin::processEmptyBlock(Block *block, bool poolTheBlock)
 {
     if (block != activeBlk) {
-        /* We are not actively using this block; return it to the general block pool */
+        /* We are not using this block; return it to the pool */
         outofTLSBin(block);
-        memPool->returnEmptyBlock(block, /*poolTheBlock=*/true);
+        block->getMemPool()->returnEmptyBlock(block, poolTheBlock);
     } else {
         /* all objects are free - let's restore the bump pointer */
         block->restoreBumpPtr();
@@ -2199,7 +2220,7 @@ LargeMemoryBlock *LocalLOCImpl<LOW_MARK, HIGH_MARK>::get(size_t size)
     if (size > MAX_TOTAL_SIZE)
         return NULL;
 
-    if (!head || !(localHead = (LargeMemoryBlock*)AtomicFetchStore(&head, 0))) {
+    if (!head || (localHead = (LargeMemoryBlock*)AtomicFetchStore(&head, 0)) == NULL) {
         // do not restore totalSize, numOfBlocks and tail at this point,
         // as they are used only in put(), where they must be restored
         return NULL;
@@ -2355,7 +2376,7 @@ static void *allocateAligned(MemoryPool *memPool, size_t size, size_t alignment)
 }
 
 static void *reallocAligned(MemoryPool *memPool, void *ptr,
-                            size_t size, size_t alignment = 0)
+                            size_t newSize, size_t alignment = 0)
 {
     void *result;
     size_t copySize;
@@ -2363,32 +2384,46 @@ static void *reallocAligned(MemoryPool *memPool, void *ptr,
     if (isLargeObject<ourMem>(ptr)) {
         LargeMemoryBlock* lmb = ((LargeObjectHdr *)ptr - 1)->memoryBlock;
         copySize = lmb->unalignedSize-((uintptr_t)ptr-(uintptr_t)lmb);
-        if (size <= copySize && (0==alignment || isAligned(ptr, alignment))) {
-            lmb->objectSize = size;
-            return ptr;
-        } else {
-            copySize = lmb->objectSize;
+
+        // Apply different strategies if size decreases
+        if (newSize <= copySize && (0 == alignment || isAligned(ptr, alignment))) {
+
+            // For huge objects (that do not fit in backend cache), keep the same space unless
+            // the new size is at least twice smaller
+            bool isMemoryBlockHuge = copySize > memPool->extMemPool.backend.getMaxBinnedSize();
+            size_t threshold = isMemoryBlockHuge ? copySize / 2 : 0;
+            if (newSize > threshold) {
+                lmb->objectSize = newSize;
+                return ptr;
+            }
+            // TODO: For large objects suitable for the backend cache,
+            // split out the excessive part and put it to the backend.
+        }
+        // Reallocate for real
+        copySize = lmb->objectSize;
 #if BACKEND_HAS_MREMAP
-            if (void *r = memPool->extMemPool.remap(ptr, copySize, size,
-                              alignment<largeObjectAlignment?
-                              largeObjectAlignment : alignment))
-                return r;
+        if (void *r = memPool->extMemPool.remap(ptr, copySize, newSize,
+                          alignment < largeObjectAlignment ? largeObjectAlignment : alignment))
+            return r;
 #endif
-            result = alignment ? allocateAligned(memPool, size, alignment) :
-                internalPoolMalloc(memPool, size);
-        }
+        result = alignment ? allocateAligned(memPool, newSize, alignment) :
+            internalPoolMalloc(memPool, newSize);
+
     } else {
         Block* block = (Block *)alignDown(ptr, slabSize);
         copySize = block->findObjectSize(ptr);
-        if (size <= copySize && (0==alignment || isAligned(ptr, alignment))) {
+
+        // TODO: Move object to another bin if size decreases and the current bin is "empty enough".
+        // Currently, in case of size decreasing, old pointer is returned
+        if (newSize <= copySize && (0==alignment || isAligned(ptr, alignment))) {
             return ptr;
         } else {
-            result = alignment ? allocateAligned(memPool, size, alignment) :
-                internalPoolMalloc(memPool, size);
+            result = alignment ? allocateAligned(memPool, newSize, alignment) :
+                internalPoolMalloc(memPool, newSize);
         }
     }
     if (result) {
-        memcpy(result, ptr, copySize<size? copySize: size);
+        memcpy(result, ptr, copySize < newSize ? copySize : newSize);
         internalPoolFree(memPool, ptr, 0);
     }
     return result;
@@ -2438,8 +2473,8 @@ bool isLargeObject(void *object)
     if (!isAligned(object, largeObjectAlignment))
         return false;
     LargeObjectHdr *header = (LargeObjectHdr*)object - 1;
-    BackRefIdx idx = memOrigin==unknownMem? safer_dereference(&header->backRefIdx) :
-        header->backRefIdx;
+    BackRefIdx idx = (memOrigin == unknownMem) ?
+        safer_dereference(&header->backRefIdx) : header->backRefIdx;
 
     return idx.isLargeObject()
         // in valid LargeObjectHdr memoryBlock is not NULL
@@ -2524,11 +2559,8 @@ static void *internalPoolMalloc(MemoryPool* memPool, size_t size)
     /*
      * else privatize publicly freed objects in some block and allocate from it
      */
-    mallocBlock = bin->getPublicFreeListBlock();
+    mallocBlock = bin->getPrivatizedFreeListBlock();
     if (mallocBlock) {
-        if (mallocBlock->emptyEnoughToUse()) {
-            bin->moveBlockToFront(mallocBlock);
-        }
         MALLOC_ASSERT( mallocBlock->freeListNonNull(), ASSERT_TEXT );
         if ( FreeObject *result = mallocBlock->allocateFromFreeList() )
             return result;
@@ -2614,18 +2646,15 @@ static void internalFree(void *object)
 
 static size_t internalMsize(void* ptr)
 {
-    if (ptr) {
-        MALLOC_ASSERT(isRecognized(ptr), "Invalid pointer in scalable_msize detected.");
-        if (isLargeObject<ourMem>(ptr)) {
-            LargeMemoryBlock* lmb = ((LargeObjectHdr*)ptr - 1)->memoryBlock;
-            return lmb->objectSize;
-        } else
-            return ((Block*)alignDown(ptr, slabSize))->findObjectSize(ptr);
+    MALLOC_ASSERT(ptr, "Invalid pointer passed to internalMsize");
+    if (isLargeObject<ourMem>(ptr)) {
+        // TODO: return the maximum memory size, that can be written to this object
+        LargeMemoryBlock* lmb = ((LargeObjectHdr*)ptr - 1)->memoryBlock;
+        return lmb->objectSize;
+    } else {
+        Block *block = (Block*)alignDown(ptr, slabSize);
+        return block->findObjectSize(ptr);
     }
-    errno = EINVAL;
-    // Unlike _msize, return 0 in case of parameter error.
-    // Returning size_t(-1) looks more like the way to troubles.
-    return 0;
 }
 
 } // namespace internal
@@ -2660,8 +2689,10 @@ rml::MemPoolError pool_create_v1(intptr_t pool_id, const MemPoolPolicy *policy,
         return UNSUPPORTED_POLICY;
     }
     if (!isMallocInitialized())
-        if (!doInitialization())
+        if (!doInitialization()) {
+            *pool = NULL;
             return NO_MEMORY;
+        }
     rml::internal::MemoryPool *memPool =
         (rml::internal::MemoryPool*)internalMalloc((sizeof(rml::internal::MemoryPool)));
     if (!memPool) {
@@ -2758,6 +2789,21 @@ rml::MemoryPool *pool_identify(void *object)
     return (rml::MemoryPool*)pool;
 }
 
+size_t pool_msize(rml::MemoryPool *mPool, void* object)
+{
+    if (object) {
+        // No assert for object recognition, cause objects allocated from non-default
+        // memory pool do not participate in range checking and do not have valid backreferences for
+        // small objects. Instead, check that an object belong to the certain memory pool.
+        MALLOC_ASSERT_EX(mPool == pool_identify(object), "Object does not belong to the specified pool");
+        return internalMsize(object);
+    }
+    errno = EINVAL;
+    // Unlike _msize, return 0 in case of parameter error.
+    // Returning size_t(-1) looks more like the way to troubles.
+    return 0;
+}
+
 } // namespace rml
 
 using namespace rml::internal;
@@ -2771,47 +2817,71 @@ static unsigned int threadGoingDownCount = 0;
  * from the malloc blocks and replace them with a NULL thread id.
  *
  * For pthreads, the function is set as a callback in pthread_key_create for TLS bin.
- * For non-NULL keys it will be automatically called at thread exit with the key value
- * as the argument.
+ * It will be automatically called at thread exit with the key value as the argument,
+ * unless that value is NULL.
+ * For Windows, it is called from DllMain( DLL_THREAD_DETACH ).
+ *
+ * However neither of the above is called for the main process thread, so the routine
+ * also needs to be called during the process shutdown.
  *
- * for Windows, it should be called directly e.g. from DllMain
 */
-void mallocThreadShutdownNotification(void* arg)
+// TODO: Consider making this function part of class MemoryPool.
+void doThreadShutdownNotification(TLSData* tls, bool main_thread)
 {
-    // Check whether TLS has been initialized
-    if (!isMallocInitialized()) return;
-
     TRACEF(( "[ScalableMalloc trace] Thread id %d blocks return start %d\n",
              getThreadId(),  threadGoingDownCount++ ));
-#if USE_WINTHREAD
-    suppress_unused_warning(arg);
-    MallocMutex::scoped_lock lock(MemoryPool::memPoolListLock);
-    // The routine is called once per thread, need to walk through all pools on Windows
-    for (MemoryPool *memPool = defaultMemPool; memPool; memPool = memPool->next)
-        if (TLSData *tls = memPool->getTLS(/*create=*/false))
-            memPool->processThreadShutdown(tls);
-#else
-    if (!shutdownSync.threadDtorStart()) return;
-    // The routine is called for each memPool, gets memPool from TLSData.
-    TLSData *tls = (TLSData*)arg;
-    tls->getMemPool()->processThreadShutdown(tls);
-    shutdownSync.threadDtorDone();
+
+#if USE_PTHREAD
+    if (tls) {
+        if (!shutdownSync.threadDtorStart()) return;
+        tls->getMemPool()->onThreadShutdown(tls);
+        shutdownSync.threadDtorDone();
+    } else
 #endif
+    {
+        suppress_unused_warning(tls); // not used on Windows
+        // The default pool is safe to use at this point:
+        //   on Linux, only the main thread can go here before destroying defaultMemPool;
+        //   on Windows, shutdown is synchronized via loader lock and isMallocInitialized().
+        // See also __TBB_mallocProcessShutdownNotification()
+        defaultMemPool->onThreadShutdown(defaultMemPool->getTLS(/*create=*/false));
+        // Take lock to walk through other pools; but waiting might be dangerous at this point
+        // (e.g. on Windows the main thread might deadlock)
+        bool locked;
+        MallocMutex::scoped_lock lock(MemoryPool::memPoolListLock, /*wait=*/!main_thread, &locked);
+        if (locked) { // the list is safe to process
+            for (MemoryPool *memPool = defaultMemPool->next; memPool; memPool = memPool->next)
+                memPool->onThreadShutdown(memPool->getTLS(/*create=*/false));
+        }
+    }
 
     TRACEF(( "[ScalableMalloc trace] Thread id %d blocks return end\n", getThreadId() ));
 }
 
-#if USE_WINTHREAD
+#if USE_PTHREAD
+void mallocThreadShutdownNotification(void* arg)
+{
+    // The routine is called for each pool (as TLS dtor) on each thread, except for the main thread
+    if (!isMallocInitialized()) return;
+    doThreadShutdownNotification((TLSData*)arg, false);
+}
+#else
 extern "C" void __TBB_mallocThreadShutdownNotification()
 {
-    mallocThreadShutdownNotification(NULL);
+    // The routine is called once per thread on Windows
+    if (!isMallocInitialized()) return;
+    doThreadShutdownNotification(NULL, false);
 }
 #endif
 
-extern "C" void __TBB_mallocProcessShutdownNotification()
+extern "C" void __TBB_mallocProcessShutdownNotification(bool windows_process_dying)
 {
     if (!isMallocInitialized()) return;
 
+    // Don't clean allocator internals if the entire process is exiting
+    if (!windows_process_dying) {
+        doThreadShutdownNotification(NULL, /*main_thread=*/true);
+    }
 #if  __TBB_MALLOC_LOCACHE_STAT
     printf("cache hit ratio %f, size hit %f\n",
            1.*cacheHits/mallocCalls, 1.*memHitKB/memAllocKB);
@@ -2857,12 +2927,14 @@ extern "C" void * scalable_malloc(size_t size)
     return ptr;
 }
 
-extern "C" void scalable_free (void *object) {
+extern "C" void scalable_free(void *object)
+{
     internalFree(object);
 }
 
 #if MALLOC_ZONE_OVERLOAD_ENABLED
-extern "C" void __TBB_malloc_free_definite_size(void *object, size_t size) {
+extern "C" void __TBB_malloc_free_definite_size(void *object, size_t size)
+{
     internalPoolFree(defaultMemPool, object, size);
 }
 #endif
@@ -3113,7 +3185,14 @@ extern "C" void scalable_aligned_free(void *ptr)
  */
 extern "C" size_t scalable_msize(void* ptr)
 {
-    return internalMsize(ptr);
+    if (ptr) {
+        MALLOC_ASSERT(isRecognized(ptr), "Invalid pointer in scalable_msize detected.");
+        return internalMsize(ptr);
+    }
+    errno = EINVAL;
+    // Unlike _msize, return 0 in case of parameter error.
+    // Returning size_t(-1) looks more like the way to troubles.
+    return 0;
 }
 
 /*
@@ -3184,6 +3263,9 @@ extern "C" int scalable_allocation_mode(int param, intptr_t value)
             return TBBMALLOC_INVALID_PARAM;
         }
 #endif
+    } else if (param == TBBMALLOC_SET_HUGE_SIZE_THRESHOLD) {
+        defaultMemPool->extMemPool.loc.setHugeSizeThreshold((size_t)value);
+        return TBBMALLOC_OK;
     }
     return TBBMALLOC_INVALID_PARAM;
 }
@@ -3192,16 +3274,18 @@ extern "C" int scalable_allocation_command(int cmd, void *param)
 {
     if (param)
         return TBBMALLOC_INVALID_PARAM;
+
+    bool released = false;
     switch(cmd) {
     case TBBMALLOC_CLEAN_THREAD_BUFFERS:
         if (TLSData *tls = defaultMemPool->getTLS(/*create=*/false))
-            return tls->externalCleanup(&defaultMemPool->extMemPool,
-                                        /*cleanOnlyUnused=*/false)?
-                TBBMALLOC_OK : TBBMALLOC_NO_EFFECT;
-        return TBBMALLOC_NO_EFFECT;
+            released = tls->externalCleanup(/*cleanOnlyUnused*/false, /*cleanBins=*/true);
+        break;
     case TBBMALLOC_CLEAN_ALL_BUFFERS:
-        return defaultMemPool->extMemPool.hardCachesCleanup()?
-            TBBMALLOC_OK : TBBMALLOC_NO_EFFECT;
+        released = defaultMemPool->extMemPool.hardCachesCleanup();
+        break;
+    default:
+        return TBBMALLOC_INVALID_PARAM;
     }
-    return TBBMALLOC_INVALID_PARAM;
+    return released ? TBBMALLOC_OK : TBBMALLOC_NO_EFFECT;
 }
diff --git a/src/tbb/src/tbbmalloc/index.html b/src/tbb/src/tbbmalloc/index.html
index 19eaf992..28fc7e09 100644
--- a/src/tbb/src/tbbmalloc/index.html
+++ b/src/tbb/src/tbbmalloc/index.html
@@ -7,7 +7,7 @@ <H2>Overview</H2>
 
 <HR>
 <p></p>
-Copyright &copy; 2005-2017 Intel Corporation.  All Rights Reserved.
+Copyright &copy; 2005-2020 Intel Corporation.  All Rights Reserved.
 <P></P>
 Intel is a registered trademark or trademark of Intel Corporation
 or its subsidiaries in the United States and other countries.
diff --git a/src/tbb/src/tbbmalloc/large_objects.cpp b/src/tbb/src/tbbmalloc/large_objects.cpp
index 0921b855..c5230b6f 100644
--- a/src/tbb/src/tbbmalloc/large_objects.cpp
+++ b/src/tbb/src/tbbmalloc/large_objects.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,20 +12,54 @@
     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 "tbbmalloc_internal.h"
+#include "tbb/tbb_environment.h"
 
+/******************************* Allocation of large objects *********************************************/
 
+namespace rml {
+namespace internal {
 
-*/
+/* ---------------------------- Large Object cache init section ---------------------------------------- */
 
-#include "tbbmalloc_internal.h"
+void LargeObjectCache::init(ExtMemoryPool *memPool)
+{
+    extMemPool = memPool;
+    // scalable_allocation_mode can be called before allocator initialization, respect this manual request
+    if (hugeSizeThreshold == 0) {
+        // Huge size threshold initialization if environment variable was set
+        long requestedThreshold = tbb::internal::GetIntegralEnvironmentVariable("TBB_MALLOC_SET_HUGE_SIZE_THRESHOLD");
+        // Read valid env or initialize by default with max possible values
+        if (requestedThreshold != -1) {
+            setHugeSizeThreshold(requestedThreshold);
+        } else {
+            setHugeSizeThreshold(maxHugeSize);
+        }
+    }
+}
 
-/********* Allocation of large objects ************/
+/* ----------------------------- Huge size threshold settings ----------------------------------------- */
 
+void LargeObjectCache::setHugeSizeThreshold(size_t value)
+{
+    // Valid in the huge cache range: [MaxLargeSize, MaxHugeSize].
+    if (value <= maxHugeSize) {
+        hugeSizeThreshold = value >= maxLargeSize ? alignToBin(value) : maxLargeSize;
 
-namespace rml {
-namespace internal {
+        // Calculate local indexes for the global threshold size (for fast search inside a regular cleanup)
+        largeCache.hugeSizeThresholdIdx = LargeCacheType::numBins;
+        hugeCache.hugeSizeThresholdIdx = HugeCacheType::sizeToIdx(hugeSizeThreshold);
+    }
+}
 
+bool LargeObjectCache::sizeInCacheRange(size_t size)
+{
+    return size <= maxHugeSize && (size <= defaultMaxHugeSize || size >= hugeSizeThreshold);
+}
+
+/* ----------------------------------------------------------------------------------------------------- */
 
 /* The functor called by the aggregator for the operation list */
 template<typename Props>
@@ -101,23 +135,7 @@ class CacheBinFunctor {
     uintptr_t getCurrTime() const { return currTime; }
 };
 
-// ---------------- Cache Bin Aggregator Operation Helpers ---------------- //
-// The list of possible operations.
-enum CacheBinOperationType {
-    CBOP_INVALID = 0,
-    CBOP_GET,
-    CBOP_PUT_LIST,
-    CBOP_CLEAN_TO_THRESHOLD,
-    CBOP_CLEAN_ALL,
-    CBOP_UPDATE_USED_SIZE
-};
-
-// The operation status list. CBST_NOWAIT can be specified for non-blocking operations.
-enum CacheBinOperationStatus {
-    CBST_WAIT = 0,
-    CBST_NOWAIT,
-    CBST_DONE
-};
+/* ---------------- Cache Bin Aggregator Operation Helpers ---------------- */
 
 // The list of structures which describe the operation data
 struct OpGet {
@@ -187,7 +205,8 @@ template <typename OpTypeData>
 OpTypeData& opCast(CacheBinOperation &op) {
     return *reinterpret_cast<OpTypeData*>(&op.data);
 }
-// ------------------------------------------------------------------------ //
+
+/* ------------------------------------------------------------------------ */
 
 #if __TBB_MALLOC_LOCACHE_STAT
 intptr_t mallocCalls, cacheHits;
@@ -292,7 +311,7 @@ template<typename Props> void CacheBinFunctor<Props>::
                     num += 1;
 
                     STAT_increment(getThreadId(), ThreadCommonCounters, cacheLargeObj);
-                } while (( curr = curr->next ));
+                } while ((curr = curr->next) != NULL);
 
                 LargeMemoryBlock *tail = prev;
                 addToPutList(head, tail, num);
@@ -386,7 +405,7 @@ template<typename Props> void CacheBinFunctor<Props>::operator()(CacheBinOperati
 #if __TBB_MALLOC_WHITEBOX_TEST
             tbbmalloc_whitebox::locPutProcessed+=prep.putListNum;
 #endif
-            toRelease = bin->putList(prep.head, prep.tail, bitMask, idx, prep.putListNum);
+            toRelease = bin->putList(prep.head, prep.tail, bitMask, idx, prep.putListNum, extMemPool->loc.hugeSizeThreshold);
         }
         needCleanup = extMemPool->loc.isCleanupNeededOnRange(timeRange, startTime);
         currTime = endTime - 1;
@@ -401,7 +420,7 @@ template<typename Props> void CacheBinFunctor<Props>::operator()(CacheBinOperati
         CacheBinOperation *opNext = opClean->next;
         prep.commitOperation( opClean );
 
-        while (( opClean = opNext )) {
+        while ((opClean = opNext) != NULL) {
             opNext = opClean->next;
             prep.commitOperation(opClean);
         }
@@ -418,11 +437,13 @@ template<typename Props> void LargeObjectCacheImpl<Props>::
     CacheBinFunctor<Props> func( this, extMemPool, bitMask, idx );
     aggregator.execute( op, func, longLifeTime );
 
-    if (  LargeMemoryBlock *toRelease = func.getToRelease() )
+    if ( LargeMemoryBlock *toRelease = func.getToRelease()) {
         extMemPool->backend.returnLargeObject(toRelease);
+    }
 
-    if ( func.isCleanupNeeded() )
+    if ( func.isCleanupNeeded() ) {
         extMemPool->loc.doCleanup( func.getCurrTime(), /*doThreshDecr=*/false);
+    }
 }
 
 template<typename Props> LargeMemoryBlock *LargeObjectCacheImpl<Props>::
@@ -492,22 +513,24 @@ template<typename Props> bool LargeObjectCacheImpl<Props>::
 }
 
 template<typename Props> void LargeObjectCacheImpl<Props>::
-    CacheBin::updateUsedSize(ExtMemoryPool *extMemPool, size_t size, BinBitMask *bitMask, int idx) {
+    CacheBin::updateUsedSize(ExtMemoryPool *extMemPool, size_t size, BinBitMask *bitMask, int idx)
+{
     OpUpdateUsedSize data = {size};
     CacheBinOperation op(data);
     ExecuteOperation( &op, extMemPool, bitMask, idx );
 }
-/* ----------------------------------------------------------------------------------------------------- */
+
 /* ------------------------------ Unsafe methods used with the aggregator ------------------------------ */
+
 template<typename Props> LargeMemoryBlock *LargeObjectCacheImpl<Props>::
-    CacheBin::putList(LargeMemoryBlock *head, LargeMemoryBlock *tail, BinBitMask *bitMask, int idx, int num)
+    CacheBin::putList(LargeMemoryBlock *head, LargeMemoryBlock *tail, BinBitMask *bitMask, int idx, int num, size_t hugeSizeThreshold)
 {
     size_t size = head->unalignedSize;
     usedSize -= num*size;
     MALLOC_ASSERT( !last || (last->age != 0 && last->age != -1U), ASSERT_TEXT );
     MALLOC_ASSERT( (tail==head && num==1) || (tail!=head && num>1), ASSERT_TEXT );
     LargeMemoryBlock *toRelease = NULL;
-    if (!lastCleanedAge) {
+    if (size < hugeSizeThreshold && !lastCleanedAge) {
         // 1st object of such size was released.
         // Not cache it, and remember when this occurs
         // to take into account during cache miss.
@@ -560,7 +583,6 @@ template<typename Props> LargeMemoryBlock *LargeObjectCacheImpl<Props>::
     return result;
 }
 
-// forget the history for the bin if it was unused for long time
 template<typename Props> void LargeObjectCacheImpl<Props>::
     CacheBin::forgetOutdatedState(uintptr_t currTime)
 {
@@ -574,9 +596,9 @@ template<typename Props> void LargeObjectCacheImpl<Props>::
     bool doCleanup = false;
 
     if (ageThreshold)
-        doCleanup = sinceLastGet > Props::LongWaitFactor*ageThreshold;
+        doCleanup = sinceLastGet > Props::LongWaitFactor * ageThreshold;
     else if (lastCleanedAge)
-        doCleanup = sinceLastGet > Props::LongWaitFactor*(lastCleanedAge - lastGet);
+        doCleanup = sinceLastGet > Props::LongWaitFactor * (lastCleanedAge - lastGet);
 
     if (doCleanup) {
         lastCleanedAge = 0;
@@ -639,6 +661,7 @@ template<typename Props> LargeMemoryBlock *LargeObjectCacheImpl<Props>::
 
     return toRelease;
 }
+
 /* ----------------------------------------------------------------------------------------------------- */
 
 template<typename Props> size_t LargeObjectCacheImpl<Props>::
@@ -656,34 +679,40 @@ template<typename Props> size_t LargeObjectCacheImpl<Props>::
     return cachedSize;
 }
 
-// release from cache blocks that are older than ageThreshold
+// Release objects from cache blocks that are older than ageThreshold
 template<typename Props>
 bool LargeObjectCacheImpl<Props>::regularCleanup(ExtMemoryPool *extMemPool, uintptr_t currTime, bool doThreshDecr)
 {
     bool released = false;
     BinsSummary binsSummary;
 
-    for (int i = bitMask.getMaxTrue(numBins-1); i >= 0;
-         i = bitMask.getMaxTrue(i-1)) {
+    // Threshold settings is below this cache or starts from zero index
+    if (hugeSizeThresholdIdx == 0) return false;
+
+    // Starting searching for bin that is less than huge size threshold (can be cleaned-up)
+    int startSearchIdx = hugeSizeThresholdIdx - 1;
+
+    for (int i = bitMask.getMaxTrue(startSearchIdx); i >= 0; i = bitMask.getMaxTrue(i-1)) {
         bin[i].updateBinsSummary(&binsSummary);
-        if (!doThreshDecr && tooLargeLOC>2 && binsSummary.isLOCTooLarge()) {
+        if (!doThreshDecr && tooLargeLOC > 2 && binsSummary.isLOCTooLarge()) {
             // if LOC is too large for quite long time, decrease the threshold
             // based on bin hit statistics.
             // For this, redo cleanup from the beginning.
             // Note: on this iteration total usedSz can be not too large
             // in comparison to total cachedSz, as we calculated it only
             // partially. We are ok with it.
-            i = bitMask.getMaxTrue(numBins-1)+1;
+            i = bitMask.getMaxTrue(startSearchIdx)+1;
             doThreshDecr = true;
             binsSummary.reset();
             continue;
         }
         if (doThreshDecr)
             bin[i].decreaseThreshold();
-        if (bin[i].cleanToThreshold(extMemPool, &bitMask, currTime, i))
+
+        if (bin[i].cleanToThreshold(extMemPool, &bitMask, currTime, i)) {
             released = true;
+        }
     }
-
     // We want to find if LOC was too large for some time continuously,
     // so OK with races between incrementing and zeroing, but incrementing
     // must be atomic.
@@ -698,11 +727,20 @@ template<typename Props>
 bool LargeObjectCacheImpl<Props>::cleanAll(ExtMemoryPool *extMemPool)
 {
     bool released = false;
-    for (int i = numBins-1; i >= 0; i--)
+    for (int i = numBins-1; i >= 0; i--) {
         released |= bin[i].releaseAllToBackend(extMemPool, &bitMask, i);
+    }
     return released;
 }
 
+template<typename Props>
+void LargeObjectCacheImpl<Props>::reset() {
+    tooLargeLOC = 0;
+    for (int i = numBins-1; i >= 0; i--)
+        bin[i].init();
+    bitMask.reset();
+}
+
 #if __TBB_MALLOC_WHITEBOX_TEST
 template<typename Props>
 size_t LargeObjectCacheImpl<Props>::getLOCSize() const
@@ -764,11 +802,16 @@ bool LargeObjectCache::cleanAll()
     return largeCache.cleanAll(extMemPool) | hugeCache.cleanAll(extMemPool);
 }
 
+void LargeObjectCache::reset()
+{
+    largeCache.reset();
+    hugeCache.reset();
+}
+
 template<typename Props>
 LargeMemoryBlock *LargeObjectCacheImpl<Props>::get(ExtMemoryPool *extMemoryPool, size_t size)
 {
-    MALLOC_ASSERT( size%Props::CacheStep==0, ASSERT_TEXT );
-    int idx = sizeToIdx(size);
+    int idx = Props::sizeToIdx(size);
 
     LargeMemoryBlock *lmb = bin[idx].get(extMemoryPool, size, &bitMask, idx);
 
@@ -782,7 +825,7 @@ LargeMemoryBlock *LargeObjectCacheImpl<Props>::get(ExtMemoryPool *extMemoryPool,
 template<typename Props>
 void LargeObjectCacheImpl<Props>::updateCacheState(ExtMemoryPool *extMemPool, DecreaseOrIncrease op, size_t size)
 {
-    int idx = sizeToIdx(size);
+    int idx = Props::sizeToIdx(size);
     MALLOC_ASSERT(idx<numBins, ASSERT_TEXT);
     bin[idx].updateUsedSize(extMemPool, op==decrease? -size : size, &bitMask, idx);
 }
@@ -808,7 +851,7 @@ void LargeObjectCache::reportStat(FILE *f)
 template<typename Props>
 void LargeObjectCacheImpl<Props>::putList(ExtMemoryPool *extMemPool, LargeMemoryBlock *toCache)
 {
-    int toBinIdx = sizeToIdx(toCache->unalignedSize);
+    int toBinIdx = Props::sizeToIdx(toCache->unalignedSize);
 
     MALLOC_ITT_SYNC_RELEASING(bin+toBinIdx);
     bin[toBinIdx].putList(extMemPool, toCache, &bitMask, toBinIdx);
@@ -822,19 +865,33 @@ void LargeObjectCache::updateCacheState(DecreaseOrIncrease op, size_t size)
         hugeCache.updateCacheState(extMemPool, op, size);
 }
 
+uintptr_t LargeObjectCache::getCurrTime()
+{
+    return (uintptr_t)AtomicIncrement((intptr_t&)cacheCurrTime);
+}
+
+uintptr_t LargeObjectCache::getCurrTimeRange(uintptr_t range)
+{
+    return (uintptr_t)AtomicAdd((intptr_t&)cacheCurrTime, range) + 1;
+}
+
 void LargeObjectCache::registerRealloc(size_t oldSize, size_t newSize)
 {
     updateCacheState(decrease, oldSize);
-    updateCacheState(increase, newSize);
+    updateCacheState(increase, alignToBin(newSize));
+}
+
+size_t LargeObjectCache::alignToBin(size_t size) {
+    return size < maxLargeSize ? LargeCacheType::alignToBin(size) : HugeCacheType::alignToBin(size);
 }
 
-// return artificial bin index, it's used only during sorting and never saved
+// Used for internal purpose
 int LargeObjectCache::sizeToIdx(size_t size)
 {
-    MALLOC_ASSERT(size < maxHugeSize, ASSERT_TEXT);
-    return size < maxLargeSize?
+    MALLOC_ASSERT(size <= maxHugeSize, ASSERT_TEXT);
+    return size < maxLargeSize ?
         LargeCacheType::sizeToIdx(size) :
-        LargeCacheType::getNumBins()+HugeCacheType::sizeToIdx(size);
+        LargeCacheType::numBins + HugeCacheType::sizeToIdx(size);
 }
 
 void LargeObjectCache::putList(LargeMemoryBlock *list)
@@ -844,7 +901,7 @@ void LargeObjectCache::putList(LargeMemoryBlock *list)
     for (LargeMemoryBlock *curr = list; curr; curr = toProcess) {
         LargeMemoryBlock *tail = curr;
         toProcess = curr->next;
-        if (curr->unalignedSize >= maxHugeSize) {
+        if (!sizeInCacheRange(curr->unalignedSize)) {
             extMemPool->backend.returnLargeObject(curr);
             continue;
         }
@@ -877,23 +934,23 @@ void LargeObjectCache::putList(LargeMemoryBlock *list)
 
 void LargeObjectCache::put(LargeMemoryBlock *largeBlock)
 {
-    if (largeBlock->unalignedSize < maxHugeSize) {
+    size_t blockSize = largeBlock->unalignedSize;
+    if (sizeInCacheRange(blockSize)) {
         largeBlock->next = NULL;
-        if (largeBlock->unalignedSize<maxLargeSize)
+        if (blockSize < maxLargeSize)
             largeCache.putList(extMemPool, largeBlock);
         else
             hugeCache.putList(extMemPool, largeBlock);
-    } else
+    } else {
         extMemPool->backend.returnLargeObject(largeBlock);
+    }
 }
 
 LargeMemoryBlock *LargeObjectCache::get(size_t size)
 {
-    MALLOC_ASSERT( size%largeBlockCacheStep==0, ASSERT_TEXT );
-    MALLOC_ASSERT( size>=minLargeSize, ASSERT_TEXT );
-
-    if ( size < maxHugeSize) {
-        return size < maxLargeSize?
+    MALLOC_ASSERT( size >= minLargeSize, ASSERT_TEXT );
+    if (sizeInCacheRange(size)) {
+        return size < maxLargeSize ?
             largeCache.get(extMemPool, size) : hugeCache.get(extMemPool, size);
     }
     return NULL;
@@ -963,7 +1020,7 @@ void *ExtMemoryPool::remap(void *ptr, size_t oldSize, size_t newSize, size_t ali
     void *o = backend.remap(ptr, oldSize, newSize, alignment);
     if (o) {
         LargeMemoryBlock *lmb = ((LargeObjectHdr*)o - 1)->memoryBlock;
-        loc.registerRealloc(lmb->unalignedSize, oldUnalignedSize);
+        loc.registerRealloc(oldUnalignedSize, lmb->unalignedSize);
     }
     return o;
 }
diff --git a/src/tbb/src/tbbmalloc/large_objects.h b/src/tbb/src/tbbmalloc/large_objects.h
new file mode 100644
index 00000000..de7c2058
--- /dev/null
+++ b/src/tbb/src/tbbmalloc/large_objects.h
@@ -0,0 +1,368 @@
+/*
+    Copyright (c) 2005-2020 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.
+*/
+
+#ifndef __TBB_tbbmalloc_internal_H
+    #error tbbmalloc_internal.h must be included at this point
+#endif
+
+#ifndef __TBB_large_objects_H
+#define __TBB_large_objects_H
+
+//! The list of possible Cache Bin Aggregator operations.
+/*  Declared here to avoid Solaris Studio* 12.2 "multiple definitions" error */
+enum CacheBinOperationType {
+    CBOP_INVALID = 0,
+    CBOP_GET,
+    CBOP_PUT_LIST,
+    CBOP_CLEAN_TO_THRESHOLD,
+    CBOP_CLEAN_ALL,
+    CBOP_UPDATE_USED_SIZE
+};
+
+// The Cache Bin Aggregator operation status list.
+// CBST_NOWAIT can be specified for non-blocking operations.
+enum CacheBinOperationStatus {
+    CBST_WAIT = 0,
+    CBST_NOWAIT,
+    CBST_DONE
+};
+
+/*
+ * Bins that grow with arithmetic step
+ */
+template<size_t MIN_SIZE, size_t MAX_SIZE>
+struct LargeBinStructureProps {
+public:
+    static const size_t   MinSize = MIN_SIZE, MaxSize = MAX_SIZE;
+    static const size_t   CacheStep = 8 * 1024;
+    static const unsigned NumBins = (MaxSize - MinSize) / CacheStep;
+
+    static size_t alignToBin(size_t size) {
+        return alignUp(size, CacheStep);
+    }
+
+    static int sizeToIdx(size_t size) {
+        MALLOC_ASSERT(MinSize <= size && size < MaxSize, ASSERT_TEXT);
+        MALLOC_ASSERT(size % CacheStep == 0, ASSERT_TEXT);
+        return (size - MinSize) / CacheStep;
+    }
+};
+
+/*
+ * Bins that grow with special geometric progression.
+ */
+template<size_t MIN_SIZE, size_t MAX_SIZE>
+struct HugeBinStructureProps {
+
+private:
+    // Sizes grow with the following formula: Size = MinSize * (2 ^ (Index / StepFactor))
+    // There are StepFactor bins (8 be default) between each power of 2 bin
+    static const int MaxSizeExp    = Log2<MAX_SIZE>::value;
+    static const int MinSizeExp    = Log2<MIN_SIZE>::value;
+    static const int StepFactor    = 8;
+    static const int StepFactorExp = Log2<StepFactor>::value;
+
+public:
+    static const size_t   MinSize = MIN_SIZE, MaxSize = MAX_SIZE;
+    static const unsigned NumBins = (MaxSizeExp - MinSizeExp) * StepFactor;
+
+    static size_t alignToBin(size_t size) {
+        size_t minorStepExp = BitScanRev(size) - StepFactorExp;
+        return alignUp(size, 1ULL << minorStepExp);
+    }
+
+    // Sizes between the power of 2 values are aproximated to StepFactor.
+    static int sizeToIdx(size_t size) {
+        MALLOC_ASSERT(MinSize <= size && size <= MaxSize, ASSERT_TEXT);
+        int sizeExp = (int)BitScanRev(size); // same as __TBB_Log2
+        size_t majorStepSize = 1ULL << sizeExp;
+        int minorStepExp = sizeExp - StepFactorExp;
+        int minorIdx = (size - majorStepSize) >> minorStepExp;
+        MALLOC_ASSERT(size == majorStepSize + ((size_t)minorIdx << minorStepExp),
+            "Size is not aligned on the bin");
+        return StepFactor * (sizeExp - MinSizeExp) + minorIdx;
+    }
+};
+
+/*
+ * Cache properties accessor
+ *
+ * TooLargeFactor -- when cache size treated "too large" in comparison to user data size
+ * OnMissFactor -- If cache miss occurred and cache was cleaned,
+ *                 set ageThreshold to OnMissFactor * the difference
+ *                 between current time and last time cache was cleaned.
+ * LongWaitFactor -- to detect rarely-used bins and forget about their usage history
+ */
+template<typename StructureProps, int TOO_LARGE, int ON_MISS, int LONG_WAIT>
+struct LargeObjectCacheProps : public StructureProps {
+    static const int TooLargeFactor = TOO_LARGE, OnMissFactor = ON_MISS, LongWaitFactor = LONG_WAIT;
+};
+
+template<typename Props>
+class LargeObjectCacheImpl {
+private:
+
+    // Current sizes of used and cached objects. It's calculated while we are
+    // traversing bins, and used for isLOCTooLarge() check at the same time.
+    class BinsSummary {
+        size_t usedSz;
+        size_t cachedSz;
+    public:
+        BinsSummary() : usedSz(0), cachedSz(0) {}
+        // "too large" criteria
+        bool isLOCTooLarge() const { return cachedSz > Props::TooLargeFactor * usedSz; }
+        void update(size_t usedSize, size_t cachedSize) {
+            usedSz += usedSize;
+            cachedSz += cachedSize;
+        }
+        void reset() { usedSz = cachedSz = 0; }
+    };
+
+public:
+    // The number of bins to cache large/huge objects.
+    static const uint32_t numBins = Props::NumBins;
+
+    typedef BitMaskMax<numBins> BinBitMask;
+
+    // 2-linked list of same-size cached blocks ordered by age (oldest on top)
+    // TODO: are we really want the list to be 2-linked? This allows us
+    // reduce memory consumption and do less operations under lock.
+    // TODO: try to switch to 32-bit logical time to save space in CacheBin
+    // and move bins to different cache lines.
+    class CacheBin {
+    private:
+        LargeMemoryBlock *first,
+                         *last;
+        /* age of an oldest block in the list; equal to last->age, if last defined,
+            used for quick checking it without acquiring the lock. */
+        uintptr_t         oldest;
+        /* currAge when something was excluded out of list because of the age,
+         not because of cache hit */
+        uintptr_t         lastCleanedAge;
+        /* Current threshold value for the blocks of a particular size.
+         Set on cache miss. */
+        intptr_t          ageThreshold;
+
+        /* total size of all objects corresponding to the bin and allocated by user */
+        size_t            usedSize,
+        /* total size of all objects cached in the bin */
+                          cachedSize;
+        /* mean time of presence of block in the bin before successful reuse */
+        intptr_t          meanHitRange;
+        /* time of last get called for the bin */
+        uintptr_t         lastGet;
+
+        typename MallocAggregator<CacheBinOperation>::type aggregator;
+
+        void ExecuteOperation(CacheBinOperation *op, ExtMemoryPool *extMemPool, BinBitMask *bitMask, int idx, bool longLifeTime = true);
+
+        /* should be placed in zero-initialized memory, ctor not needed. */
+        CacheBin();
+
+    public:
+        void init() {
+            memset(this, 0, sizeof(CacheBin));
+        }
+
+        /* ---------- Cache accessors ---------- */
+        void putList(ExtMemoryPool *extMemPool, LargeMemoryBlock *head, BinBitMask *bitMask, int idx);
+        LargeMemoryBlock *get(ExtMemoryPool *extMemPool, size_t size, BinBitMask *bitMask, int idx);
+
+        /* ---------- Cleanup functions -------- */
+        bool cleanToThreshold(ExtMemoryPool *extMemPool, BinBitMask *bitMask, uintptr_t currTime, int idx);
+        bool releaseAllToBackend(ExtMemoryPool *extMemPool, BinBitMask *bitMask, int idx);
+        /* ------------------------------------- */
+
+        void updateUsedSize(ExtMemoryPool *extMemPool, size_t size, BinBitMask *bitMask, int idx);
+        void decreaseThreshold() {
+            if (ageThreshold)
+                ageThreshold = (ageThreshold + meanHitRange) / 2;
+        }
+        void updateBinsSummary(BinsSummary *binsSummary) const {
+            binsSummary->update(usedSize, cachedSize);
+        }
+        size_t getSize() const { return cachedSize; }
+        size_t getUsedSize() const { return usedSize; }
+        size_t reportStat(int num, FILE *f);
+
+        /* --------- Unsafe methods used with the aggregator ------- */
+        void forgetOutdatedState(uintptr_t currTime);
+        LargeMemoryBlock *putList(LargeMemoryBlock *head, LargeMemoryBlock *tail, BinBitMask *bitMask,
+                int idx, int num, size_t hugeObjectThreshold);
+        LargeMemoryBlock *get();
+        LargeMemoryBlock *cleanToThreshold(uintptr_t currTime, BinBitMask *bitMask, int idx);
+        LargeMemoryBlock *cleanAll(BinBitMask *bitMask, int idx);
+        void updateUsedSize(size_t size, BinBitMask *bitMask, int idx) {
+            if (!usedSize) bitMask->set(idx, true);
+            usedSize += size;
+            if (!usedSize && !first) bitMask->set(idx, false);
+        }
+        void updateMeanHitRange( intptr_t hitRange ) {
+            hitRange = hitRange >= 0 ? hitRange : 0;
+            meanHitRange = meanHitRange ? (meanHitRange + hitRange) / 2 : hitRange;
+        }
+        void updateAgeThreshold( uintptr_t currTime ) {
+            if (lastCleanedAge)
+                ageThreshold = Props::OnMissFactor*(currTime - lastCleanedAge);
+        }
+        void updateCachedSize(size_t size) {
+            cachedSize += size;
+        }
+        void setLastGet( uintptr_t newLastGet ) {
+            lastGet = newLastGet;
+        }
+        /* -------------------------------------------------------- */
+    };
+
+    // Huge bins index for fast regular cleanup searching in case of
+    // the "huge size threshold" setting defined
+    intptr_t     hugeSizeThresholdIdx;
+
+private:
+    // How many times LOC was "too large"
+    intptr_t     tooLargeLOC;
+    // for fast finding of used bins and bins with non-zero usedSize;
+    // indexed from the end, as we need largest 1st
+    BinBitMask   bitMask;
+    // bins with lists of recently freed large blocks cached for re-use
+    CacheBin bin[numBins];
+
+public:
+    /* ------------ CacheBin structure dependent stuff ------------ */
+    static size_t alignToBin(size_t size) {
+        return Props::alignToBin(size);
+    }
+    static int sizeToIdx(size_t size) {
+        return Props::sizeToIdx(size);
+    }
+
+    /* --------- Main cache functions (put, get object) ------------ */
+    void putList(ExtMemoryPool *extMemPool, LargeMemoryBlock *largeBlock);
+    LargeMemoryBlock *get(ExtMemoryPool *extMemPool, size_t size);
+
+    /* ------------------------ Cleanup ---------------------------- */
+    bool regularCleanup(ExtMemoryPool *extMemPool, uintptr_t currAge, bool doThreshDecr);
+    bool cleanAll(ExtMemoryPool *extMemPool);
+
+    /* -------------------------- Other ---------------------------- */
+    void updateCacheState(ExtMemoryPool *extMemPool, DecreaseOrIncrease op, size_t size);
+
+    void reset();
+    void reportStat(FILE *f);
+#if __TBB_MALLOC_WHITEBOX_TEST
+    size_t getLOCSize() const;
+    size_t getUsedSize() const;
+#endif
+};
+
+class LargeObjectCache {
+private:
+    // Large bins [minLargeSize, maxLargeSize)
+    // Huge bins [maxLargeSize, maxHugeSize)
+    static const size_t minLargeSize = 8 * 1024,
+                        maxLargeSize = 8 * 1024 * 1024,
+                        // Cache memory up to 1TB (or 2GB for 32-bit arch), but sieve objects from the special threshold
+                        maxHugeSize = tbb::internal::select_size_t_constant<2147483648U, 1099511627776ULL>::value;
+
+public:
+    // Upper bound threshold for caching size. After that size all objects sieve through cache
+    // By default - 64MB, previous value was 129MB (needed by some Intel(R) Math Kernel Library (Intel(R) MKL) benchmarks)
+    static const size_t defaultMaxHugeSize = 64UL * 1024UL * 1024UL;
+    // After that size large object interpreted as huge and does not participate in regular cleanup.
+    // Can be changed during the program execution.
+    size_t hugeSizeThreshold;
+
+private:
+    // Large objects cache properties
+    typedef LargeBinStructureProps<minLargeSize, maxLargeSize> LargeBSProps;
+    typedef LargeObjectCacheProps<LargeBSProps, 2, 2, 16> LargeCacheTypeProps;
+
+    // Huge objects cache properties
+    typedef HugeBinStructureProps<maxLargeSize, maxHugeSize> HugeBSProps;
+    typedef LargeObjectCacheProps<HugeBSProps, 1, 1, 4> HugeCacheTypeProps;
+
+    // Cache implementation type with properties
+    typedef LargeObjectCacheImpl< LargeCacheTypeProps > LargeCacheType;
+    typedef LargeObjectCacheImpl< HugeCacheTypeProps > HugeCacheType;
+
+    // Beginning of largeCache is more actively used and smaller than hugeCache,
+    // so put hugeCache first to prevent false sharing
+    // with LargeObjectCache's predecessor
+    HugeCacheType hugeCache;
+    LargeCacheType largeCache;
+
+    /* logical time, incremented on each put/get operation
+       To prevent starvation between pools, keep separately for each pool.
+       Overflow is OK, as we only want difference between
+       its current value and some recent.
+
+       Both malloc and free should increment logical time, as in
+       a different case multiple cached blocks would have same age,
+       and accuracy of predictors suffers.
+    */
+    uintptr_t cacheCurrTime;
+
+    // Memory pool that owns this LargeObjectCache.
+    // strict 1:1 relation, never changed
+    ExtMemoryPool *extMemPool;
+
+    // Returns artificial bin index,
+    // it's used only during sorting and never saved
+    static int sizeToIdx(size_t size);
+
+    // Our friends
+    friend class Backend;
+
+public:
+    void init(ExtMemoryPool *memPool);
+
+    // Item accessors
+    void put(LargeMemoryBlock *largeBlock);
+    void putList(LargeMemoryBlock *head);
+    LargeMemoryBlock *get(size_t size);
+
+    void updateCacheState(DecreaseOrIncrease op, size_t size);
+    bool isCleanupNeededOnRange(uintptr_t range, uintptr_t currTime);
+
+    // Cleanup operations
+    bool doCleanup(uintptr_t currTime, bool doThreshDecr);
+    bool decreasingCleanup();
+    bool regularCleanup();
+    bool cleanAll();
+    void reset();
+
+    void reportStat(FILE *f);
+#if __TBB_MALLOC_WHITEBOX_TEST
+    size_t getLOCSize() const;
+    size_t getUsedSize() const;
+#endif
+
+    // Cache deals with exact-fit sizes, so need to align each size
+    // to the specific bin when put object to cache
+    static size_t alignToBin(size_t size);
+
+    void setHugeSizeThreshold(size_t value);
+
+    // Check if we should cache or sieve this size
+    bool sizeInCacheRange(size_t size);
+
+    uintptr_t getCurrTime();
+    uintptr_t getCurrTimeRange(uintptr_t range);
+    void registerRealloc(size_t oldSize, size_t newSize);
+};
+
+#endif // __TBB_large_objects_H
+
diff --git a/src/tbb/src/tbbmalloc/lin32-proxy-export.def b/src/tbb/src/tbbmalloc/lin32-proxy-export.def
index b3e2849b..329664a5 100644
--- a/src/tbb/src/tbbmalloc/lin32-proxy-export.def
+++ b/src/tbb/src/tbbmalloc/lin32-proxy-export.def
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 {
diff --git a/src/tbb/src/tbbmalloc/lin32-tbbmalloc-export.def b/src/tbb/src/tbbmalloc/lin32-tbbmalloc-export.def
index 33eff0f1..3e078d14 100644
--- a/src/tbb/src/tbbmalloc/lin32-tbbmalloc-export.def
+++ b/src/tbb/src/tbbmalloc/lin32-tbbmalloc-export.def
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 {
@@ -49,6 +45,7 @@ _ZN3rml12pool_reallocEPNS_10MemoryPoolEPvj;
 _ZN3rml20pool_aligned_reallocEPNS_10MemoryPoolEPvjj;
 _ZN3rml19pool_aligned_mallocEPNS_10MemoryPoolEjj;
 _ZN3rml13pool_identifyEPv;
+_ZN3rml10pool_msizeEPNS_10MemoryPoolEPv;
 
 local:
 
diff --git a/src/tbb/src/tbbmalloc/lin64-proxy-export.def b/src/tbb/src/tbbmalloc/lin64-proxy-export.def
index 12d8d43d..913aa78d 100644
--- a/src/tbb/src/tbbmalloc/lin64-proxy-export.def
+++ b/src/tbb/src/tbbmalloc/lin64-proxy-export.def
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 {
diff --git a/src/tbb/src/tbbmalloc/lin64-tbbmalloc-export.def b/src/tbb/src/tbbmalloc/lin64-tbbmalloc-export.def
index a57c933b..663a35c0 100644
--- a/src/tbb/src/tbbmalloc/lin64-tbbmalloc-export.def
+++ b/src/tbb/src/tbbmalloc/lin64-tbbmalloc-export.def
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 {
@@ -49,6 +45,7 @@ _ZN3rml12pool_reallocEPNS_10MemoryPoolEPvm;
 _ZN3rml20pool_aligned_reallocEPNS_10MemoryPoolEPvmm;
 _ZN3rml19pool_aligned_mallocEPNS_10MemoryPoolEmm;
 _ZN3rml13pool_identifyEPv;
+_ZN3rml10pool_msizeEPNS_10MemoryPoolEPv;
 
 local:
 
diff --git a/src/tbb/src/tbbmalloc/lin64ipf-proxy-export.def b/src/tbb/src/tbbmalloc/lin64ipf-proxy-export.def
index 12d8d43d..913aa78d 100644
--- a/src/tbb/src/tbbmalloc/lin64ipf-proxy-export.def
+++ b/src/tbb/src/tbbmalloc/lin64ipf-proxy-export.def
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 {
diff --git a/src/tbb/src/tbbmalloc/lin64ipf-tbbmalloc-export.def b/src/tbb/src/tbbmalloc/lin64ipf-tbbmalloc-export.def
index a57c933b..e8a56171 100644
--- a/src/tbb/src/tbbmalloc/lin64ipf-tbbmalloc-export.def
+++ b/src/tbb/src/tbbmalloc/lin64ipf-tbbmalloc-export.def
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 {
@@ -37,6 +33,9 @@ __TBB_malloc_safer_aligned_realloc;
 __TBB_malloc_safer_free;
 __TBB_malloc_safer_msize;
 __TBB_malloc_safer_realloc;
+/* For tbbmalloc proxy to use MallocMutex with new_handler feature */
+__TBB_machine_lockbyte;
+__TBB_machine_trylockbyte;
 
 /* memory pool stuff */
 _ZN3rml11pool_createElPKNS_13MemPoolPolicyE;
@@ -49,6 +48,7 @@ _ZN3rml12pool_reallocEPNS_10MemoryPoolEPvm;
 _ZN3rml20pool_aligned_reallocEPNS_10MemoryPoolEPvmm;
 _ZN3rml19pool_aligned_mallocEPNS_10MemoryPoolEmm;
 _ZN3rml13pool_identifyEPv;
+_ZN3rml10pool_msizeEPNS_10MemoryPoolEPv;
 
 local:
 
diff --git a/src/tbb/src/tbbmalloc/mac32-tbbmalloc-export.def b/src/tbb/src/tbbmalloc/mac32-tbbmalloc-export.def
index 71cc1079..82759dff 100644
--- a/src/tbb/src/tbbmalloc/mac32-tbbmalloc-export.def
+++ b/src/tbb/src/tbbmalloc/mac32-tbbmalloc-export.def
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 _scalable_calloc
@@ -46,3 +42,5 @@ __ZN3rml12pool_reallocEPNS_10MemoryPoolEPvm
 __ZN3rml20pool_aligned_reallocEPNS_10MemoryPoolEPvmm
 __ZN3rml19pool_aligned_mallocEPNS_10MemoryPoolEmm
 __ZN3rml13pool_identifyEPv
+__ZN3rml10pool_msizeEPNS_10MemoryPoolEPv
+
diff --git a/src/tbb/src/tbbmalloc/mac64-tbbmalloc-export.def b/src/tbb/src/tbbmalloc/mac64-tbbmalloc-export.def
index 71cc1079..82759dff 100644
--- a/src/tbb/src/tbbmalloc/mac64-tbbmalloc-export.def
+++ b/src/tbb/src/tbbmalloc/mac64-tbbmalloc-export.def
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 _scalable_calloc
@@ -46,3 +42,5 @@ __ZN3rml12pool_reallocEPNS_10MemoryPoolEPvm
 __ZN3rml20pool_aligned_reallocEPNS_10MemoryPoolEPvmm
 __ZN3rml19pool_aligned_mallocEPNS_10MemoryPoolEmm
 __ZN3rml13pool_identifyEPv
+__ZN3rml10pool_msizeEPNS_10MemoryPoolEPv
+
diff --git a/src/tbb/src/tbbmalloc/proxy.cpp b/src/tbb/src/tbbmalloc/proxy.cpp
index c865bd1a..2de52333 100644
--- a/src/tbb/src/tbbmalloc/proxy.cpp
+++ b/src/tbb/src/tbbmalloc/proxy.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,14 +12,32 @@
     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 __linux__ && !__ANDROID__
+// include <bits/c++config.h> indirectly so that <cstdlib> is not included
+#include <cstddef>
+// include <features.h> indirectly so that <stdlib.h> is not included
+#include <unistd.h>
+// Working around compiler issue with Anaconda's gcc 7.3 compiler package.
+// New gcc ported for old libc may provide their inline implementation
+// of aligned_alloc as required by new C++ standard, this makes it hard to
+// redefine aligned_alloc here. However, running on systems with new libc
+// version, it still needs it to be redefined, thus tricking system headers
+#if defined(__GLIBC_PREREQ) && !__GLIBC_PREREQ(2, 16) && _GLIBCXX_HAVE_ALIGNED_ALLOC
+// tell <cstdlib> that there is no aligned_alloc
+#undef _GLIBCXX_HAVE_ALIGNED_ALLOC
+// trick <stdlib.h> to define another symbol instead
+#define aligned_alloc __hidden_redefined_aligned_alloc
+// Fix the state and undefine the trick
+#include <cstdlib>
+#undef aligned_alloc
+#endif // defined(__GLIBC_PREREQ)&&!__GLIBC_PREREQ(2, 16)&&_GLIBCXX_HAVE_ALIGNED_ALLOC
+#endif // __linux__ && !__ANDROID__
+
 #include "proxy.h"
 #include "tbb/tbb_config.h"
+#include "tbb/tbb_environment.h"
 
 #if !defined(__EXCEPTIONS) && !defined(_CPPUNWIND) && !defined(__SUNPRO_CC)
     #if TBB_USE_EXCEPTIONS
@@ -31,6 +49,78 @@
     #define TBB_USE_EXCEPTIONS 1
 #endif
 
+#if __TBB_CPP11_PRESENT
+#define __TBB_THROW_BAD_ALLOC
+#define __TBB_NO_THROW noexcept
+#else
+#define __TBB_THROW_BAD_ALLOC throw(std::bad_alloc)
+#define __TBB_NO_THROW throw()
+#endif
+
+#if MALLOC_UNIXLIKE_OVERLOAD_ENABLED || _WIN32 && !__TBB_WIN8UI_SUPPORT
+/*** internal global operator new implementation (Linux, Windows) ***/
+#include <new>
+
+// Synchronization primitives to protect original library pointers and new_handler
+#include "Synchronize.h"
+
+#if __TBB_MSVC_PART_WORD_INTERLOCKED_INTRINSICS_PRESENT
+// Use MallocMutex implementation
+typedef MallocMutex ProxyMutex;
+#else
+// One byte atomic intrinsics are not available,
+// so use simple pointer based spin mutex
+class SimpleSpinMutex : tbb::internal::no_copy {
+    intptr_t flag;
+public:
+    class scoped_lock : tbb::internal::no_copy {
+        SimpleSpinMutex& mutex;
+    public:
+        scoped_lock( SimpleSpinMutex& m ) : mutex(m) {
+            while( !(AtomicFetchStore( &(m.flag), 1 ) == 0) );
+        }
+        ~scoped_lock() {
+            FencedStore(mutex.flag, 0);
+        }
+    };
+    friend class scoped_lock;
+};
+typedef SimpleSpinMutex ProxyMutex;
+#endif /* __TBB_MSVC_PART_WORD_INTERLOCKED_INTRINSICS_PRESENT */
+
+// In case there is no std::get_new_handler function
+// which provides synchronized access to std::new_handler
+#if !__TBB_CPP11_GET_NEW_HANDLER_PRESENT
+static ProxyMutex new_lock;
+#endif
+
+static inline void* InternalOperatorNew(size_t sz) {
+    void* res = scalable_malloc(sz);
+#if TBB_USE_EXCEPTIONS
+    while (!res) {
+        std::new_handler handler;
+#if __TBB_CPP11_GET_NEW_HANDLER_PRESENT
+        handler = std::get_new_handler();
+#else
+        {
+            ProxyMutex::scoped_lock lock(new_lock);
+            handler = std::set_new_handler(0);
+            std::set_new_handler(handler);
+        }
+#endif
+        if (handler) {
+            (*handler)();
+        } else {
+            throw std::bad_alloc();
+        }
+        res = scalable_malloc(sz);
+}
+#endif /* TBB_USE_EXCEPTIONS */
+    return res;
+}
+/*** end of internal global operator new implementation ***/
+#endif // MALLOC_UNIXLIKE_OVERLOAD_ENABLED || _WIN32 && !__TBB_WIN8UI_SUPPORT
+
 #if MALLOC_UNIXLIKE_OVERLOAD_ENABLED || MALLOC_ZONE_OVERLOAD_ENABLED
 
 #ifndef __THROW
@@ -38,7 +128,6 @@
 #endif
 
 /*** service functions and variables ***/
-
 #include <string.h> // for memset
 #include <unistd.h> // for sysconf
 
@@ -50,7 +139,6 @@ static inline void initPageSize()
 }
 
 #if MALLOC_UNIXLIKE_OVERLOAD_ENABLED
-#include "Customize.h" // FencedStore
 #include <dlfcn.h>
 #include <malloc.h>    // mallinfo
 
@@ -58,7 +146,15 @@ static inline void initPageSize()
    1) detection that the proxy library is loaded
    2) check that dlsym("malloc") found something different from our replacement malloc
 */
+// Starting from GCC 9, the -Wmissing-attributes warning was extended for alias below
+#if __GNUC__ == 9
+    #pragma GCC diagnostic push
+    #pragma GCC diagnostic ignored "-Wmissing-attributes"
+#endif
 extern "C" void *__TBB_malloc_proxy(size_t) __attribute__ ((alias ("malloc")));
+#if __GNUC__ == 9
+    #pragma GCC diagnostic pop
+#endif
 
 static void *orig_msize;
 
@@ -86,7 +182,7 @@ static intptr_t origFuncSearched;
 inline void InitOrigPointers()
 {
     // race is OK here, as different threads found same functions
-    if (!origFuncSearched) {
+    if (!FencedLoad(origFuncSearched)) {
         orig_free = dlsym(RTLD_NEXT, "free");
         orig_realloc = dlsym(RTLD_NEXT, "realloc");
         orig_msize = dlsym(RTLD_NEXT, "malloc_usable_size");
@@ -205,11 +301,20 @@ void *aligned_alloc(size_t alignment, size_t size) __attribute__ ((alias ("memal
 // in conjunction with standard malloc/free, so we must ovberload them.
 // Bionic doesn't have them. Not removing from the linker scripts,
 // as absent entry points are ignored by the linker.
+
+// Starting from GCC 9, the -Wmissing-attributes warning was extended for aliases below
+#if __GNUC__ == 9
+    #pragma GCC diagnostic push
+    #pragma GCC diagnostic ignored "-Wmissing-attributes"
+#endif
 void *__libc_malloc(size_t size) __attribute__ ((alias ("malloc")));
 void *__libc_calloc(size_t num, size_t size) __attribute__ ((alias ("calloc")));
 void *__libc_memalign(size_t alignment, size_t size) __attribute__ ((alias ("memalign")));
 void *__libc_pvalloc(size_t size) __attribute__ ((alias ("pvalloc")));
 void *__libc_valloc(size_t size) __attribute__ ((alias ("valloc")));
+#if __GNUC__ == 9
+    #pragma GCC diagnostic pop
+#endif
 
 // call original __libc_* to support naive replacement of free via __libc_free etc
 void __libc_free(void *ptr)
@@ -229,43 +334,31 @@ void *__libc_realloc(void *ptr, size_t size)
 
 /*** replacements for global operators new and delete ***/
 
-#include <new>
-
-void * operator new(size_t sz) {
-    void *res = scalable_malloc(sz);
-#if TBB_USE_EXCEPTIONS
-    if (NULL == res)
-        throw std::bad_alloc();
-#endif /* TBB_USE_EXCEPTIONS */
-    return res;
+void* operator new(size_t sz) __TBB_THROW_BAD_ALLOC {
+    return InternalOperatorNew(sz);
 }
-void* operator new[](size_t sz) {
-    void *res = scalable_malloc(sz);
-#if TBB_USE_EXCEPTIONS
-    if (NULL == res)
-        throw std::bad_alloc();
-#endif /* TBB_USE_EXCEPTIONS */
-    return res;
+void* operator new[](size_t sz) __TBB_THROW_BAD_ALLOC {
+    return InternalOperatorNew(sz);
 }
-void operator delete(void* ptr) throw() {
+void operator delete(void* ptr) __TBB_NO_THROW {
     InitOrigPointers();
     __TBB_malloc_safer_free(ptr, (void (*)(void*))orig_free);
 }
-void operator delete[](void* ptr) throw() {
+void operator delete[](void* ptr) __TBB_NO_THROW {
     InitOrigPointers();
     __TBB_malloc_safer_free(ptr, (void (*)(void*))orig_free);
 }
-void* operator new(size_t sz, const std::nothrow_t&) throw() {
+void* operator new(size_t sz, const std::nothrow_t&) __TBB_NO_THROW {
     return scalable_malloc(sz);
 }
-void* operator new[](std::size_t sz, const std::nothrow_t&) throw() {
+void* operator new[](std::size_t sz, const std::nothrow_t&) __TBB_NO_THROW {
     return scalable_malloc(sz);
 }
-void operator delete(void* ptr, const std::nothrow_t&) throw() {
+void operator delete(void* ptr, const std::nothrow_t&) __TBB_NO_THROW {
     InitOrigPointers();
     __TBB_malloc_safer_free(ptr, (void (*)(void*))orig_free);
 }
-void operator delete[](void* ptr, const std::nothrow_t&) throw() {
+void operator delete[](void* ptr, const std::nothrow_t&) __TBB_NO_THROW {
     InitOrigPointers();
     __TBB_malloc_safer_free(ptr, (void (*)(void*))orig_free);
 }
@@ -273,7 +366,6 @@ void operator delete[](void* ptr, const std::nothrow_t&) throw() {
 #endif /* MALLOC_UNIXLIKE_OVERLOAD_ENABLED */
 #endif /* MALLOC_UNIXLIKE_OVERLOAD_ENABLED || MALLOC_ZONE_OVERLOAD_ENABLED */
 
-
 #ifdef _WIN32
 #include <windows.h>
 
@@ -331,19 +423,35 @@ void* __TBB_malloc_safer_realloc_##CRTLIB( void *ptr, size_t size )
     return __TBB_malloc_safer_realloc( ptr, size, &func_ptrs );                                      \
 }                                                                                                    \
                                                                                                      \
-void* __TBB_malloc_safer__aligned_realloc_##CRTLIB( void *ptr, size_t size, size_t aligment )        \
+void* __TBB_malloc_safer__aligned_realloc_##CRTLIB( void *ptr, size_t size, size_t alignment )       \
 {                                                                                                    \
     orig_aligned_ptrs func_ptrs = {orig__aligned_free_##CRTLIB, orig__aligned_msize_##CRTLIB};       \
-    return __TBB_malloc_safer_aligned_realloc( ptr, size, aligment, &func_ptrs );                    \
+    return __TBB_malloc_safer_aligned_realloc( ptr, size, alignment, &func_ptrs );                   \
 }
 
-// Limit is 30 bytes/60 symbols per line, * can be used to match any digit in bytecodes.
-// Purpose of the pattern is to mark an instruction bound, it should consist of several
-// full instructions plus one more byte. It's not required for the patterns to be unique
-// (i.e., it's OK to have same pattern for unrelated functions).
+// Only for ucrtbase: substitution for _o_free
+void (*orig__o_free)(void*);
+void __TBB_malloc__o_free(void *ptr)
+{
+    __TBB_malloc_safer_free( ptr, orig__o_free );
+}
+// Only for ucrtbase: substitution for _free_base
+void(*orig__free_base)(void*);
+void __TBB_malloc__free_base(void *ptr)
+{
+    __TBB_malloc_safer_free(ptr, orig__free_base);
+}
+
+// Size limit is MAX_PATTERN_SIZE (28) byte codes / 56 symbols per line.
+// * can be used to match any digit in byte codes.
+// # followed by several * indicate a relative address that needs to be corrected.
+// Purpose of the pattern is to mark an instruction bound; it should consist of several
+// full instructions plus one extra byte code. It's not required for the patterns
+// to be unique (i.e., it's OK to have same pattern for unrelated functions).
 // TODO: use hot patch prologues if exist
 const char* known_bytecodes[] = {
 #if _WIN64
+//  "========================================================" - 56 symbols
     "4883EC284885C974",       // release free()
     "4883EC284885C975",       // release _msize()
     "4885C974375348",         // release free() 8.0.50727.42, 10.0
@@ -351,15 +459,18 @@ const char* known_bytecodes[] = {
     "C7442410000000008B",     // release free() ucrtbase.dll 10.0.14393.33
     "E90B000000CCCC",         // release _msize() ucrtbase.dll 10.0.14393.33
     "48895C24085748",         // release _aligned_msize() ucrtbase.dll 10.0.14393.33
+    "E903000000CCCC",         // release _aligned_msize() ucrtbase.dll 10.0.16299.522
     "48894C24084883EC28BA",   // debug prologue
     "4C894424184889542410",   // debug _aligned_msize() 10.0
     "48894C24084883EC2848",   // debug _aligned_free 10.0
+    "488BD1488D0D#*******E9", // _o_free(), ucrtbase.dll
  #if __TBB_OVERLOAD_OLD_MSVCR
     "48895C2408574883EC3049", // release _aligned_msize 9.0
     "4883EC384885C975",       // release _msize() 9.0
     "4C8BC1488B0DA6E4040033", // an old win64 SDK
  #endif
 #else // _WIN32
+//  "========================================================" - 56 symbols
     "8BFF558BEC8B",           // multiple
     "8BFF558BEC83",           // release free() & _msize() 10.0.40219.325, _msize() ucrtbase.dll
     "8BFF558BECFF",           // release _aligned_msize ucrtbase.dll
@@ -429,46 +540,41 @@ __TBB_ORIG_ALLOCATOR_REPLACEMENT_WRAPPER(msvcr120d);
 __TBB_ORIG_ALLOCATOR_REPLACEMENT_WRAPPER(msvcr120);
 __TBB_ORIG_ALLOCATOR_REPLACEMENT_WRAPPER(ucrtbase);
 
-
 /*** replacements for global operators new and delete ***/
 
-#include <new>
-
 #if _MSC_VER && !defined(__INTEL_COMPILER)
 #pragma warning( push )
 #pragma warning( disable : 4290 )
 #endif
 
-void * operator_new(size_t sz) {
-    void *res = scalable_malloc(sz);
-    if (NULL == res) throw std::bad_alloc();
-    return res;
+/*** operator new overloads internals (Linux, Windows) ***/
+
+void* operator_new(size_t sz) __TBB_THROW_BAD_ALLOC {
+    return InternalOperatorNew(sz);
 }
-void* operator_new_arr(size_t sz) {
-    void *res = scalable_malloc(sz);
-    if (NULL == res) throw std::bad_alloc();
-    return res;
+void* operator_new_arr(size_t sz) __TBB_THROW_BAD_ALLOC {
+    return InternalOperatorNew(sz);
 }
-void operator_delete(void* ptr) throw() {
+void operator_delete(void* ptr) __TBB_NO_THROW {
     __TBB_malloc_safer_delete(ptr);
 }
 #if _MSC_VER && !defined(__INTEL_COMPILER)
 #pragma warning( pop )
 #endif
 
-void operator_delete_arr(void* ptr) throw() {
+void operator_delete_arr(void* ptr) __TBB_NO_THROW {
     __TBB_malloc_safer_delete(ptr);
 }
-void* operator_new_t(size_t sz, const std::nothrow_t&) throw() {
+void* operator_new_t(size_t sz, const std::nothrow_t&) __TBB_NO_THROW {
     return scalable_malloc(sz);
 }
-void* operator_new_arr_t(std::size_t sz, const std::nothrow_t&) throw() {
+void* operator_new_arr_t(std::size_t sz, const std::nothrow_t&) __TBB_NO_THROW {
     return scalable_malloc(sz);
 }
-void operator_delete_t(void* ptr, const std::nothrow_t&) throw() {
+void operator_delete_t(void* ptr, const std::nothrow_t&) __TBB_NO_THROW {
     __TBB_malloc_safer_delete(ptr);
 }
-void operator_delete_arr_t(void* ptr, const std::nothrow_t&) throw() {
+void operator_delete_arr_t(void* ptr, const std::nothrow_t&) __TBB_NO_THROW {
     __TBB_malloc_safer_delete(ptr);
 }
 
@@ -577,7 +683,7 @@ bool BytecodesAreKnown(const unicode_char_t *dllName)
     if (!module)
         return false;
     for (int i=0; funcName[i]; i++)
-        if (! IsPrologueKnown(module, funcName[i], known_bytecodes)) {
+        if (! IsPrologueKnown(dllName, funcName[i], known_bytecodes, module)) {
             fprintf(stderr, "TBBmalloc: skip allocation functions replacement in " WCHAR_SPEC
                     ": unknown prologue for function " WCHAR_SPEC "\n", dllName, funcName[i]);
             return false;
@@ -597,7 +703,7 @@ void SkipReplacement(const unicode_char_t *dllName)
     char *dllStr = buffer;
 
     errno_t ret = wcstombs_s(&real_sz, dllStr, sz, dllName, sz-1);
-    __TBB_ASSERT(!ret, "Dll name conversion failed")
+    __TBB_ASSERT(!ret, "Dll name conversion failed");
 #endif
 
     for (size_t i=0; i<arrayLength(modules_to_replace); i++)
@@ -616,7 +722,11 @@ void ReplaceFunctionWithStore( const unicode_char_t *dllName, const char *funcNa
 
     fprintf(stderr, "Failed to %s function %s in module %s\n",
             res==FRR_NOFUNC? "find" : "replace", funcName, dllName);
-    exit(1);
+
+    // Unable to replace a required function
+    // Aborting because incomplete replacement of memory management functions
+    // may leave the program in an invalid state
+    abort();
 }
 
 void doMallocReplacement()
@@ -641,8 +751,20 @@ void doMallocReplacement()
         {
             ReplaceFunctionWithStore( modules_to_replace[j].name, c_routines_to_replace[i]._func, c_routines_to_replace[i]._fptr, NULL, NULL,  c_routines_to_replace[i]._on_error );
         }
-        // ucrtbase.dll does not export operator new/delete.
-        if ( strcmp(modules_to_replace[j].name, "ucrtbase.dll") == 0 ){
+        if ( strcmp(modules_to_replace[j].name, "ucrtbase.dll") == 0 ) {
+            HMODULE ucrtbase_handle = GetModuleHandle("ucrtbase.dll");
+            if (!ucrtbase_handle)
+                continue;
+            // If _o_free function is present and patchable, redirect it to tbbmalloc as well
+            // This prevents issues with other _o_* functions which might allocate memory with malloc
+            if ( IsPrologueKnown("ucrtbase.dll", "_o_free", known_bytecodes, ucrtbase_handle)) {
+                ReplaceFunctionWithStore( "ucrtbase.dll", "_o_free", (FUNCPTR)__TBB_malloc__o_free, known_bytecodes, (FUNCPTR*)&orig__o_free,  FRR_FAIL );
+            }
+            // Similarly for _free_base
+            if (IsPrologueKnown("ucrtbase.dll", "_free_base", known_bytecodes, ucrtbase_handle)) {
+                ReplaceFunctionWithStore("ucrtbase.dll", "_free_base", (FUNCPTR)__TBB_malloc__free_base, known_bytecodes, (FUNCPTR*)&orig__free_base, FRR_FAIL);
+            }
+            // ucrtbase.dll does not export operator new/delete, so skip the rest of the loop.
             continue;
         }
 
@@ -668,15 +790,10 @@ extern "C" BOOL WINAPI DllMain( HINSTANCE hInst, DWORD callReason, LPVOID reserv
 
     if ( callReason==DLL_PROCESS_ATTACH && reserved && hInst ) {
 #if !__TBB_WIN8UI_SUPPORT
-#if TBBMALLOC_USE_TBB_FOR_ALLOCATOR_ENV_CONTROLLED
-        char pinEnvVariable[50];
-        if( GetEnvironmentVariable("TBBMALLOC_USE_TBB_FOR_ALLOCATOR", pinEnvVariable, 50))
+        if (!tbb::internal::GetBoolEnvironmentVariable("TBB_MALLOC_DISABLE_REPLACEMENT"))
         {
             doMallocReplacement();
         }
-#else
-        doMallocReplacement();
-#endif
 #endif // !__TBB_WIN8UI_SUPPORT
     }
 
diff --git a/src/tbb/src/tbbmalloc/proxy.h b/src/tbb/src/tbbmalloc/proxy.h
index 8db526c2..a6a8479a 100644
--- a/src/tbb/src/tbbmalloc/proxy.h
+++ b/src/tbb/src/tbbmalloc/proxy.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef _TBB_malloc_proxy_H_
diff --git a/src/tbb/src/tbbmalloc/proxy_overload_osx.h b/src/tbb/src/tbbmalloc/proxy_overload_osx.h
index 53afe13d..c052b1b5 100644
--- a/src/tbb/src/tbbmalloc/proxy_overload_osx.h
+++ b/src/tbb/src/tbbmalloc/proxy_overload_osx.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 // The original source for this code is
diff --git a/src/tbb/src/tbbmalloc/shared_utils.h b/src/tbb/src/tbbmalloc/shared_utils.h
index 273559d3..6904663e 100644
--- a/src/tbb/src/tbbmalloc/shared_utils.h
+++ b/src/tbb/src/tbbmalloc/shared_utils.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_shared_utils_H
@@ -60,6 +56,14 @@ inline size_t arrayLength(const T(&)[N]) {
     return N;
 }
 
+/*
+ * Compile time Log2 calculation
+ */
+template <size_t NUM>
+struct Log2 { static const int value = 1 + Log2<(NUM >> 1)>::value; };
+template <>
+struct Log2<1> { static const int value = 0; };
+
 #if defined(min)
 #undef min
 #endif
@@ -69,6 +73,61 @@ T min ( const T& val1, const T& val2 ) {
     return val1 < val2 ? val1 : val2;
 }
 
+/*
+ * Functions to parse files information (system files for example)
+ */
+
+#include <stdio.h>
+
+#if defined(_MSC_VER) && (_MSC_VER<1900) && !defined(__INTEL_COMPILER)
+    // Suppress overzealous compiler warnings that default ctor and assignment
+    // operator cannot be generated and object 'class' can never be instantiated.
+    #pragma warning(push)
+    #pragma warning(disable:4510 4512 4610)
+#endif
+
+#if __SUNPRO_CC
+    // Suppress overzealous compiler warnings that a class with a reference member
+    // lacks a user-defined constructor, which can lead to errors
+    #pragma error_messages (off, refmemnoconstr)
+#endif
+
+// TODO: add a constructor to remove warnings suppression
+struct parseFileItem {
+    const char* format;
+    unsigned long long& value;
+};
+
+#if defined(_MSC_VER) && (_MSC_VER<1900) && !defined(__INTEL_COMPILER)
+    #pragma warning(pop)
+#endif
+
+#if __SUNPRO_CC
+    #pragma error_messages (on, refmemnoconstr)
+#endif
+
+template <int BUF_LINE_SIZE, int N>
+void parseFile(const char* file, const parseFileItem (&items)[N]) {
+    // Tries to find all items in each line
+    int found[N] = { 0 };
+    // If all items found, stop forward file reading
+    int numFound = 0;
+    // Line storage
+    char buf[BUF_LINE_SIZE];
+
+    if (FILE *f = fopen(file, "r")) {
+        while (numFound < N && fgets(buf, BUF_LINE_SIZE, f)) {
+            for (int i = 0; i < N; ++i) {
+                if (!found[i] && 1 == sscanf(buf, items[i].format, &items[i].value)) {
+                    ++numFound;
+                    found[i] = 1;
+                }
+            }
+        }
+        fclose(f);
+    }
+}
+
 namespace rml {
 namespace internal {
 
@@ -85,5 +144,8 @@ const uint32_t estimatedCacheLineSize = 128;
 const uint32_t estimatedCacheLineSize =  64;
 #endif
 
-}} // namespaces
+} // namespace internal
+} // namespace rml
+
 #endif /* __TBB_shared_utils_H */
+
diff --git a/src/tbb/src/tbbmalloc/tbb_function_replacement.cpp b/src/tbb/src/tbbmalloc/tbb_function_replacement.cpp
index b0157856..602ec681 100644
--- a/src/tbb/src/tbbmalloc/tbb_function_replacement.cpp
+++ b/src/tbb/src/tbbmalloc/tbb_function_replacement.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,28 +12,84 @@
     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 "tbb/tbb_config.h"
 
 #if !__TBB_WIN8UI_SUPPORT && defined(_WIN32)
 
+#ifndef _CRT_SECURE_NO_DEPRECATE
 #define _CRT_SECURE_NO_DEPRECATE 1
+#endif
 #define __TBB_NO_IMPLICIT_LINKAGE 1
 
+// no standard-conforming implementation of snprintf prior to VS 2015
+#if !defined(_MSC_VER) || _MSC_VER>=1900
+#define LOG_PRINT(s, n, format, ...) snprintf(s, n, format, __VA_ARGS__)
+#else
+#define LOG_PRINT(s, n, format, ...) _snprintf_s(s, n, _TRUNCATE, format, __VA_ARGS__)
+#endif
+
 #include <windows.h>
 #include <new>
 #include <stdio.h>
+#include <string.h>
 #include "tbb_function_replacement.h"
 
-#include "tbb/tbb_config.h"
 #include "tbb/tbb_stddef.h"
 #include "../tbb/tbb_assert_impl.h"
 
+// The information about a standard memory allocation function for the replacement log
+struct FunctionInfo {
+    const char* funcName;
+    const char* dllName;
+};
+
+// Namespace that processes and manages the output of records to the Log journal
+// that will be provided to user by TBB_malloc_replacement_log()
+namespace Log {
+    // Value of RECORDS_COUNT is set due to the fact that we maximally
+    // scan 8 modules, and in every module we can swap 6 opcodes. (rounded to 8)
+    static const unsigned RECORDS_COUNT = 8 * 8;
+    static const unsigned RECORD_LENGTH = MAX_PATH;
+
+    // Need to add 1 to count of records, because last record must be always NULL
+    static char *records[RECORDS_COUNT + 1];
+    static bool replacement_status = true;
+
+    // Internal counter that contains number of next string for record
+    static unsigned record_number = 0;
+
+    // Function that writes info about (not)found opcodes to the Log journal
+    // functionInfo - information about a standard memory allocation function for the replacement log
+    // opcodeString - string, that contain byte code of this function
+    // status - information about function replacement status
+    static void record(FunctionInfo functionInfo, const char * opcodeString, bool status) {
+        __TBB_ASSERT(functionInfo.dllName, "Empty DLL name value");
+        __TBB_ASSERT(functionInfo.funcName, "Empty function name value");
+        __TBB_ASSERT(opcodeString, "Empty opcode");
+        __TBB_ASSERT(record_number <= RECORDS_COUNT, "Incorrect record number");
+
+        //If some replacement failed -> set status to false
+        replacement_status &= status;
+
+        // If we reach the end of the log, write this message to the last line
+        if (record_number == RECORDS_COUNT) {
+            // %s - workaround to fix empty variable argument parsing behavior in GCC
+            LOG_PRINT(records[RECORDS_COUNT - 1], RECORD_LENGTH, "%s", "Log was truncated.");
+            return;
+        }
+
+        char* entry = (char*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, RECORD_LENGTH);
+        __TBB_ASSERT(entry, "Invalid memory was returned");
+
+        LOG_PRINT(entry, RECORD_LENGTH, "%s: %s (%s), byte pattern: <%s>",
+            status ? "Success" : "Fail", functionInfo.funcName, functionInfo.dllName, opcodeString);
+
+        records[record_number++] = entry;
+    }
+};
+
 inline UINT_PTR Ptr2Addrint(LPVOID ptr)
 {
     Int2Ptr i2p;
@@ -66,7 +122,7 @@ inline bool IsInDistance(UINT_PTR addr1, UINT_PTR addr2, __int64 dist)
  * doesn't allocate memory dynamically.
  *
  * The struct MemoryBuffer holds the data about a page in the memory used for
- * replacing functions in Intel64 where the target is too far to be replaced
+ * replacing functions in 64-bit code where the target is too far to be replaced
  * with a short jump. All the calculations of m_base and m_next are in a multiple
  * of SIZE_OF_ADDRESS (which is 8 in Win64).
  */
@@ -180,14 +236,13 @@ static MemoryProvider memProvider;
 
 // Compare opcodes from dictionary (str1) and opcodes from code (str2)
 // str1 might contain '*' to mask addresses
-// RETURN: NULL if opcodes did not match, string length of str1 on success
+// RETURN: 0 if opcodes did not match, 1 on success
 size_t compareStrings( const char *str1, const char *str2 )
 {
-   size_t str1Length = strlen(str1);
-   for (size_t i=0; i<str1Length; i++){
-       if( str1[i] != '*' && str1[i] != str2[i] ) return 0;
+   for (size_t i=0; str1[i]!=0; i++){
+       if( str1[i]!='*' && str1[i]!='#' && str1[i]!=str2[i] ) return 0;
    }
-   return str1Length;
+   return 1;
 }
 
 // Check function prologue with known prologues from the dictionary
@@ -195,15 +250,15 @@ size_t compareStrings( const char *str1, const char *str2 )
 // inpAddr - pointer to function prologue
 // Dictionary contains opcodes for several full asm instructions
 // + one opcode byte for the next asm instruction for safe address processing
-// RETURN: number of bytes for safe bytes replacement (matched_pattern/2-1)
-UINT CheckOpcodes( const char ** opcodes, void *inpAddr, bool abortOnError )
+// RETURN: 1 + the index of the matched pattern, or 0 if no match found.
+static UINT CheckOpcodes( const char ** opcodes, void *inpAddr, bool abortOnError, const FunctionInfo* functionInfo = NULL)
 {
     static size_t opcodesStringsCount = 0;
     static size_t maxOpcodesLength = 0;
     static size_t opcodes_pointer = (size_t)opcodes;
-    char opcodeString[61];
+    char opcodeString[2*MAX_PATTERN_SIZE+1];
     size_t i;
-    size_t result;
+    size_t result = 0;
 
     // Get the values for static variables
     // max length and number of patterns
@@ -214,20 +269,27 @@ UINT CheckOpcodes( const char ** opcodes, void *inpAddr, bool abortOnError )
             opcodesStringsCount++;
         }
         opcodes_pointer = (size_t)opcodes;
-        __TBB_ASSERT( maxOpcodesLength < 61, "Limit is 30 opcodes/60 symbols per pattern" );
+        __TBB_ASSERT( maxOpcodesLength/2 <= MAX_PATTERN_SIZE, "Pattern exceeded the limit of 28 opcodes/56 symbols" );
     }
 
     // Translate prologue opcodes to string format to compare
-    for( i=0; i< maxOpcodesLength/2; i++ ){
+    for( i=0; i<maxOpcodesLength/2 && i<MAX_PATTERN_SIZE; ++i ){
         sprintf( opcodeString + 2*i, "%.2X", *((unsigned char*)inpAddr+i) );
     }
-    opcodeString[maxOpcodesLength] = 0;
+    opcodeString[2*i] = 0;
 
     // Compare translated opcodes with patterns
-    for( i=0; i< opcodesStringsCount; i++ ){
-        result = compareStrings( opcodes[i],opcodeString );
-        if( result )
-            return (UINT)(result/2-1);
+    for( UINT idx=0; idx<opcodesStringsCount; ++idx ){
+        result = compareStrings( opcodes[idx],opcodeString );
+        if( result ) {
+            if (functionInfo) {
+                Log::record(*functionInfo, opcodeString, /*status*/ true);
+            }
+            return idx + 1; // avoid 0 which indicates a failure
+        }
+    }
+    if (functionInfo) {
+        Log::record(*functionInfo, opcodeString, /*status*/ false);
     }
     if (abortOnError) {
         // Impossibility to find opcodes in the dictionary is a serious issue,
@@ -237,11 +299,26 @@ UINT CheckOpcodes( const char ** opcodes, void *inpAddr, bool abortOnError )
     return 0;
 }
 
+// Modify offsets in original code after moving it to a trampoline.
+// We do not have more than one offset to correct in existing opcode patterns.
+static void CorrectOffset( UINT_PTR address, const char* pattern, UINT distance )
+{
+    const char* pos = strstr(pattern, "#*******");
+    if( pos ) {
+        address += (pos - pattern)/2; // compute the offset position
+        UINT value;
+        // UINT assignment is not used to avoid potential alignment issues
+        memcpy(&value, Addrint2Ptr(address), sizeof(value));
+        value += distance;
+        memcpy(Addrint2Ptr(address), &value, sizeof(value));
+    }
+}
+
 // Insert jump relative instruction to the input address
 // RETURN: the size of the trampoline or 0 on failure
-static DWORD InsertTrampoline32(void *inpAddr, void *targetAddr, const char ** opcodes, void** storedAddr)
+static DWORD InsertTrampoline32(void *inpAddr, void *targetAddr, const char* pattern, void** storedAddr)
 {
-    UINT opcodesNumber = SIZE_OF_RELJUMP;
+    size_t bytesToMove = SIZE_OF_RELJUMP;
     UINT_PTR srcAddr = Ptr2Addrint(inpAddr);
     UINT_PTR tgtAddr = Ptr2Addrint(targetAddr);
     // Check that the target fits in 32 bits
@@ -253,29 +330,24 @@ static DWORD InsertTrampoline32(void *inpAddr, void *targetAddr, const char ** o
     UCHAR *codePtr = (UCHAR *)inpAddr;
 
     if ( storedAddr ){ // If requested, store original function code
-        if ( *codePtr == 0xE9 ){ // JMP relative instruction
-            // For the special case when a system function consists of a single near jump,
-            // instead of moving it somewhere we use the target of the jump as the original function.
-            unsigned offsetInJmp = *(unsigned*)(codePtr + 1);
-            *storedAddr = (void*)(srcAddr + offsetInJmp + SIZE_OF_RELJUMP);
-        }else{
-            opcodesNumber = CheckOpcodes( opcodes, inpAddr, /*abortOnError=*/true );
-            __TBB_ASSERT_RELEASE( opcodesNumber >= SIZE_OF_RELJUMP, "Incorrect bytecode pattern?" );
-            UINT_PTR strdAddr = memProvider.GetLocation(srcAddr);
-            if (!strdAddr)
-                return 0;
-            *storedAddr = Addrint2Ptr(strdAddr);
-            // Set 'executable' flag for original instructions in the new place
-            DWORD pageFlags = PAGE_EXECUTE_READWRITE;
-            if (!VirtualProtect(*storedAddr, MAX_PROBE_SIZE, pageFlags, &pageFlags)) return 0;
-            // Copy original instructions to the new place
-            memcpy(*storedAddr, codePtr, opcodesNumber);
-            // Set jump to the code after replacement
-            offset = srcAddr - strdAddr - SIZE_OF_RELJUMP;
-            offset32 = (UINT)((offset & 0xFFFFFFFF));
-            *((UCHAR*)*storedAddr+opcodesNumber) = 0xE9;
-            memcpy(((UCHAR*)*storedAddr+opcodesNumber+1), &offset32, sizeof(offset32));
-        }
+        bytesToMove = strlen(pattern)/2-1; // The last byte matching the pattern must not be copied
+        __TBB_ASSERT_RELEASE( bytesToMove >= SIZE_OF_RELJUMP, "Incorrect bytecode pattern?" );
+        UINT_PTR trampAddr = memProvider.GetLocation(srcAddr);
+        if (!trampAddr)
+            return 0;
+        *storedAddr = Addrint2Ptr(trampAddr);
+        // Set 'executable' flag for original instructions in the new place
+        DWORD pageFlags = PAGE_EXECUTE_READWRITE;
+        if (!VirtualProtect(*storedAddr, MAX_PROBE_SIZE, pageFlags, &pageFlags)) return 0;
+        // Copy original instructions to the new place
+        memcpy(*storedAddr, codePtr, bytesToMove);
+        offset = srcAddr - trampAddr;
+        offset32 = (UINT)(offset & 0xFFFFFFFF);
+        CorrectOffset( trampAddr, pattern, offset32 );
+        // Set jump to the code after replacement
+        offset32 -= SIZE_OF_RELJUMP;
+        *(UCHAR*)(trampAddr+bytesToMove) = 0xE9;
+        memcpy((UCHAR*)(trampAddr+bytesToMove+1), &offset32, sizeof(offset32));
     }
 
     // The following will work correctly even if srcAddr>tgtAddr, as long as
@@ -287,7 +359,7 @@ static DWORD InsertTrampoline32(void *inpAddr, void *targetAddr, const char ** o
     memcpy(codePtr+1, &offset32, sizeof(offset32));
 
     // Fill the rest with NOPs to correctly see disassembler of old code in debugger.
-    for( unsigned i=SIZE_OF_RELJUMP; i<opcodesNumber; i++ ){
+    for( unsigned i=SIZE_OF_RELJUMP; i<bytesToMove; i++ ){
         *(codePtr+i) = 0x90;
     }
 
@@ -299,9 +371,9 @@ static DWORD InsertTrampoline32(void *inpAddr, void *targetAddr, const char ** o
 // 2  Put jump RIP relative indirect through the address in the close page
 // 3  Put the absolute address of the target in the allocated location
 // RETURN: the size of the trampoline or 0 on failure
-static DWORD InsertTrampoline64(void *inpAddr, void *targetAddr, const char ** opcodes, void** storedAddr)
+static DWORD InsertTrampoline64(void *inpAddr, void *targetAddr, const char* pattern, void** storedAddr)
 {
-    UINT opcodesNumber = SIZE_OF_INDJUMP;
+    size_t bytesToMove = SIZE_OF_INDJUMP;
 
     UINT_PTR srcAddr = Ptr2Addrint(inpAddr);
     UINT_PTR tgtAddr = Ptr2Addrint(targetAddr);
@@ -320,29 +392,24 @@ static DWORD InsertTrampoline64(void *inpAddr, void *targetAddr, const char ** o
     *locPtr = tgtAddr;
 
     if ( storedAddr ){ // If requested, store original function code
-        if ( *codePtr == 0xE9 ){ // JMP relative instruction
-            // For the special case when a system function consists of a single near jump,
-            // instead of moving it somewhere we use the target of the jump as the original function.
-            unsigned offsetInJmp = *(unsigned*)(codePtr + 1);
-            *storedAddr = (void*)(srcAddr + offsetInJmp + SIZE_OF_RELJUMP);
-        }else{
-            opcodesNumber = CheckOpcodes( opcodes, inpAddr, /*abortOnError=*/true );
-            __TBB_ASSERT_RELEASE( opcodesNumber >= SIZE_OF_INDJUMP, "Incorrect bytecode pattern?" );
-            UINT_PTR strdAddr = memProvider.GetLocation(srcAddr);
-            if (!strdAddr)
-                return 0;
-            *storedAddr = Addrint2Ptr(strdAddr);
-            // Set 'executable' flag for original instructions in the new place
-            DWORD pageFlags = PAGE_EXECUTE_READWRITE;
-            if (!VirtualProtect(*storedAddr, MAX_PROBE_SIZE, pageFlags, &pageFlags)) return 0;
-            // Copy original instructions to the new place
-            memcpy(*storedAddr, codePtr, opcodesNumber);
-            // Set jump to the code after replacement. It is within the distance of relative jump!
-            offset = srcAddr - strdAddr - SIZE_OF_RELJUMP;
-            offset32 = (UINT)((offset & 0xFFFFFFFF));
-            *((UCHAR*)*storedAddr+opcodesNumber) = 0xE9;
-            memcpy(((UCHAR*)*storedAddr+opcodesNumber+1), &offset32, sizeof(offset32));
-        }
+        bytesToMove = strlen(pattern)/2-1; // The last byte matching the pattern must not be copied
+        __TBB_ASSERT_RELEASE( bytesToMove >= SIZE_OF_INDJUMP, "Incorrect bytecode pattern?" );
+        UINT_PTR trampAddr = memProvider.GetLocation(srcAddr);
+        if (!trampAddr)
+            return 0;
+        *storedAddr = Addrint2Ptr(trampAddr);
+        // Set 'executable' flag for original instructions in the new place
+        DWORD pageFlags = PAGE_EXECUTE_READWRITE;
+        if (!VirtualProtect(*storedAddr, MAX_PROBE_SIZE, pageFlags, &pageFlags)) return 0;
+        // Copy original instructions to the new place
+        memcpy(*storedAddr, codePtr, bytesToMove);
+        offset = srcAddr - trampAddr;
+        offset32 = (UINT)(offset & 0xFFFFFFFF);
+        CorrectOffset( trampAddr, pattern, offset32 );
+        // Set jump to the code after replacement. It is within the distance of relative jump!
+        offset32 -= SIZE_OF_RELJUMP;
+        *(UCHAR*)(trampAddr+bytesToMove) = 0xE9;
+        memcpy((UCHAR*)(trampAddr+bytesToMove+1), &offset32, sizeof(offset32));
     }
 
     // Fill the buffer
@@ -353,7 +420,7 @@ static DWORD InsertTrampoline64(void *inpAddr, void *targetAddr, const char ** o
     memcpy(codePtr+2, &offset32, sizeof(offset32));
 
     // Fill the rest with NOPs to correctly see disassembler of old code in debugger.
-    for( unsigned i=SIZE_OF_INDJUMP; i<opcodesNumber; i++ ){
+    for( unsigned i=SIZE_OF_INDJUMP; i<bytesToMove; i++ ){
         *(codePtr+i) = 0x90;
     }
 
@@ -373,9 +440,27 @@ static bool InsertTrampoline(void *inpAddr, void *targetAddr, const char ** opco
     DWORD origProt = 0;
     if (!VirtualProtect(inpAddr, MAX_PROBE_SIZE, PAGE_EXECUTE_WRITECOPY, &origProt))
         return FALSE;
-    probeSize = InsertTrampoline32(inpAddr, targetAddr, opcodes, origFunc);
+
+    const char* pattern = NULL;
+    if ( origFunc ){ // Need to store original function code
+        UCHAR * const codePtr = (UCHAR *)inpAddr;
+        if ( *codePtr == 0xE9 ){ // JMP relative instruction
+            // For the special case when a system function consists of a single near jump,
+            // instead of moving it somewhere we use the target of the jump as the original function.
+            unsigned offsetInJmp = *(unsigned*)(codePtr + 1);
+            *origFunc = (void*)(Ptr2Addrint(inpAddr) + offsetInJmp + SIZE_OF_RELJUMP);
+            origFunc = NULL; // now it must be ignored by InsertTrampoline32/64
+        } else {
+            // find the right opcode pattern
+            UINT opcodeIdx = CheckOpcodes( opcodes, inpAddr, /*abortOnError=*/true );
+            __TBB_ASSERT( opcodeIdx > 0, "abortOnError ignored in CheckOpcodes?" );
+            pattern = opcodes[opcodeIdx-1];  // -1 compensates for +1 in CheckOpcodes
+        }
+    }
+
+    probeSize = InsertTrampoline32(inpAddr, targetAddr, pattern, origFunc);
     if (!probeSize)
-        probeSize = InsertTrampoline64(inpAddr, targetAddr, opcodes, origFunc);
+        probeSize = InsertTrampoline64(inpAddr, targetAddr, pattern, origFunc);
 
     // Restore original protection
     VirtualProtect(inpAddr, MAX_PROBE_SIZE, origProt, &origProt);
@@ -471,12 +556,28 @@ FRR_TYPE ReplaceFunctionW(const wchar_t *dllName, const char *funcName, FUNCPTR
     return FRR_OK;
 }
 
-bool IsPrologueKnown(HMODULE module, const char *funcName, const char **opcodes)
+bool IsPrologueKnown(const char* dllName, const char *funcName, const char **opcodes, HMODULE module)
 {
     FARPROC inpFunc = GetProcAddress(module, funcName);
-    if (!inpFunc)
+    FunctionInfo functionInfo = { funcName, dllName };
+
+    if (!inpFunc) {
+        Log::record(functionInfo, "unknown", /*status*/ false);
         return false;
-    return CheckOpcodes( opcodes, (void*)inpFunc, /*abortOnError=*/false ) != 0;
+    }
+
+    return CheckOpcodes( opcodes, (void*)inpFunc, /*abortOnError=*/false, &functionInfo) != 0;
+}
+
+// Public Windows API
+extern "C" __declspec(dllexport) int TBB_malloc_replacement_log(char *** function_replacement_log_ptr)
+{
+    if (function_replacement_log_ptr != NULL) {
+        *function_replacement_log_ptr = Log::records;
+    }
+
+    // If we have no logs -> return false status
+    return Log::replacement_status && Log::records[0] != NULL ? 0 : -1;
 }
 
 #endif /* !__TBB_WIN8UI_SUPPORT && defined(_WIN32) */
diff --git a/src/tbb/src/tbbmalloc/tbb_function_replacement.h b/src/tbb/src/tbbmalloc/tbb_function_replacement.h
index e986ab18..109536bc 100644
--- a/src/tbb/src/tbbmalloc/tbb_function_replacement.h
+++ b/src/tbb/src/tbbmalloc/tbb_function_replacement.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_function_replacement_H
@@ -45,7 +41,7 @@ typedef void (*FUNCPTR)();
 FRR_TYPE ReplaceFunctionA(const char *dllName, const char *funcName, FUNCPTR newFunc, const char ** opcodes, FUNCPTR* origFunc=NULL);
 FRR_TYPE ReplaceFunctionW(const wchar_t *dllName, const char *funcName, FUNCPTR newFunc, const char ** opcodes, FUNCPTR* origFunc=NULL);
 
-bool IsPrologueKnown(HMODULE module, const char *funcName, const char **opcodes);
+bool IsPrologueKnown(const char* dllName, const char *funcName, const char **opcodes, HMODULE module);
 
 // Utilities to convert between ADDRESS and LPVOID
 union Int2Ptr {
@@ -56,7 +52,7 @@ union Int2Ptr {
 inline UINT_PTR Ptr2Addrint(LPVOID ptr);
 inline LPVOID Addrint2Ptr(UINT_PTR ptr);
 
-// Use this value as the maximum size the trampoline region
+// The size of a trampoline region
 const unsigned MAX_PROBE_SIZE = 32;
 
 // The size of a jump relative instruction "e9 00 00 00 00"
@@ -68,6 +64,10 @@ const unsigned SIZE_OF_INDJUMP = 6;
 // The size of address we put in the location (in Intel64)
 const unsigned SIZE_OF_ADDRESS = 8;
 
+// The size limit (in bytes) for an opcode pattern to fit into a trampoline
+// There should be enough space left for a relative jump; +1 is for the extra pattern byte.
+const unsigned MAX_PATTERN_SIZE = MAX_PROBE_SIZE - SIZE_OF_RELJUMP + 1;
+
 // The max distance covered in 32 bits: 2^31 - 1 - C
 // where C should not be smaller than the size of a probe.
 // The latter is important to correctly handle "backward" jumps.
diff --git a/src/tbb/src/tbbmalloc/tbbmalloc.cpp b/src/tbb/src/tbbmalloc/tbbmalloc.cpp
index fa0e6984..080ce1d4 100644
--- a/src/tbb/src/tbbmalloc/tbbmalloc.cpp
+++ b/src/tbb/src/tbbmalloc/tbbmalloc.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 "TypeDefinitions.h" // Customize.h and proxy.h get included
@@ -45,7 +41,7 @@ namespace internal {
 #define MALLOCLIB_NAME "tbbmalloc" DEBUG_SUFFIX ".dll"
 #elif __APPLE__
 #define MALLOCLIB_NAME "libtbbmalloc" DEBUG_SUFFIX ".dylib"
-#elif __FreeBSD__ || __NetBSD__ || __sun || _AIX || __ANDROID__
+#elif __FreeBSD__ || __NetBSD__ || __OpenBSD__ || __sun || _AIX || __ANDROID__
 #define MALLOCLIB_NAME "libtbbmalloc" DEBUG_SUFFIX ".so"
 #elif __linux__
 #define MALLOCLIB_NAME "libtbbmalloc" DEBUG_SUFFIX  __TBB_STRING(.so.TBB_COMPATIBLE_INTERFACE_VERSION)
@@ -75,16 +71,15 @@ void init_tbbmalloc() {
 
 #if !__TBB_SOURCE_DIRECTLY_INCLUDED
 #if USE_WINTHREAD
-extern "C" BOOL WINAPI DllMain( HINSTANCE /*hInst*/, DWORD callReason, LPVOID )
+extern "C" BOOL WINAPI DllMain( HINSTANCE /*hInst*/, DWORD callReason, LPVOID lpvReserved)
 {
-
     if (callReason==DLL_THREAD_DETACH)
     {
         __TBB_mallocThreadShutdownNotification();
     }
     else if (callReason==DLL_PROCESS_DETACH)
     {
-        __TBB_mallocProcessShutdownNotification();
+        __TBB_mallocProcessShutdownNotification(lpvReserved != NULL);
     }
     return TRUE;
 }
@@ -98,7 +93,7 @@ struct RegisterProcessShutdownNotification {
     }
 #endif /* !__TBB_USE_DLOPEN_REENTRANCY_WORKAROUND */
     ~RegisterProcessShutdownNotification() {
-        __TBB_mallocProcessShutdownNotification();
+        __TBB_mallocProcessShutdownNotification(false);
     }
 };
 
diff --git a/src/tbb/src/tbbmalloc/tbbmalloc.rc b/src/tbb/src/tbbmalloc/tbbmalloc.rc
index 2b65e554..6c6eedfc 100644
--- a/src/tbb/src/tbbmalloc/tbbmalloc.rc
+++ b/src/tbb/src/tbbmalloc/tbbmalloc.rc
@@ -1,4 +1,4 @@
-// Copyright (c) 2005-2017 Intel Corporation
+// Copyright (c) 2005-2020 Intel Corporation
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -11,10 +11,6 @@
 // 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.
-//
-//
-//
-//
 
 // Microsoft Visual C++ generated resource script.
 //
@@ -84,7 +80,7 @@ BEGIN
             VALUE "CompanyName", "Intel Corporation\0"
             VALUE "FileDescription", "Scalable Allocator library\0"
             VALUE "FileVersion", TBBMALLOC_VERSION "\0"
-            VALUE "LegalCopyright", "Copyright 2005-2017 Intel Corporation.  All Rights Reserved.\0"
+            VALUE "LegalCopyright", "Copyright 2005-2020 Intel Corporation.  All Rights Reserved.\0"
             VALUE "LegalTrademarks", "\0"
 #ifndef TBB_USE_DEBUG
             VALUE "OriginalFilename", "tbbmalloc.dll\0"
diff --git a/src/tbb/src/tbbmalloc/tbbmalloc_internal.h b/src/tbb/src/tbbmalloc/tbbmalloc_internal.h
index e4082bc7..8f95aa05 100644
--- a/src/tbb/src/tbbmalloc/tbbmalloc_internal.h
+++ b/src/tbb/src/tbbmalloc/tbbmalloc_internal.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,14 +12,10 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_tbbmalloc_internal_H
-#define __TBB_tbbmalloc_internal_H 1
+#define __TBB_tbbmalloc_internal_H
 
 
 #include "TypeDefinitions.h" /* Also includes customization layer Customize.h */
@@ -99,10 +95,19 @@ extern intptr_t memAllocKB, memHitKB;
 template<typename T>
 void suppress_unused_warning( const T& ) {}
 
+/********** Various global default constants ********/
+
+/*
+ * Default huge page size
+ */
+static const size_t HUGE_PAGE_SIZE = 2 * 1024 * 1024;
+
+/********** End of global default constatns *********/
+
 /********** Various numeric parameters controlling allocations ********/
 
 /*
- * smabSize - the size of a block for allocation of small objects,
+ * slabSize - the size of a block for allocation of small objects,
  * it must be larger than maxSegregatedObjectSize.
  */
 const uintptr_t slabSize = 16*1024;
@@ -241,7 +246,7 @@ class AllLocalCaches {
 public:
     void registerThread(TLSRemote *tls);
     void unregisterThread(TLSRemote *tls);
-    bool cleanup(ExtMemoryPool *extPool, bool cleanOnlyUnused);
+    bool cleanup(bool cleanOnlyUnused);
     void markUnused();
     void reset() { head = NULL; }
 };
@@ -275,220 +280,8 @@ class OrphanedBlocks {
     bool cleanup(Backend* backend);
 };
 
-/* cache blocks in range [MinSize; MaxSize) in bins with CacheStep
- TooLargeFactor -- when cache size treated "too large" in comparison to user data size
- OnMissFactor -- If cache miss occurred and cache was cleaned,
-                 set ageThreshold to OnMissFactor * the difference
-                 between current time and last time cache was cleaned.
- LongWaitFactor -- to detect rarely-used bins and forget about their usage history
-*/
-template<size_t MIN_SIZE, size_t MAX_SIZE, uint32_t CACHE_STEP, int TOO_LARGE,
-         int ON_MISS, int LONG_WAIT>
-struct LargeObjectCacheProps {
-    static const size_t MinSize = MIN_SIZE, MaxSize = MAX_SIZE;
-    static const uint32_t CacheStep = CACHE_STEP;
-    static const int TooLargeFactor = TOO_LARGE, OnMissFactor = ON_MISS,
-        LongWaitFactor = LONG_WAIT;
-};
-
-template<typename Props>
-class LargeObjectCacheImpl {
-private:
-    // The number of bins to cache large objects.
-    static const uint32_t numBins = (Props::MaxSize-Props::MinSize)/Props::CacheStep;
-    // Current sizes of used and cached objects. It's calculated while we are
-    // traversing bins, and used for isLOCTooLarge() check at the same time.
-    class BinsSummary {
-        size_t usedSz;
-        size_t cachedSz;
-    public:
-        BinsSummary() : usedSz(0), cachedSz(0) {}
-        // "too large" criteria
-        bool isLOCTooLarge() const { return cachedSz > Props::TooLargeFactor*usedSz; }
-        void update(size_t usedSize, size_t cachedSize) {
-            usedSz += usedSize;
-            cachedSz += cachedSize;
-        }
-        void reset() { usedSz = cachedSz = 0; }
-    };
-public:
-    typedef BitMaskMax<numBins> BinBitMask;
-
-    // 2-linked list of same-size cached blocks ordered by age (oldest on top)
-    // TODO: are we really want the list to be 2-linked? This allows us
-    // reduce memory consumption and do less operations under lock.
-    // TODO: try to switch to 32-bit logical time to save space in CacheBin
-    // and move bins to different cache lines.
-    class CacheBin {
-    private:
-        LargeMemoryBlock *first,
-                         *last;
-  /* age of an oldest block in the list; equal to last->age, if last defined,
-     used for quick cheching it without acquiring the lock. */
-        uintptr_t         oldest;
-  /* currAge when something was excluded out of list because of the age,
-     not because of cache hit */
-        uintptr_t         lastCleanedAge;
-  /* Current threshold value for the blocks of a particular size.
-     Set on cache miss. */
-        intptr_t          ageThreshold;
-
-  /* total size of all objects corresponding to the bin and allocated by user */
-        size_t            usedSize,
-  /* total size of all objects cached in the bin */
-                          cachedSize;
-  /* mean time of presence of block in the bin before successful reuse */
-        intptr_t          meanHitRange;
-  /* time of last get called for the bin */
-        uintptr_t         lastGet;
-
-        typename MallocAggregator<CacheBinOperation>::type aggregator;
-
-        void ExecuteOperation(CacheBinOperation *op, ExtMemoryPool *extMemPool, BinBitMask *bitMask, int idx, bool longLifeTime = true);
-  /* should be placed in zero-initialized memory, ctor not needed. */
-        CacheBin();
-    public:
-        void init() { memset(this, 0, sizeof(CacheBin)); }
-        void putList(ExtMemoryPool *extMemPool, LargeMemoryBlock *head, BinBitMask *bitMask, int idx);
-        LargeMemoryBlock *get(ExtMemoryPool *extMemPool, size_t size, BinBitMask *bitMask, int idx);
-        bool cleanToThreshold(ExtMemoryPool *extMemPool, BinBitMask *bitMask, uintptr_t currTime, int idx);
-        bool releaseAllToBackend(ExtMemoryPool *extMemPool, BinBitMask *bitMask, int idx);
-        void updateUsedSize(ExtMemoryPool *extMemPool, size_t size, BinBitMask *bitMask, int idx);
-
-        void decreaseThreshold() {
-            if (ageThreshold)
-                ageThreshold = (ageThreshold + meanHitRange)/2;
-        }
-        void updateBinsSummary(BinsSummary *binsSummary) const {
-            binsSummary->update(usedSize, cachedSize);
-        }
-        size_t getSize() const { return cachedSize; }
-        size_t getUsedSize() const { return usedSize; }
-        size_t reportStat(int num, FILE *f);
-  /* ---------- unsafe methods used with the aggregator ---------- */
-        void forgetOutdatedState(uintptr_t currTime);
-        LargeMemoryBlock *putList(LargeMemoryBlock *head, LargeMemoryBlock *tail, BinBitMask *bitMask, int idx, int num);
-        LargeMemoryBlock *get();
-        LargeMemoryBlock *cleanToThreshold(uintptr_t currTime, BinBitMask *bitMask, int idx);
-        LargeMemoryBlock *cleanAll(BinBitMask *bitMask, int idx);
-        void updateUsedSize(size_t size, BinBitMask *bitMask, int idx) {
-            if (!usedSize) bitMask->set(idx, true);
-            usedSize += size;
-            if (!usedSize && !first) bitMask->set(idx, false);
-        }
-        void updateMeanHitRange( intptr_t hitRange ) {
-            hitRange = hitRange >= 0 ? hitRange : 0;
-            meanHitRange = meanHitRange ? (meanHitRange + hitRange)/2 : hitRange;
-        }
-        void updateAgeThreshold( uintptr_t currTime ) {
-            if (lastCleanedAge)
-                ageThreshold = Props::OnMissFactor*(currTime - lastCleanedAge);
-        }
-        void updateCachedSize(size_t size) { cachedSize += size; }
-        void setLastGet( uintptr_t newLastGet ) { lastGet = newLastGet; }
-  /* -------------------------------------------------------- */
-    };
-private:
-    intptr_t     tooLargeLOC; // how many times LOC was "too large"
-    // for fast finding of used bins and bins with non-zero usedSize;
-    // indexed from the end, as we need largest 1st
-    BinBitMask   bitMask;
-    // bins with lists of recently freed large blocks cached for re-use
-    CacheBin bin[numBins];
-
-public:
-    static int sizeToIdx(size_t size) {
-        MALLOC_ASSERT(Props::MinSize <= size && size < Props::MaxSize, ASSERT_TEXT);
-        return (size-Props::MinSize)/Props::CacheStep;
-    }
-    static int getNumBins() { return numBins; }
-
-    void putList(ExtMemoryPool *extMemPool, LargeMemoryBlock *largeBlock);
-    LargeMemoryBlock *get(ExtMemoryPool *extMemPool, size_t size);
-
-    void updateCacheState(ExtMemoryPool *extMemPool, DecreaseOrIncrease op, size_t size);
-    bool regularCleanup(ExtMemoryPool *extMemPool, uintptr_t currAge, bool doThreshDecr);
-    bool cleanAll(ExtMemoryPool *extMemPool);
-    void reset() {
-        tooLargeLOC = 0;
-        for (int i = numBins-1; i >= 0; i--)
-            bin[i].init();
-        bitMask.reset();
-    }
-    void reportStat(FILE *f);
-#if __TBB_MALLOC_WHITEBOX_TEST
-    size_t getLOCSize() const;
-    size_t getUsedSize() const;
-#endif
-};
-
-class LargeObjectCache {
-    static const size_t minLargeSize =  8*1024,
-                        maxLargeSize =  8*1024*1024,
-    // There are benchmarks of interest that should work well with objects of this size
-                        maxHugeSize = 129*1024*1024;
-public:
-    // Difference between object sizes in large block bins
-    static const uint32_t largeBlockCacheStep =  8*1024,
-                          hugeBlockCacheStep = 512*1024;
-private:
-    typedef LargeObjectCacheProps<minLargeSize, maxLargeSize, largeBlockCacheStep, 2, 2, 16> LargeCacheTypeProps;
-    typedef LargeObjectCacheProps<maxLargeSize, maxHugeSize, hugeBlockCacheStep, 1, 1, 4> HugeCacheTypeProps;
-    typedef LargeObjectCacheImpl< LargeCacheTypeProps > LargeCacheType;
-    typedef LargeObjectCacheImpl< HugeCacheTypeProps > HugeCacheType;
-
-    // beginning of largeCache is more actively used and smaller than hugeCache,
-    // so put hugeCache first to prevent false sharing
-    // with LargeObjectCache's predecessor
-    HugeCacheType hugeCache;
-    LargeCacheType largeCache;
-
-    /* logical time, incremented on each put/get operation
-       To prevent starvation between pools, keep separately for each pool.
-       Overflow is OK, as we only want difference between
-       its current value and some recent.
-
-       Both malloc and free should increment logical time, as in
-       a different case multiple cached blocks would have same age,
-       and accuracy of predictors suffers.
-    */
-    uintptr_t cacheCurrTime;
-
-                     // memory pool that owns this LargeObjectCache,
-    ExtMemoryPool *extMemPool; // strict 1:1 relation, never changed
-
-    static int sizeToIdx(size_t size);
-public:
-    void init(ExtMemoryPool *memPool) { extMemPool = memPool; }
-    void put(LargeMemoryBlock *largeBlock);
-    void putList(LargeMemoryBlock *head);
-    LargeMemoryBlock *get(size_t size);
-
-    void updateCacheState(DecreaseOrIncrease op, size_t size);
-    bool isCleanupNeededOnRange(uintptr_t range, uintptr_t currTime);
-    bool doCleanup(uintptr_t currTime, bool doThreshDecr);
-
-    bool decreasingCleanup();
-    bool regularCleanup();
-    bool cleanAll();
-    void reset() {
-        largeCache.reset();
-        hugeCache.reset();
-    }
-    void reportStat(FILE *f);
-#if __TBB_MALLOC_WHITEBOX_TEST
-    size_t getLOCSize() const;
-    size_t getUsedSize() const;
-#endif
-    static size_t alignToBin(size_t size) {
-        return size<maxLargeSize? alignUp(size, largeBlockCacheStep)
-            : alignUp(size, hugeBlockCacheStep);
-    }
-
-    uintptr_t getCurrTime() { return (uintptr_t)AtomicIncrement((intptr_t&)cacheCurrTime); }
-    uintptr_t getCurrTimeRange(uintptr_t range) { return (uintptr_t)AtomicAdd((intptr_t&)cacheCurrTime, range)+1; }
-    void registerRealloc(size_t oldSize, size_t newSize);
-};
+/* Large objects entities */
+#include "large_objects.h"
 
 // select index size for BackRefMaster based on word size: default is uint32_t,
 // uint16_t for 32-bit platforms
@@ -511,7 +304,7 @@ class BackRefIdx { // composite index to backreference array
     uint16_t largeObj:1;  // is this object "large"?
     uint16_t offset  :15; // offset from beginning of BackRefBlock
 public:
-    BackRefIdx() : master(invalid) {}
+    BackRefIdx() : master(invalid), largeObj(0), offset(0) {}
     bool isInvalid() const { return master == invalid; }
     bool isLargeObject() const { return largeObj; }
     master_t getMaster() const { return master; }
@@ -542,337 +335,188 @@ struct LargeMemoryBlock : public BlockI {
     BackRefIdx        backRefIdx;    // cached here, used copy is in LargeObjectHdr
 };
 
-// global state of blocks currently in processing
-class BackendSync {
-    // Class instances should reside in zero-initialized memory!
-    // The number of blocks currently removed from a bin and not returned back
-    intptr_t inFlyBlocks;         // to another
-    intptr_t binsModifications;   // incremented on every bin modification
-    Backend *backend;
+// Classes and methods for backend.cpp
+#include "backend.h"
+
+// An TBB allocator mode that can be controlled by user
+// via API/environment variable. Must be placed in zero-initialized memory.
+// External synchronization assumed.
+// TODO: TBB_VERSION support
+class AllocControlledMode {
+    intptr_t val;
+    bool     setDone;
+
 public:
-    void init(Backend *b) { backend = b; }
-    void blockConsumed() { AtomicIncrement(inFlyBlocks); }
-    void binsModified() { AtomicIncrement(binsModifications); }
-    void blockReleased() {
-#if __TBB_MALLOC_BACKEND_STAT
-        MALLOC_ITT_SYNC_RELEASING(&inFlyBlocks);
-#endif
-        AtomicIncrement(binsModifications);
-        intptr_t prev = AtomicAdd(inFlyBlocks, -1);
-        MALLOC_ASSERT(prev > 0, ASSERT_TEXT);
-        suppress_unused_warning(prev);
+    intptr_t get() const {
+        MALLOC_ASSERT(setDone, ASSERT_TEXT);
+        return val;
     }
-    intptr_t getNumOfMods() const { return FencedLoad(binsModifications); }
-    // return true if need re-do the blocks search
-    inline bool waitTillBlockReleased(intptr_t startModifiedCnt);
-};
 
-class CoalRequestQ { // queue of free blocks that coalescing was delayed
-private:
-    FreeBlock   *blocksToFree;
-    BackendSync *bkndSync;
-    // counted blocks in blocksToFree and that are leaved blocksToFree
-    // and still in active coalescing
-    intptr_t     inFlyBlocks;
-public:
-    void init(BackendSync *bSync) { bkndSync = bSync; }
-    FreeBlock *getAll(); // return current list of blocks and make queue empty
-    void putBlock(FreeBlock *fBlock);
-    inline void blockWasProcessed();
-    intptr_t blocksInFly() const { return FencedLoad(inFlyBlocks); }
-};
+    // Note: set() can be called before init()
+    void set(intptr_t newVal) {
+        val = newVal;
+        setDone = true;
+    }
 
-class MemExtendingSema {
-    intptr_t     active;
-public:
-    bool wait() {
-        bool rescanBins = false;
-        // up to 3 threads can add more memory from OS simultaneously,
-        // rest of threads have to wait
-        for (;;) {
-            intptr_t prevCnt = FencedLoad(active);
-            if (prevCnt < 3) {
-                intptr_t n = AtomicCompareExchange(active, prevCnt+1, prevCnt);
-                if (n == prevCnt)
-                    break;
-            } else {
-                SpinWaitWhileEq(active, prevCnt);
-                rescanBins = true;
-                break;
-            }
-        }
-        return rescanBins;
+    bool ready() const {
+        return setDone;
     }
-    void signal() { AtomicAdd(active, -1); }
-};
 
-enum MemRegionType {
-    // The region does not guarantee the block size.
-    MEMREG_FLEXIBLE_SIZE = 0,
-    // The region can hold exact number of blocks with the size of the
-    // first reqested block.
-    MEMREG_SEVERAL_BLOCKS,
-    // The region holds only one block with a reqested size.
-    MEMREG_ONE_BLOCK
+    // envName - environment variable to get controlled mode
+    void initReadEnv(const char *envName, intptr_t defaultVal) {
+        if (!setDone) {
+#if !__TBB_WIN8UI_SUPPORT
+        // TODO: use strtol to get the actual value of the envirable
+            const char *envVal = getenv(envName);
+            if (envVal && !strcmp(envVal, "1"))
+                val = 1;
+            else
+#endif
+                val = defaultVal;
+            setDone = true;
+        }
+    }
 };
 
-class MemRegionList {
-    MallocMutex regionListLock;
-public:
-    MemRegion  *head;
-    void add(MemRegion *r);
-    void remove(MemRegion *r);
-    int reportStat(FILE *f);
+// Page type to be used inside MapMemory.
+// Regular (4KB aligned), Huge and Transparent Huge Pages (2MB aligned).
+enum PageType {
+    REGULAR = 0,
+    PREALLOCATED_HUGE_PAGE,
+    TRANSPARENT_HUGE_PAGE
 };
 
-class Backend {
+// init() and printStatus() is called only under global initialization lock.
+// Race is possible between registerAllocation() and registerReleasing(),
+// harm is that up to single huge page releasing is missed (because failure
+// to get huge page is registered only 1st time), that is negligible.
+// setMode is also can be called concurrently.
+// Object must reside in zero-initialized memory
+// TODO: can we check for huge page presence during every 10th mmap() call
+// in case huge page is released by another process?
+class HugePagesStatus {
 private:
-/* Blocks in range [minBinnedSize; getMaxBinnedSize()] are kept in bins,
-   one region can contains several blocks. Larger blocks are allocated directly
-   and one region always contains one block.
-*/
-    enum {
-        minBinnedSize = 8*1024UL,
-        /*   If huge pages are available, maxBinned_HugePage used.
-             If not, maxBinned_SmallPage is the threshold.
-             TODO: use pool's granularity for upper bound setting.*/
-        maxBinned_SmallPage = 1024*1024UL,
-        // TODO: support other page sizes
-        maxBinned_HugePage = 4*1024*1024UL
-    };
-    enum {
-        VALID_BLOCK_IN_BIN = 1 // valid block added to bin, not returned as result
-    };
-public:
-    static const int freeBinsNum =
-        (maxBinned_HugePage-minBinnedSize)/LargeObjectCache::largeBlockCacheStep + 1;
-
-    // if previous access missed per-thread slabs pool,
-    // allocate numOfSlabAllocOnMiss blocks in advance
-    static const int numOfSlabAllocOnMiss = 2;
-
-    enum {
-        NO_BIN = -1,
-        // special bin for blocks >= maxBinned_HugePage, blocks go to this bin
-        // when pool is created with keepAllMemory policy
-        // TODO: currently this bin is scanned using "1st fit", as it accumulates
-        // blocks of different sizes, "best fit" is preferred in terms of fragmentation
-        HUGE_BIN = freeBinsNum-1
-    };
-
-    // Bin keeps 2-linked list of free blocks. It must be 2-linked
-    // because during coalescing a block it's removed from a middle of the list.
-    struct Bin {
-        FreeBlock   *head,
-                    *tail;
-        MallocMutex  tLock;
-
-        void removeBlock(FreeBlock *fBlock);
-        void reset() { head = tail = 0; }
-        bool empty() const { return !head; }
-
-        size_t countFreeBlocks();
-        size_t reportFreeBlocks(FILE *f);
-        void reportStat(FILE *f);
-    };
-
-    typedef BitMaskMin<Backend::freeBinsNum> BitMaskBins;
-
-    // array of bins supplemented with bitmask for fast finding of non-empty bins
-    class IndexedBins {
-        BitMaskBins bitMask;
-        Bin         freeBins[Backend::freeBinsNum];
-        FreeBlock *getFromBin(int binIdx, BackendSync *sync, size_t size,
-                              bool resSlabAligned, bool alignedBin, bool wait,
-                              int *resLocked);
-    public:
-        FreeBlock *findBlock(int nativeBin, BackendSync *sync, size_t size,
-                             bool resSlabAligned, bool alignedBin, int *numOfLockedBins);
-        bool tryReleaseRegions(int binIdx, Backend *backend);
-        void lockRemoveBlock(int binIdx, FreeBlock *fBlock);
-        void addBlock(int binIdx, FreeBlock *fBlock, size_t blockSz, bool addToTail);
-        bool tryAddBlock(int binIdx, FreeBlock *fBlock, bool addToTail);
-        int getMinNonemptyBin(unsigned startBin) const {
-            int p = bitMask.getMinTrue(startBin);
-            return p == -1 ? Backend::freeBinsNum : p;
+    AllocControlledMode requestedMode; // changed only by user
+                                       // to keep enabled and requestedMode consistent
+    MallocMutex setModeLock;
+    size_t      pageSize;
+    intptr_t    needActualStatusPrint;
+
+    static void doPrintStatus(bool state, const char *stateName) {
+        // Under macOS* fprintf/snprintf acquires an internal lock, so when
+        // 1st allocation is done under the lock, we got a deadlock.
+        // Do not use fprintf etc during initialization.
+        fputs("TBBmalloc: huge pages\t", stderr);
+        if (!state)
+            fputs("not ", stderr);
+        fputs(stateName, stderr);
+        fputs("\n", stderr);
+    }
+
+    void parseSystemMemInfo() {
+        bool hpAvailable  = false;
+        bool thpAvailable = false;
+        unsigned long long hugePageSize = 0;
+
+#if __linux__
+        // Check huge pages existence
+        unsigned long long meminfoHugePagesTotal = 0;
+
+        parseFileItem meminfoItems[] = {
+            // Parse system huge page size
+            { "Hugepagesize: %llu kB", hugePageSize },
+            // Check if there are preallocated huge pages on the system
+            // https://www.kernel.org/doc/Documentation/vm/hugetlbpage.txt
+            { "HugePages_Total: %llu", meminfoHugePagesTotal } };
+
+        parseFile</*BUFF_SIZE=*/100>("/proc/meminfo", meminfoItems);
+
+        // Double check another system information regarding preallocated
+        // huge pages if there are no information in /proc/meminfo
+        unsigned long long vmHugePagesTotal = 0;
+
+        parseFileItem vmItem[] = { { "%llu", vmHugePagesTotal } };
+
+        // We parse a counter number, it can't be huge
+        parseFile</*BUFF_SIZE=*/100>("/proc/sys/vm/nr_hugepages", vmItem);
+
+        if (meminfoHugePagesTotal > 0 || vmHugePagesTotal > 0) {
+            MALLOC_ASSERT(hugePageSize != 0, "Huge Page size can't be zero if we found preallocated.");
+
+            // Any non zero value clearly states that there are preallocated
+            // huge pages on the system
+            hpAvailable = true;
         }
-        void verify();
-        void reset();
-        void reportStat(FILE *f);
-    };
 
-private:
-    class AdvRegionsBins {
-        BitMaskBins bins;
-    public:
-        void registerBin(int regBin) { bins.set(regBin, 1); }
-        int getMinUsedBin(int start) const { return bins.getMinTrue(start); }
-        void reset() { bins.reset(); }
-    };
-    // auxiliary class to atomic maximum request finding
-    class MaxRequestComparator {
-        const Backend *backend;
-    public:
-        MaxRequestComparator(const Backend *be) : backend(be) {}
-        inline bool operator()(size_t oldMaxReq, size_t requestSize) const;
-    };
-
-#if CHECK_ALLOCATION_RANGE
-    // Keep min and max of all addresses requested from OS,
-    // use it for checking memory possibly allocated by replaced allocators
-    // and for debugging purposes. Valid only for default memory pool.
-    class UsedAddressRange {
-        static const uintptr_t ADDRESS_UPPER_BOUND = UINTPTR_MAX;
-
-        uintptr_t   leftBound,
-                    rightBound;
-        MallocMutex mutex;
-    public:
-        // rightBound is zero-initialized
-        void init() { leftBound = ADDRESS_UPPER_BOUND; }
-        void registerAlloc(uintptr_t left, uintptr_t right);
-        void registerFree(uintptr_t left, uintptr_t right);
-        // as only left and right bounds are kept, we can return true
-        // for pointer not allocated by us, if more than single region
-        // was requested from OS
-        bool inRange(void *ptr) const {
-            const uintptr_t p = (uintptr_t)ptr;
-            return leftBound<=p && p<=rightBound;
+        // Check if there is transparent huge pages support on the system
+        unsigned long long thpPresent = 'n';
+        parseFileItem thpItem[] = { { "[alwa%cs] madvise never\n", thpPresent } };
+        parseFile</*BUFF_SIZE=*/100>("/sys/kernel/mm/transparent_hugepage/enabled", thpItem);
+
+        if (thpPresent == 'y') {
+            MALLOC_ASSERT(hugePageSize != 0, "Huge Page size can't be zero if we found thp existence.");
+            thpAvailable = true;
         }
-    };
-#else
-    class UsedAddressRange {
-    public:
-        void init() { }
-        void registerAlloc(uintptr_t, uintptr_t) {}
-        void registerFree(uintptr_t, uintptr_t) {}
-        bool inRange(void *) const { return true; }
-    };
 #endif
+        MALLOC_ASSERT(!pageSize, "Huge page size can't be set twice. Double initialization.");
 
-    ExtMemoryPool   *extMemPool;
-    // used for release every region on pool destroying
-    MemRegionList    regionList;
-
-    CoalRequestQ     coalescQ; // queue of coalescing requests
-    BackendSync      bkndSync;
-    // semaphore protecting adding more more memory from OS
-    MemExtendingSema memExtendingSema;
-    size_t           totalMemSize,
-                     memSoftLimit;
-    UsedAddressRange usedAddrRange;
-    // to keep 1st allocation large than requested, keep bootstrapping status
-    enum {
-        bootsrapMemNotDone = 0,
-        bootsrapMemInitializing,
-        bootsrapMemDone
-    };
-    intptr_t         bootsrapMemStatus;
-    MallocMutex      bootsrapMemStatusMutex;
-
-    // Using of maximal observed requested size allows decrease
-    // memory consumption for small requests and decrease fragmentation
-    // for workloads when small and large allocation requests are mixed.
-    // TODO: decrease, not only increase it
-    size_t           maxRequestedSize;
-
-    FreeBlock *addNewRegion(size_t size, MemRegionType type, bool addToBin);
-    FreeBlock *findBlockInRegion(MemRegion *region, size_t exactBlockSize);
-    void startUseBlock(MemRegion *region, FreeBlock *fBlock, bool addToBin);
-    void releaseRegion(MemRegion *region);
-
-    FreeBlock *releaseMemInCaches(intptr_t startModifiedCnt,
-                                  int *lockedBinsThreshold, int numOfLockedBins);
-    void requestBootstrapMem();
-    FreeBlock *askMemFromOS(size_t totalReqSize, intptr_t startModifiedCnt,
-                            int *lockedBinsThreshold, int numOfLockedBins,
-                            bool *splittable);
-    FreeBlock *genericGetBlock(int num, size_t size, bool resSlabAligned);
-    void genericPutBlock(FreeBlock *fBlock, size_t blockSz);
-    FreeBlock *splitUnalignedBlock(FreeBlock *fBlock, int num, size_t size,
-                              bool needAlignedRes);
-    FreeBlock *splitAlignedBlock(FreeBlock *fBlock, int num, size_t size,
-                            bool needAlignedRes);
-
-    FreeBlock *doCoalesc(FreeBlock *fBlock, MemRegion **memRegion);
-    bool coalescAndPutList(FreeBlock *head, bool forceCoalescQDrop, bool reportBlocksProcessed);
-    void coalescAndPut(FreeBlock *fBlock, size_t blockSz);
-
-    void removeBlockFromBin(FreeBlock *fBlock);
-
-    void *allocRawMem(size_t &size);
-    bool freeRawMem(void *object, size_t size);
-
-    void putLargeBlock(LargeMemoryBlock *lmb);
-    void releaseCachesToLimit();
-public:
-    bool scanCoalescQ(bool forceCoalescQDrop);
-    intptr_t blocksInCoalescing() const { return coalescQ.blocksInFly(); }
-    void verify();
-    void init(ExtMemoryPool *extMemoryPool);
-    void reset();
-    bool destroy();
-    bool clean(); // clean on caches cleanup
-    void reportStat(FILE *f);
-
-    BlockI *getSlabBlock(int num) {
-        BlockI *b = (BlockI*)
-            genericGetBlock(num, slabSize, /*resSlabAligned=*/true);
-        MALLOC_ASSERT(isAligned(b, slabSize), ASSERT_TEXT);
-        return b;
+        // Initialize object variables
+        pageSize       = hugePageSize * 1024; // was read in KB from meminfo
+        isHPAvailable  = hpAvailable;
+        isTHPAvailable = thpAvailable;
     }
-    void putSlabBlock(BlockI *block) {
-        genericPutBlock((FreeBlock *)block, slabSize);
-    }
-    void *getBackRefSpace(size_t size, bool *rawMemUsed);
-    void putBackRefSpace(void *b, size_t size, bool rawMemUsed);
 
-    bool inUserPool() const;
+public:
 
-    LargeMemoryBlock *getLargeBlock(size_t size);
-    void returnLargeObject(LargeMemoryBlock *lmb);
+    // System information
+    bool isHPAvailable;
+    bool isTHPAvailable;
 
-    void *remap(void *ptr, size_t oldSize, size_t newSize, size_t alignment);
+    // User defined value
+    bool isEnabled;
 
-    void setRecommendedMaxSize(size_t softLimit) {
-        memSoftLimit = softLimit;
-        releaseCachesToLimit();
+    void init() {
+        parseSystemMemInfo();
+        MallocMutex::scoped_lock lock(setModeLock);
+        requestedMode.initReadEnv("TBB_MALLOC_USE_HUGE_PAGES", 0);
+        isEnabled = (isHPAvailable || isTHPAvailable) && requestedMode.get();
     }
-    inline size_t getMaxBinnedSize() const;
-
-    bool ptrCanBeValid(void *ptr) const { return usedAddrRange.inRange(ptr); }
-
-#if __TBB_MALLOC_WHITEBOX_TEST
-    size_t getTotalMemSize() const { return totalMemSize; }
-#endif
-private:
-    static int sizeToBin(size_t size) {
-        if (size >= maxBinned_HugePage)
-            return HUGE_BIN;
-        else if (size < minBinnedSize)
-            return NO_BIN;
 
-        int bin = (size - minBinnedSize)/LargeObjectCache::largeBlockCacheStep;
+    // Could be set from user code at any place.
+    // If we didn't call init() at this place, isEnabled will be false
+    void setMode(intptr_t newVal) {
+        MallocMutex::scoped_lock lock(setModeLock);
+        requestedMode.set(newVal);
+        isEnabled = (isHPAvailable || isTHPAvailable) && newVal;
+    }
 
-        MALLOC_ASSERT(bin < HUGE_BIN, "Invalid size.");
-        return bin;
+    bool isRequested() const {
+        return requestedMode.ready() ? requestedMode.get() : false;
     }
-#if __TBB_MALLOC_BACKEND_STAT
-    static size_t binToSize(int bin) {
-        MALLOC_ASSERT(bin <= HUGE_BIN, "Invalid bin.");
 
-        return bin*LargeObjectCache::largeBlockCacheStep + minBinnedSize;
+    void reset() {
+        pageSize = needActualStatusPrint = 0;
+        isEnabled = isHPAvailable = isTHPAvailable = false;
     }
-#endif
-    static bool toAlignedBin(FreeBlock *block, size_t size) {
-        return isAligned((char*)block+size, slabSize)
-            && size >= slabSize;
+
+    // If memory mapping size is a multiple of huge page size, some OS kernels
+    // can use huge pages transparently. Use this when huge pages are requested.
+    size_t getGranularity() const {
+        if (requestedMode.ready())
+            return requestedMode.get() ? pageSize : 0;
+        else
+            return HUGE_PAGE_SIZE; // the mode is not yet known; assume typical 2MB huge pages
     }
 
-    // register bins related to advance regions
-    AdvRegionsBins advRegBins;
-    IndexedBins freeLargeBins,
-                freeAlignedBins;
+    void printStatus() {
+        doPrintStatus(requestedMode.get(), "requested");
+        if (requestedMode.get()) { // report actual status iff requested
+            if (pageSize)
+                FencedStore(needActualStatusPrint, 1);
+            else
+                doPrintStatus(/*state=*/false, "available");
+        }
+    }
 };
 
 class AllLargeBlocksList {
@@ -963,86 +607,6 @@ struct FreeObject {
     FreeObject  *next;
 };
 
-// An TBB allocator mode that can be controlled by user
-// via API/environment variable. Must be placed in zero-initialized memory.
-// External synchronization assumed.
-// TODO: TBB_VERSION support
-class AllocControlledMode {
-    intptr_t val;
-    bool     setDone;
-public:
-    bool ready() const { return setDone; }
-    intptr_t get() const {
-        MALLOC_ASSERT(setDone, ASSERT_TEXT);
-        return val;
-    }
-    void set(intptr_t newVal) { // note set() can be called before init()
-        val = newVal;
-        setDone = true;
-    }
-    // envName - environment variable to get controlled mode
-    void initReadEnv(const char *envName, intptr_t defaultVal);
-};
-
-// init() and printStatus() is called only under global initialization lock.
-// Race is possible between registerAllocation() and registerReleasing(),
-// harm is that up to single huge page releasing is missed (because failure
-// to get huge page is registered only 1st time), that is negligible.
-// setMode is also can be called concurrently.
-// Object must reside in zero-initialized memory
-// TODO: can we check for huge page presence during every 10th mmap() call
-// in case huge page is released by another process?
-class HugePagesStatus {
-private:
-    AllocControlledMode requestedMode; // changed only by user
-               // to keep enabled and requestedMode consistent
-    MallocMutex setModeLock;
-    size_t      pageSize;
-    intptr_t    needActualStatusPrint;
-
-    static void doPrintStatus(bool state, const char *stateName);
-public:
-    // both variables are changed only inside HugePagesStatus
-    intptr_t    enabled;
-    // Have we got huge pages at all? It's used when large hugepage-aligned
-    // region is releasing, to find can it release some huge pages or not.
-    intptr_t    wasObserved;
-
-    // If memory mapping size is a multiple of huge page size, some OS kernels
-    // can use huge pages transparently (i.e. even if not explicitly enabled).
-    // Use this when huge pages are requested.
-    size_t recommendedGranularity() const {
-        if (requestedMode.ready())
-            return requestedMode.get()? pageSize : 0;
-        else
-            return 2048*1024; // the mode is not yet known; assume typical 2MB huge pages
-    }
-    void printStatus();
-    void registerAllocation(bool available);
-    void registerReleasing(void* addr, size_t size);
-
-    void init(size_t hugePageSize) {
-        MALLOC_ASSERT(!hugePageSize || isPowerOfTwo(hugePageSize),
-                      "Only memory pages of a power-of-two size are supported.");
-        MALLOC_ASSERT(!pageSize, "Huge page size can't be set twice.");
-        pageSize = hugePageSize;
-
-        MallocMutex::scoped_lock lock(setModeLock);
-        requestedMode.initReadEnv("TBB_MALLOC_USE_HUGE_PAGES", 0);
-        enabled = pageSize && requestedMode.get();
-    }
-    void setMode(intptr_t newVal) {
-        MallocMutex::scoped_lock lock(setModeLock);
-        requestedMode.set(newVal);
-        enabled = pageSize && newVal;
-    }
-    void reset() {
-        pageSize = 0;
-        needActualStatusPrint = enabled = wasObserved = 0;
-    }
-};
-
-extern HugePagesStatus hugePages;
 
 /******* A helper class to support overriding malloc with scalable_malloc *******/
 #if MALLOC_CHECK_RECURSION
diff --git a/src/tbb/src/tbbmalloc/tbbmalloc_internal_api.h b/src/tbb/src/tbbmalloc/tbbmalloc_internal_api.h
index 301c9f59..0f0803c3 100644
--- a/src/tbb/src/tbbmalloc/tbbmalloc_internal_api.h
+++ b/src/tbb/src/tbbmalloc/tbbmalloc_internal_api.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 #ifndef __TBB_tbbmalloc_internal_api_H
@@ -32,7 +28,7 @@ typedef enum {
 } AllocationModeInternalParam;
 
 void MallocInitializeITT();
-void __TBB_mallocProcessShutdownNotification();
+void __TBB_mallocProcessShutdownNotification(bool);
 #if _WIN32||_WIN64
 void __TBB_mallocThreadShutdownNotification();
 #endif
diff --git a/src/tbb/src/tbbmalloc/win32-gcc-tbbmalloc-export.def b/src/tbb/src/tbbmalloc/win32-gcc-tbbmalloc-export.def
index f2ca7f31..9c3a2c82 100644
--- a/src/tbb/src/tbbmalloc/win32-gcc-tbbmalloc-export.def
+++ b/src/tbb/src/tbbmalloc/win32-gcc-tbbmalloc-export.def
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 {
@@ -47,6 +43,7 @@ _ZN3rml12pool_reallocEPNS_10MemoryPoolEPvj;
 _ZN3rml20pool_aligned_reallocEPNS_10MemoryPoolEPvjj;
 _ZN3rml19pool_aligned_mallocEPNS_10MemoryPoolEjj;
 _ZN3rml13pool_identifyEPv;
+_ZN3rml10pool_msizeEPNS_10MemoryPoolEPv;
 
 local:*;
 };
diff --git a/src/tbb/src/tbbmalloc/win32-tbbmalloc-export.def b/src/tbb/src/tbbmalloc/win32-tbbmalloc-export.def
index f02c208b..29fd4ac7 100644
--- a/src/tbb/src/tbbmalloc/win32-tbbmalloc-export.def
+++ b/src/tbb/src/tbbmalloc/win32-tbbmalloc-export.def
@@ -1,4 +1,4 @@
-; Copyright (c) 2005-2017 Intel Corporation
+; Copyright (c) 2005-2020 Intel Corporation
 ;
 ; Licensed under the Apache License, Version 2.0 (the "License");
 ; you may not use this file except in compliance with the License.
@@ -11,10 +11,6 @@
 ; 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.
-;
-;
-;
-;
 
 EXPORTS
 
@@ -45,3 +41,5 @@ __TBB_malloc_safer_aligned_realloc
 ?pool_aligned_realloc@rml@@YAPAXPAVMemoryPool@1@PAXII@Z
 ?pool_aligned_malloc@rml@@YAPAXPAVMemoryPool@1@II@Z
 ?pool_identify@rml@@YAPAVMemoryPool@1@PAX@Z
+?pool_msize@rml@@YAIPAVMemoryPool@1@PAX@Z
+
diff --git a/src/tbb/src/tbbmalloc/win64-gcc-tbbmalloc-export.def b/src/tbb/src/tbbmalloc/win64-gcc-tbbmalloc-export.def
index d399b96d..caf162d3 100644
--- a/src/tbb/src/tbbmalloc/win64-gcc-tbbmalloc-export.def
+++ b/src/tbb/src/tbbmalloc/win64-gcc-tbbmalloc-export.def
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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.
-
-
-
-
 */
 
 {
@@ -47,6 +43,7 @@ _ZN3rml12pool_reallocEPNS_10MemoryPoolEPvy;
 _ZN3rml20pool_aligned_reallocEPNS_10MemoryPoolEPvyy;
 _ZN3rml19pool_aligned_mallocEPNS_10MemoryPoolEyy;
 _ZN3rml13pool_identifyEPv;
+_ZN3rml10pool_msizeEPNS_10MemoryPoolEPv;
 
 local:*;
 };
diff --git a/src/tbb/src/tbbmalloc/win64-tbbmalloc-export.def b/src/tbb/src/tbbmalloc/win64-tbbmalloc-export.def
index 0e335a49..aba13bdc 100644
--- a/src/tbb/src/tbbmalloc/win64-tbbmalloc-export.def
+++ b/src/tbb/src/tbbmalloc/win64-tbbmalloc-export.def
@@ -1,4 +1,4 @@
-; Copyright (c) 2005-2017 Intel Corporation
+; Copyright (c) 2005-2020 Intel Corporation
 ;
 ; Licensed under the Apache License, Version 2.0 (the "License");
 ; you may not use this file except in compliance with the License.
@@ -11,10 +11,6 @@
 ; 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.
-;
-;
-;
-;
 
 EXPORTS
 
@@ -46,3 +42,5 @@ __TBB_malloc_safer_aligned_realloc
 ?pool_aligned_realloc@rml@@YAPEAXPEAVMemoryPool@1@PEAX_K2@Z
 ?pool_aligned_malloc@rml@@YAPEAXPEAVMemoryPool@1@_K1@Z
 ?pool_identify@rml@@YAPEAVMemoryPool@1@PEAX@Z
+?pool_msize@rml@@YA_KPEAVMemoryPool@1@PEAX@Z
+
diff --git a/src/tbb/src/tbbproxy/tbbproxy-windows.asm b/src/tbb/src/tbbproxy/tbbproxy-windows.asm
index d5affed9..a751a74d 100644
--- a/src/tbb/src/tbbproxy/tbbproxy-windows.asm
+++ b/src/tbb/src/tbbproxy/tbbproxy-windows.asm
@@ -1,4 +1,4 @@
-; Copyright (c) 2005-2017 Intel Corporation
+; Copyright (c) 2005-2020 Intel Corporation
 ;
 ; Licensed under the Apache License, Version 2.0 (the "License");
 ; you may not use this file except in compliance with the License.
@@ -11,10 +11,6 @@
 ; 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.
-;
-;
-;
-;
 
 // __TBB_STRING macro defined in "tbb_stddef.h". However, we cannot include "tbb_stddef.h"
 // because it contains a lot of C/C++ definitions. So, we have to define __TBB_STRING here:
diff --git a/src/tbb/src/tbbproxy/tbbproxy.cpp b/src/tbb/src/tbbproxy/tbbproxy.cpp
index 0e57ab71..8d3b4c9d 100644
--- a/src/tbb/src/tbbproxy/tbbproxy.cpp
+++ b/src/tbb/src/tbbproxy/tbbproxy.cpp
@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2017 Intel Corporation
+    Copyright (c) 2005-2020 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -12,10 +12,6 @@
     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 "tbb/tbb_config.h"
@@ -23,6 +19,7 @@
 #define TBB_PREVIEW_RUNTIME_LOADER 1
 #include "tbb/runtime_loader.h"
 #include "tbb/tbb_stddef.h"
+#include "tbb_environment.h"
 
 // C standard headers.
 #include <cctype>            // isspace
@@ -109,8 +106,7 @@ static void _say( char const * format, va_list args ) {
 // To enable printing, the variable must be set and not empty.
 // Do not call it directly, use tell() instead.
 static void _tell( char const * format, va_list args ) {
-    char const * var = getenv( "TBB_VERSION" );
-    if ( var != NULL && var[ 0 ] != 0 ) {
+    if ( tbb::internal::GetBoolEnvironmentVariable("TBB_VERSION") ) {
         _say( format, args );
     } // if
 } // _tell
@@ -352,7 +348,7 @@ static tbb::runtime_loader::error_code _load( char const * dll_name, int min_ver
     tbb::runtime_loader::error_code code = tbb::runtime_loader::ec_ok;
 
     /*
-        If these variables declared at the first usage, Intel C++ Compiler may issue warning(s):
+        If these variables declared at the first usage, Intel(R) C++ Compiler may issue warning(s):
             transfer of control [goto error] bypasses initialization of: ...
         Declaring variables at the beginning of the function eliminates warnings.
     */
diff --git a/src/tbb/third-party-programs.txt b/src/tbb/third-party-programs.txt
new file mode 100644
index 00000000..7360813b
--- /dev/null
+++ b/src/tbb/third-party-programs.txt
@@ -0,0 +1,230 @@
+Intel(R) Threading Building Blocks Third Party Programs File
+
+This file contains the list of third party software ("third party programs")
+contained in the Intel software and their required notices and/or license terms.
+This third party software, even if included with the distribution of the Intel
+software, may be governed by separate license terms, including without limitation,
+third party license terms, other Intel software license terms, and open source
+software license terms. These separate license terms govern your use of the third
+party programs as set forth in the "third-party-programs.txt" or other similarly named text file.
+
+Third party programs and their corresponding required notices and/or license
+terms are listed below.
+____________________________________________________________________________________________________
+
+1.  Portable Hardware Locality (hwloc):
+    Copyright (c) 2004-2006 The Trustees of Indiana University and Indiana University Research and Technology Corporation.  All rights reserved.
+    Copyright (c) 2004-2005 The University of Tennessee and The University of Tennessee Research Foundation.  All rights reserved.
+    Copyright (c) 2004-2005 High Performance Computing Center Stuttgart, University of Stuttgart.  All rights reserved.
+    Copyright (c) 2004-2005 The Regents of the University of California. All rights reserved.
+    Copyright (c) 2009      CNRS
+    Copyright (c) 2009-2016 Inria.  All rights reserved.
+    Copyright (c) 2009-2015 Universite Bordeaux
+    Copyright (c) 2009-2015 Cisco Systems, Inc.  All rights reserved.
+    Copyright (c) 2009-2012 Oracle and/or its affiliates.  All rights reserved.
+    Copyright (c) 2010      IBM
+    Copyright (c) 2010      Jirka Hladky
+    Copyright (c) 2012      Aleksej Saushev, The NetBSD Foundation
+    Copyright (c) 2012      Blue Brain Project, EPFL. All rights reserved.
+    Copyright (c) 2013-2014 University of Wisconsin-La Crosse. All rights reserved.
+    Copyright (c) 2015      Research Organization for Information Science and Technology (RIST). All rights reserved.
+    Copyright (c) 2015-2016 Intel, Inc.  All rights reserved.
+    See COPYING in top-level directory.
+
+    New BSD License
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions
+    are met:
+    1. Redistributions of source code must retain the above copyright
+       notice, this list of conditions and the following disclaimer.
+    2. Redistributions in binary form must reproduce the above copyright
+       notice, this list of conditions and the following disclaimer in the
+       documentation and/or other materials provided with the distribution.
+    3. The name of the author may not be used to endorse or promote products
+       derived from this software without specific prior written permission.
+
+    THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+    IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+    OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+    IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+    INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+    NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+    THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+_______________________________________________________________________________________________________
+
+2.  Instrumentation and Tracing Technology (ITT) Notify User API:
+    Copyright (c) 2005-2014 Intel Corporation. All rights reserved.
+
+    The 3-Clause BSD License
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions
+    are met:
+
+      * Redistributions of source code must retain the above copyright
+        notice, this list of conditions and the following disclaimer.
+      * Redistributions in binary form must reproduce the above copyright
+        notice, this list of conditions and the following disclaimer in
+        the documentation and/or other materials provided with the
+        distribution.
+      * Neither the name of Intel Corporation nor the names of its
+        contributors may be used to endorse or promote products derived
+        from this software without specific prior written permission.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+    OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+    LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+_______________________________________________________________________________________________________
+
+3.  ActiveState Thread pool with same API as (multi)  processing.Pool (Python recipe):
+    Copyright (c) 2008,2016 david decotigny (this file)
+    Copyright (c) 2006-2008, R Oudkerk (multiprocessing.Pool)
+
+    BSD 3-clause "New" or "Revised" License
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions
+    are met:
+
+    1. Redistributions of source code must retain the above copyright
+       notice, this list of conditions and the following disclaimer.
+    2. Redistributions in binary form must reproduce the above copyright
+       notice, this list of conditions and the following disclaimer in the
+       documentation and/or other materials provided with the distribution.
+    3. Neither the name of author nor the names of any contributors may be
+       used to endorse or promote products derived from this software
+       without specific prior written permission.
+
+    THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS "AS IS" AND
+    ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+    ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+    FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+    DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+    OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+    HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+    LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+    OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+    SUCH DAMAGE.
+_______________________________________________________________________________________________________
+
+4.  gperftools: Copyright (c) 2011, Google Inc.
+
+    Tachyon: Copyright (c) 1994-2008 John E. Stone. All rights reserved.
+
+    BSD 3-Clause "New" or "Revised" License
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions are
+    met:
+
+        * Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+        * Redistributions in binary form must reproduce the above
+    copyright notice, this list of conditions and the following disclaimer
+    in the documentation and/or other materials provided with the
+    distribution.
+        * Neither the name of Google Inc. nor the names of its
+    contributors may be used to endorse or promote products derived from
+    this software without specific prior written permission.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+    OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+    LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+_______________________________________________________________________________________________________
+
+5.  Mateusz Kwiatkowski Workaround for bug 62258 in libstdc++
+
+    Public domain
+_______________________________________________________________________________________________________
+
+6.  Bzip2: Copyright (c) 1996-2019 Julian Seward.
+
+    Bzip 2 License
+
+    This program, bzip2, the associated library libbzip2, and all documentation, are copyright (c) 1996-2019 Julian Seward. All rights reserved.
+
+    Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+    Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+    The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+
+    Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+
+    The name of the author may not be used to endorse or promote products derived from this software without specific prior written permission.
+
+    THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+_______________________________________________________________________________________________________
+
+7.  Apple OpenGL Image Sample Source Code
+
+    Apple License
+
+    ("Apple") in consideration of your agreement to the following terms, and your use, installation, modification or redistribution of this Apple software constitutes acceptance of these terms. If you do not agree with these terms, please do not use, install, modify or redistribute this Apple software.
+
+    In consideration of your agreement to abide by the following terms, and subject to these terms, Apple grants you a personal, non-exclusive license, under Apple's copyrights in this original Apple software (the "Apple Software"), to use, reproduce, modify and redistribute the Apple Software, with or without modifications, in source and/or binary forms; provided that if you redistribute the Apple Software in its entirety and without modifications, you must retain this notice and the following text and disclaimers in all such redistributions of the Apple Software. Neither the name, trademarks, service marks or logos of Apple Computer, Inc. may be used to endorse or promote products derived from the Apple Software without specific prior written permission from Apple.Except as expressly stated in this notice, no other rights or licenses, express or implied, are granted by Apple herein, including but not limited to any patent rights that may be infringed by your derivative works or by other works in which the Apple Software may be incorporated.
+
+    The Apple Software is provided by Apple on an "AS IS" basis. APPLE MAKES NO WARRANTIES, EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION THE IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, REGARDING THE APPLE SOFTWARE OR ITS USE AND OPERATION ALONE OR IN COMBINATION WITH YOUR PRODUCTS.
+
+    IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ARISING IN ANY WAY OUT OF THE USE, REPRODUCTION, MODIFICATION AND/OR DISTRIBUTION OF THE APPLE SOFTWARE, HOWEVER CAUSED AND WHETHER UNDER THEORY OF CONTRACT, TORT (INCLUDING NEGLIGENCE), STRICT LIABILITY OR OTHERWISE, EVEN IF APPLE HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+_______________________________________________________________________________________________________
+
+8.  LodePNG: Copyright (c) 2005-2019 by Lode Vandevenne.
+    
+    zlib License
+
+    This software is provided 'as-is', without any express or implied
+    warranty. In no event will the authors be held liable for any damages
+    arising from the use of this software.
+
+    Permission is granted to anyone to use this software for any purpose,
+    including commercial applications, and to alter it and redistribute it
+    freely, subject to the following restrictions:
+
+        1. The origin of this software must not be misrepresented; you must not
+        claim that you wrote the original software. If you use this software
+        in a product, an acknowledgment in the product documentation would be
+        appreciated but is not required.
+
+        2. Altered source versions must be plainly marked as such, and must not be
+        misrepresented as being the original software.
+
+        3. This notice may not be removed or altered from any source
+        distribution.
+_______________________________________________________________________________________________________
+
+9.  prism: Copyright (c) 2012-2013 Lea Verou.
+    
+    jquery: Copyright (c) 2005, 2014 jQuery Foundation, Inc.
+
+    MIT License
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+_______________________________________________________________________________________________________
+
+*Other names and brands may be claimed as the property of others.
diff --git a/tools/config/configure.R b/tools/config/configure.R
index 7001db32..a4d6cc50 100644
--- a/tools/config/configure.R
+++ b/tools/config/configure.R
@@ -25,7 +25,7 @@ if (broken)
 # RcppParallel to find and use a version of libtbb installed
 # there as opposed to the bundled version
 cppflags <- read_r_config("CPPFLAGS", envir = NULL)[[1]]
-cppflags <- sub("(?: )?-I/usr/local/include", "", cppflags)
+cppflags <- sub(" -I/usr/local/include", "", cppflags)
 
 # define the set of flags appropriate to the current
 # configuration of R
diff --git a/tools/tbb-patch.R b/tools/tbb-patch.R
new file mode 100644
index 00000000..8b137891
--- /dev/null
+++ b/tools/tbb-patch.R
@@ -0,0 +1 @@
+
diff --git a/tools/tbb-update.R b/tools/tbb-update.R
new file mode 100644
index 00000000..59fdf81d
--- /dev/null
+++ b/tools/tbb-update.R
@@ -0,0 +1,27 @@
+
+URL <- "https://github.com/intel/tbb/archive/v2020.1.tar.gz"
+archive <- basename(URL)
+
+# download and unpack tbb
+owd <- setwd(tempdir())
+download.file(URL, archive)
+before <- list.files()
+untar(archive)
+after <- list.files()
+tbb <- normalizePath(setdiff(after, before), winslash = "/", mustWork = TRUE)
+setwd(owd)
+
+# copy to src/tbb
+system2("cp", c("-R", shQuote(tbb), "src/tbb"))
+unlink("src/tbb", recursive = TRUE)
+file.copy(tbb, "src", recursive = TRUE)
+
+# copy header files
+unlink("inst/include/tbb", recursive = TRUE)
+tbbInclude <- paste(tbb, "include/", sep = "/")
+args <- c("-R", shQuote(tbbInclude), "inst/include")
+system2("cp", args)
+
+# remove examples
+unlink("src/tbb/examples")
+