[CPU] Setting parallel to tbb static partitioner or tbb auto partitoner by thread pool

cmake/dependencies.cmake

@@ -71,7 +71,7 @@ unset(_ov_download_tbb_done CACHE)
 # or ENABLE_SYSTEM_TBB is OFF
 #
 function(ov_download_tbb)
-    if(_ov_download_tbb_done OR NOT THREADING MATCHES "^(TBB|TBB_AUTO)$")
+    if(_ov_download_tbb_done OR NOT THREADING MATCHES "^(TBB|TBB_AUTO|TBB_PARTITIONER_AUTO)$")
         return()
     endif()
     set(_ov_download_tbb_done ON CACHE INTERNAL "Whether prebuilt TBB is already downloaded")

cmake/features.cmake

@@ -85,10 +85,10 @@ if(ANDROID)
 elseif(RISCV64)
     set(THREADING_DEFAULT "OMP")
 else()
-    set(THREADING_DEFAULT "TBB")
+    set(THREADING_DEFAULT "TBB_PARTITIONER_AUTO")
 endif()
 
-set(THREADING_OPTIONS "TBB" "TBB_AUTO" "SEQ" "OMP")
+set(THREADING_OPTIONS "TBB" "TBB_AUTO" "SEQ" "OMP" "TBB_PARTITIONER_AUTO")
 
 set(THREADING "${THREADING_DEFAULT}" CACHE STRING "Threading")
 set_property(CACHE THREADING PROPERTY STRINGS ${THREADING_OPTIONS})
@@ -106,7 +106,7 @@ endif()
 
 ov_dependent_option (ENABLE_INTEL_OPENMP "Enables usage of Intel OpenMP instead of default compiler one" ${ENABLE_INTEL_OPENMP_DEFAULT} "THREADING STREQUAL OMP" OFF)
 
-if((THREADING STREQUAL "TBB" OR THREADING STREQUAL "TBB_AUTO") AND
+if((THREADING STREQUAL "TBB" OR THREADING STREQUAL "TBB_AUTO" OR THREADING STREQUAL "TBB_PARTITIONER_AUTO") AND
     (BUILD_SHARED_LIBS OR (LINUX AND X86_64)))
     set(ENABLE_TBBBIND_2_5_DEFAULT ON)
 else()

cmake/templates/OpenVINOConfig.cmake.in

@@ -169,7 +169,7 @@ endmacro()
 
 macro(_ov_find_tbb)
     set(_ov_threading "@THREADING@")
-    if(_ov_threading STREQUAL "TBB" OR _ov_threading STREQUAL "TBB_AUTO")
+    if(_ov_threading STREQUAL "TBB" OR _ov_threading STREQUAL "TBB_AUTO" OR _ov_threading STREQUAL "TBB_PARTITIONER_AUTO")
         set(enable_pkgconfig_tbb "@tbb_FOUND@")
 
         # try tbb.pc
@@ -563,7 +563,7 @@ if(_ov_as_external_package)
 
     # WA for cmake version < 3.16 which does not export
     # IMPORTED_LINK_DEPENDENT_LIBRARIES_** properties if no PUBLIC dependencies for the library
-    if(THREADING STREQUAL "TBB" OR THREADING STREQUAL "TBB_AUTO")
+    if(THREADING STREQUAL "TBB" OR THREADING STREQUAL "TBB_AUTO" OR THREADING STREQUAL "TBB_PARTITIONER_AUTO")
         foreach(type RELEASE DEBUG RELWITHDEBINFO MINSIZEREL)
             foreach(tbb_target TBB::tbb TBB::tbbmalloc PkgConfig::tbb)
                 if(TARGET ${tbb_target})

src/bindings/python/src/openvino/properties/intel_cpu/__init__.py

@@ -2,6 +2,9 @@
 # Copyright (C) 2018-2025 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
+# Enums
+from openvino._pyopenvino.properties.intel_cpu import TbbPartitioner
+
 # Properties
 import openvino._pyopenvino.properties.intel_cpu as __intel_cpu
 from openvino.properties._properties import __make_properties

src/bindings/python/src/pyopenvino/core/properties/properties.cpp

@@ -106,11 +106,16 @@ void regmodule_properties(py::module m) {
     py::module m_intel_cpu =
         m_properties.def_submodule("intel_cpu", "openvino.properties.intel_cpu submodule that simulates ov::intel_cpu");
 
+    py::enum_<ov::intel_cpu::TbbPartitioner>(m_intel_cpu, "TbbPartitioner", py::arithmetic())
+        .value("STATIC", ov::intel_cpu::TbbPartitioner::STATIC)
+        .value("AUTO", ov::intel_cpu::TbbPartitioner::AUTO);
+
     // Submodule intel_cpu property
     wrap_property_RW(m_intel_cpu, ov::intel_cpu::denormals_optimization, "denormals_optimization");
     wrap_property_RW(m_intel_cpu,
                      ov::intel_cpu::sparse_weights_decompression_rate,
                      "sparse_weights_decompression_rate");
+    wrap_property_RW(m_intel_cpu, ov::intel_cpu::tbb_partitioner, "tbb_partitioner");
 
     // Submodule intel_gpu
     py::module m_intel_gpu =

src/bindings/python/src/pyopenvino/utils/utils.cpp

@@ -18,6 +18,7 @@
 #include "openvino/core/meta_data.hpp"
 #include "openvino/frontend/decoder.hpp"
 #include "openvino/frontend/graph_iterator.hpp"
+#include "openvino/runtime/intel_cpu/properties.hpp"
 #include "openvino/runtime/properties.hpp"
 
 using Version = ov::pass::Serialize::Version;
@@ -245,6 +246,8 @@ py::object from_ov_any(const ov::Any& any) {
         return py::cast(any.as<ov::hint::ExecutionMode>());
     } else if (any.is<ov::log::Level>()) {
         return py::cast(any.as<ov::log::Level>());
+    } else if (any.is<ov::intel_cpu::TbbPartitioner>()) {
+        return py::cast(any.as<ov::intel_cpu::TbbPartitioner>());
     } else if (any.is<ov::device::Type>()) {
         return py::cast(any.as<ov::device::Type>());
     } else if (any.is<ov::streams::Num>()) {
@@ -544,6 +547,8 @@ ov::Any py_object_to_any(const py::object& py_obj) {
         return py::cast<ov::hint::ExecutionMode>(py_obj);
     } else if (py::isinstance<ov::log::Level>(py_obj)) {
         return py::cast<ov::log::Level>(py_obj);
+    } else if (py::isinstance<ov::intel_cpu::TbbPartitioner>(py_obj)) {
+        return py::cast<ov::intel_cpu::TbbPartitioner>(py_obj);
     } else if (py::isinstance<ov::device::Type>(py_obj)) {
         return py::cast<ov::device::Type>(py_obj);
     } else if (py::isinstance<ov::streams::Num>(py_obj)) {

src/bindings/python/tests/test_runtime/test_properties.py

@@ -116,6 +116,13 @@ def test_properties_rw_base():
                 (log.Level.TRACE, "Level.TRACE", 4),
             ),
         ),
+        (
+            intel_cpu.TbbPartitioner,
+            (
+                (intel_cpu.TbbPartitioner.STATIC, "TbbPartitioner.STATIC", 0),
+                (intel_cpu.TbbPartitioner.AUTO, "TbbPartitioner.AUTO", 1),
+            ),
+        ),
         (
             intel_auto.SchedulePolicy,
             (
@@ -356,6 +363,14 @@ def test_properties_ro(ov_property_ro, expected_value):
                 (2.0, 2.0),
             ),
         ),
+        (
+            intel_cpu.tbb_partitioner,
+            "TBB_PARTITIONER",
+            (
+                (intel_cpu.TbbPartitioner.STATIC, intel_cpu.TbbPartitioner.STATIC),
+                (intel_cpu.TbbPartitioner.AUTO, intel_cpu.TbbPartitioner.AUTO),
+            ),
+        ),
         (
             intel_auto.device_bind_buffer,
             "DEVICE_BIND_BUFFER",

src/cmake/install_tbb.cmake

@@ -66,7 +66,7 @@ unset(_ov_dynamic_tbbbind_2_5_found)
 # install TBB
 
 # define variables for OpenVINOConfig.cmake
-if(THREADING MATCHES "^(TBB|TBB_AUTO)$")
+if(THREADING MATCHES "^(TBB|TBB_AUTO|TBB_PARTITIONER_AUTO)$")
     set(OV_TBB_DIR "${TBB_DIR}")
     list(APPEND PATH_VARS "OV_TBB_DIR")
 endif()
@@ -80,7 +80,7 @@ endif()
 # - downloaded TBB should be a part of all packages
 # - custom TBB provided by users, needs to be a part of wheel packages
 # - system TBB also needs to be a part of wheel packages
-if(THREADING MATCHES "^(TBB|TBB_AUTO)$" AND
+if(THREADING MATCHES "^(TBB|TBB_AUTO|TBB_PARTITIONER_AUTO)$" AND
        ( (DEFINED TBBROOT AND TBBROOT MATCHES ${TEMP}) OR
          (DEFINED TBBROOT OR DEFINED TBB_DIR OR DEFINED ENV{TBBROOT} OR
           DEFINED ENV{TBB_DIR}) OR ENABLE_SYSTEM_TBB ) )

src/cmake/ov_parallel.cmake

@@ -76,7 +76,7 @@ function(_ov_get_tbb_location tbb_target _tbb_lib_location_var)
 endfunction()
 
 macro(ov_find_package_tbb)
-    if(THREADING STREQUAL "TBB" OR THREADING STREQUAL "TBB_AUTO" AND NOT TBB_FOUND)
+    if(THREADING STREQUAL "TBB" OR THREADING STREQUAL "TBB_AUTO" OR THREADING STREQUAL "TBB_PARTITIONER_AUTO" AND NOT TBB_FOUND)
         # conan generates TBBConfig.cmake files, which follows cmake's
         # SameMajorVersion scheme, while TBB itself follows AnyNewerVersion one
         # see https://cmake.org/cmake/help/latest/module/CMakePackageConfigHelpers.html#generating-a-package-version-file
@@ -340,7 +340,7 @@ macro(ov_find_package_openmp)
 endmacro()
 
 function(ov_set_threading_interface_for TARGET_NAME)
-    if(THREADING STREQUAL "TBB" OR THREADING STREQUAL "TBB_AUTO" AND NOT TBB_FOUND)
+    if(THREADING STREQUAL "TBB" OR THREADING STREQUAL "TBB_AUTO" OR THREADING STREQUAL "TBB_PARTITIONER_AUTO" AND NOT TBB_FOUND)
         # find TBB
         ov_find_package_tbb()
 
@@ -383,9 +383,13 @@ function(ov_set_threading_interface_for TARGET_NAME)
         add_library(openvino::threading ALIAS openvino_threading)
     endif()
 
-    if(THREADING STREQUAL "TBB" OR THREADING STREQUAL "TBB_AUTO")
+    if(THREADING STREQUAL "TBB" OR THREADING STREQUAL "TBB_AUTO" OR THREADING STREQUAL "TBB_PARTITIONER_AUTO")
         if(TBB_FOUND)
-            set(_ov_thread_define "OV_THREAD_TBB")
+            if(THREADING STREQUAL "TBB_PARTITIONER_AUTO")
+                set(_ov_thread_define "OV_THREAD_TBB_PARTITIONER_AUTO")
+            else()
+                set(_ov_thread_define "OV_THREAD_TBB")
+            endif()
             set(_ov_threading_lib TBB::tbb)
         else()
             set(THREADING "SEQ" PARENT_SCOPE)

src/core/include/openvino/core/parallel.hpp

@@ -17,12 +17,13 @@
 #include <cstddef>
 #include <type_traits>
 
-#define OV_THREAD_TBB      0
-#define OV_THREAD_OMP      1
-#define OV_THREAD_SEQ      2
-#define OV_THREAD_TBB_AUTO 3
+#define OV_THREAD_TBB                  0
+#define OV_THREAD_OMP                  1
+#define OV_THREAD_SEQ                  2
+#define OV_THREAD_TBB_AUTO             3
+#define OV_THREAD_TBB_PARTITIONER_AUTO 4
 
-#if (OV_THREAD == OV_THREAD_TBB || OV_THREAD == OV_THREAD_TBB_AUTO)
+#if (OV_THREAD == OV_THREAD_TBB || OV_THREAD == OV_THREAD_TBB_AUTO || OV_THREAD == OV_THREAD_TBB_PARTITIONER_AUTO)
 #    ifndef NOMINMAX
 #        define NOMINMAX
 #    endif
@@ -66,7 +67,7 @@ inline int parallel_get_env_threads() {
 inline void parallel_set_max_nested_levels(int levels) {
     return;
 }
-#    if OV_THREAD == OV_THREAD_TBB
+#    if (OV_THREAD == OV_THREAD_TBB || OV_THREAD == OV_THREAD_TBB_PARTITIONER_AUTO)
 #        define PARTITIONING , tbb::static_partitioner()
 
 // The TBB version less than 2018u1 has no static_partitioner argument for
@@ -231,7 +232,7 @@ namespace ov {
 
 template <typename F>
 void parallel_nt(int nthr, const F& func) {
-#if (OV_THREAD == OV_THREAD_TBB || OV_THREAD == OV_THREAD_TBB_AUTO)
+#if (OV_THREAD == OV_THREAD_TBB || OV_THREAD == OV_THREAD_TBB_AUTO || OV_THREAD == OV_THREAD_TBB_PARTITIONER_AUTO)
     if (nthr == 0)
         nthr = parallel_get_max_threads();
     if (nthr == 1) {
@@ -279,7 +280,7 @@ void parallel_nt_static(int nthr, const F& func) {
 
     if (nthr == 0)
         nthr = parallel_get_max_threads();
-#if (OV_THREAD == OV_THREAD_TBB || OV_THREAD == OV_THREAD_TBB_AUTO)
+#if (OV_THREAD == OV_THREAD_TBB || OV_THREAD == OV_THREAD_TBB_AUTO || OV_THREAD == OV_THREAD_TBB_PARTITIONER_AUTO)
     tbb::parallel_for(
         0,
         nthr,
@@ -305,7 +306,7 @@ void parallel_nt_static(int nthr, const F& func) {
 
 template <typename I, typename F>
 void parallel_sort(I begin, I end, const F& comparator) {
-#if (OV_THREAD == OV_THREAD_TBB || OV_THREAD == OV_THREAD_TBB_AUTO)
+#if (OV_THREAD == OV_THREAD_TBB || OV_THREAD == OV_THREAD_TBB_AUTO || OV_THREAD == OV_THREAD_TBB_PARTITIONER_AUTO)
     tbb::parallel_sort(begin, end, comparator);
 #elif OV_THREAD == OV_THREAD_OMP
     // TODO: propose OpenMP version
@@ -317,7 +318,7 @@ void parallel_sort(I begin, I end, const F& comparator) {
 
 template <typename T0, typename R, typename F>
 R parallel_sum(const T0& D0, const R& input, const F& func) {
-#if (OV_THREAD == OV_THREAD_TBB || OV_THREAD == OV_THREAD_TBB_AUTO)
+#if (OV_THREAD == OV_THREAD_TBB || OV_THREAD == OV_THREAD_TBB_AUTO || OV_THREAD == OV_THREAD_TBB_PARTITIONER_AUTO)
     return _TBB_REDUCE_FUNC(
         tbb::blocked_range<T0>(0, D0),
         input,
@@ -351,7 +352,7 @@ R parallel_sum(const T0& D0, const R& input, const F& func) {
 
 template <typename T0, typename T1, typename R, typename F>
 R parallel_sum2d(const T0& D0, const T1& D1, const R& input, const F& func) {
-#if (OV_THREAD == OV_THREAD_TBB || OV_THREAD == OV_THREAD_TBB_AUTO)
+#if (OV_THREAD == OV_THREAD_TBB || OV_THREAD == OV_THREAD_TBB_AUTO || OV_THREAD == OV_THREAD_TBB_PARTITIONER_AUTO)
     return _TBB_REDUCE_FUNC(
         tbb::blocked_range2d<T0, T1>(0, D0, 0, D1),
         input,
@@ -391,7 +392,7 @@ R parallel_sum2d(const T0& D0, const T1& D1, const R& input, const F& func) {
 }
 template <typename T0, typename T1, typename T2, typename R, typename F>
 R parallel_sum3d(const T0& D0, const T1& D1, const T2& D2, const R& input, const F& func) {
-#if (OV_THREAD == OV_THREAD_TBB || OV_THREAD == OV_THREAD_TBB_AUTO)
+#if (OV_THREAD == OV_THREAD_TBB || OV_THREAD == OV_THREAD_TBB_AUTO || OV_THREAD == OV_THREAD_TBB_PARTITIONER_AUTO)
     return _TBB_REDUCE_FUNC(
         tbb::blocked_range3d<T0, T1, T2>(0, D0, 0, D1, 0, D2),
         input,
@@ -524,7 +525,7 @@ void parallel_for(const T0& D0, const F& func) {
     if (D0 == T0(0)) {
         return;
     }
-#if OV_THREAD == OV_THREAD_TBB
+#if (OV_THREAD == OV_THREAD_TBB || OV_THREAD == OV_THREAD_TBB_PARTITIONER_AUTO)
     auto work_amount = static_cast<size_t>(D0);
     int nthr = parallel_get_max_threads();
     if (static_cast<size_t>(nthr) > work_amount)
@@ -590,7 +591,7 @@ void parallel_for2d(const T0& D0, const T1& D1, const F& func) {
     if (D0 == T0(0) || D1 == T1(0)) {
         return;
     }
-#if OV_THREAD == OV_THREAD_TBB
+#if (OV_THREAD == OV_THREAD_TBB || OV_THREAD == OV_THREAD_TBB_PARTITIONER_AUTO)
     auto work_amount = static_cast<size_t>(D0 * D1);
     int nthr = parallel_get_max_threads();
     if (static_cast<size_t>(nthr) > work_amount)
@@ -636,7 +637,7 @@ void parallel_for2d(const T0& D0, const T1& D1, const F& func) {
 
 template <typename T0, typename T1, typename F>
 void parallel_for2d_dynamic(const T0& D0, const T1& D1, const F& func) {
-#if (OV_THREAD == OV_THREAD_TBB || OV_THREAD == OV_THREAD_TBB_AUTO)
+#if (OV_THREAD == OV_THREAD_TBB || OV_THREAD == OV_THREAD_TBB_AUTO || OV_THREAD == OV_THREAD_TBB_PARTITIONER_AUTO)
     tbb::parallel_for(tbb::blocked_range2d<T0, T1>(0, D0, 0, D1), [=](const tbb::blocked_range2d<T0, T1>& r) {
         for (T0 d0 = r.rows().begin(); d0 < r.rows().end(); d0++) {
             for (T1 d1 = r.cols().begin(); d1 < r.cols().end(); d1++) {
@@ -674,7 +675,7 @@ void parallel_for3d(const T0& D0, const T1& D1, const T2& D2, const F& func) {
     if (D0 == T0(0) || D1 == T1(0) || D2 == T2(0)) {
         return;
     }
-#if OV_THREAD == OV_THREAD_TBB
+#if (OV_THREAD == OV_THREAD_TBB || OV_THREAD == OV_THREAD_TBB_PARTITIONER_AUTO)
     auto work_amount = static_cast<size_t>(D0 * D1 * D2);
     int nthr = parallel_get_max_threads();
     if (static_cast<size_t>(nthr) > work_amount)
@@ -720,7 +721,7 @@ void parallel_for3d(const T0& D0, const T1& D1, const T2& D2, const F& func) {
 
 template <typename T0, typename T1, typename T2, typename F>
 void parallel_for3d_dynamic(const T0& D0, const T1& D1, const T2& D2, const F& func) {
-#if (OV_THREAD == OV_THREAD_TBB || OV_THREAD == OV_THREAD_TBB_AUTO)
+#if (OV_THREAD == OV_THREAD_TBB || OV_THREAD == OV_THREAD_TBB_AUTO || OV_THREAD == OV_THREAD_TBB_PARTITIONER_AUTO)
     tbb::parallel_for(tbb::blocked_range3d<T0, T1, T2>(0, D0, 0, D1, 0, D2),
                       [=](const tbb::blocked_range3d<T0, T1, T2>& r) {
                           for (T0 d0 = r.pages().begin(); d0 < r.pages().end(); d0++) {
@@ -762,7 +763,7 @@ void parallel_for4d(const T0& D0, const T1& D1, const T2& D2, const T3& D3, cons
     if (D0 == T0(0) || D1 == T1(0) || D2 == T2(0) || D3 == T3(0)) {
         return;
     }
-#if OV_THREAD == OV_THREAD_TBB
+#if (OV_THREAD == OV_THREAD_TBB || OV_THREAD == OV_THREAD_TBB_PARTITIONER_AUTO)
     auto work_amount = static_cast<size_t>(D0 * D1 * D2 * D3);
     int nthr = parallel_get_max_threads();
     if (static_cast<size_t>(nthr) > work_amount)
@@ -838,7 +839,7 @@ void parallel_for5d(const T0& D0, const T1& D1, const T2& D2, const T3& D3, cons
     if (D0 == T0(0) || D1 == T1(0) || D2 == T2(0) || D3 == T3(0) || D4 == T4(0)) {
         return;
     }
-#if OV_THREAD == OV_THREAD_TBB
+#if (OV_THREAD == OV_THREAD_TBB || OV_THREAD == OV_THREAD_TBB_PARTITIONER_AUTO)
     auto work_amount = static_cast<size_t>(D0 * D1 * D2 * D3 * D4);
     int nthr = parallel_get_max_threads();
     if (static_cast<size_t>(nthr) > work_amount)
@@ -916,7 +917,7 @@ void parallel_for6d(const T0& D0, const T1& D1, const T2& D2, const T3& D3, cons
     if (D0 == T0(0) || D1 == T1(0) || D2 == T2(0) || D3 == T3(0) || D4 == T4(0) || D5 == T5(0)) {
         return;
     }
-#if OV_THREAD == OV_THREAD_TBB
+#if (OV_THREAD == OV_THREAD_TBB || OV_THREAD == OV_THREAD_TBB_PARTITIONER_AUTO)
     auto work_amount = static_cast<size_t>(D0 * D1 * D2 * D3 * D4 * D5);
     int nthr = parallel_get_max_threads();
     if (static_cast<size_t>(nthr) > work_amount)

src/inference/dev_api/openvino/runtime/performance_heuristics.hpp

@@ -23,7 +23,14 @@ struct MemBandwidthPressure {
     float ratio_mem_limited_convs = 0;
     float ratio_mem_limited_deconvs = 0;
     float ratio_mem_limited_gemms = 0;
+    float ratio_mem_limited_adds = 0;
     float ratio_compute_deconvs = 0;
+    int total_gemms = 0;
+    int total_convs = 0;
+    int total_adds = 0;
+    int total_light_gemms = 0;
+    int total_light_convs = 0;
+    int total_nodes = 0;
 
     static constexpr float UNKNOWN = FLT_MAX;
     static constexpr float ALL = 1.0f;

src/inference/dev_api/openvino/runtime/threading/thread_local.hpp

@@ -11,7 +11,7 @@
 
 #include "openvino/core/parallel.hpp"
 
-#if OV_THREAD == OV_THREAD_TBB || OV_THREAD == OV_THREAD_TBB_AUTO
+#if OV_THREAD == OV_THREAD_TBB || OV_THREAD == OV_THREAD_TBB_AUTO || OV_THREAD == OV_THREAD_TBB_PARTITIONER_AUTO
 #    include <tbb/enumerable_thread_specific.h>
 #else
 #    include <functional>
@@ -25,7 +25,7 @@
 namespace ov {
 namespace threading {
 
-#if OV_THREAD == OV_THREAD_TBB || OV_THREAD == OV_THREAD_TBB_AUTO
+#if OV_THREAD == OV_THREAD_TBB || OV_THREAD == OV_THREAD_TBB_AUTO || OV_THREAD == OV_THREAD_TBB_PARTITIONER_AUTO
 
 /**
  * @brief A wrapper class to keep object to be thread local.

src/inference/dev_api/openvino/runtime/threading/thread_safe_containers.hpp

@@ -13,7 +13,7 @@
 
 #include "openvino/core/parallel.hpp"
 
-#if ((OV_THREAD == OV_THREAD_TBB) || (OV_THREAD == OV_THREAD_TBB_AUTO))
+#if ((OV_THREAD == OV_THREAD_TBB) || (OV_THREAD == OV_THREAD_TBB_AUTO) || (OV_THREAD == OV_THREAD_TBB_PARTITIONER_AUTO))
 #    include <tbb/concurrent_priority_queue.h>
 #    include <tbb/concurrent_queue.h>
 #endif
@@ -47,7 +47,7 @@ class ThreadSafeQueueWithSize {
     std::queue<T> _queue;
     std::mutex _mutex;
 };
-#if ((OV_THREAD == OV_THREAD_TBB) || (OV_THREAD == OV_THREAD_TBB_AUTO))
+#if ((OV_THREAD == OV_THREAD_TBB) || (OV_THREAD == OV_THREAD_TBB_AUTO) || (OV_THREAD == OV_THREAD_TBB_PARTITIONER_AUTO))
 template <typename T>
 using ThreadSafeQueue = tbb::concurrent_queue<T>;
 template <typename T>