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

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

@@ -17,6 +17,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;
@@ -244,6 +245,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,11 @@ 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.AUTO),),
+        ),
         (
             intel_auto.device_bind_buffer,
             "DEVICE_BIND_BUFFER",

src/inference/include/openvino/runtime/intel_cpu/properties.hpp

@@ -26,6 +26,55 @@ namespace ov {
  */
 namespace intel_cpu {
 
+/**
+ * @enum       TbbPartitioner
+ * @brief      This enum contains definition of the type of TBB partitioner.
+ */
+enum class TbbPartitioner {
+    STATIC = 0,  //!<  Static partitioner
+    AUTO = 1     //!<  Auto partitioner
+};
+
+/** @cond INTERNAL */
+inline std::ostream& operator<<(std::ostream& os, const TbbPartitioner& tbb_partitioner) {
+    switch (tbb_partitioner) {
+    case TbbPartitioner::STATIC:
+        return os << "STATIC";
+    case TbbPartitioner::AUTO:
+        return os << "AUTO";
+    default:
+        OPENVINO_THROW("Unsupported tbb partitioner!");
+    }
+}
+
+inline std::istream& operator>>(std::istream& is, TbbPartitioner& tbb_partitioner) {
+    std::string str;
+    is >> str;
+    if (str == "STATIC") {
+        tbb_partitioner = TbbPartitioner::STATIC;
+    } else if (str == "AUTO") {
+        tbb_partitioner = TbbPartitioner::AUTO;
+    } else {
+        OPENVINO_THROW("Unsupported tbb partitioner: ", str);
+    }
+    return is;
+}
+/** @endcond */
+
+/**
+ * @brief This property defines the type of TBB partitioner in parallel.
+ * @ingroup ov_runtime_cpp_prop_api
+ *
+ * Developer can use this property to select the type of TBB partitioner.
+ *
+ * The following code is an example to set auto partitioner. It is STATIC by default.
+ *
+ * @code
+ * ie.set_property(ov::intel_cpu::tbb_partitioner(ov::intel_cpu::TbbPartitioner::AUTO));
+ * @endcode
+ */
+static constexpr Property<TbbPartitioner> tbb_partitioner{"TBB_PARTITIONER"};
+
 /**
  * @brief This property define whether to perform denormals optimization.
  * @ingroup ov_runtime_cpu_prop_cpp_api

src/plugins/intel_cpu/src/compiled_model.cpp

@@ -180,10 +180,12 @@ CompiledModel::GraphGuard::Lock CompiledModel::get_graph() const {
                     std::lock_guard<std::mutex> lock{*m_mutex.get()};
                     auto isQuantizedFlag = (m_cfg.lpTransformsMode == Config::On) &&
                                            ov::pass::low_precision::LowPrecision::isFunctionQuantized(m_model);
+                    auto cpuParallel = std::make_shared<CpuParallel>(m_cfg.tbbPartitioner, 32);
                     ctx = std::make_shared<GraphContext>(m_cfg,
                                                          m_socketWeights[socketId],
                                                          isQuantizedFlag,
                                                          streamsExecutor,
+                                                         cpuParallel,
                                                          m_sub_memory_manager);
                 }
 
@@ -281,6 +283,7 @@ ov::Any CompiledModel::get_property(const std::string& name) const {
             RO_property(ov::intel_cpu::denormals_optimization.name()),
             RO_property(ov::log::level.name()),
             RO_property(ov::intel_cpu::sparse_weights_decompression_rate.name()),
+            RO_property(ov::intel_cpu::tbb_partitioner.name()),
             RO_property(ov::hint::dynamic_quantization_group_size.name()),
             RO_property(ov::hint::kv_cache_precision.name()),
             RO_property(ov::key_cache_precision.name()),
@@ -361,6 +364,10 @@ ov::Any CompiledModel::get_property(const std::string& name) const {
         return static_cast<decltype(ov::intel_cpu::sparse_weights_decompression_rate)::value_type>(
             config.fcSparseWeiDecompressionRate);
     }
+    if (name == ov::intel_cpu::tbb_partitioner) {
+        const auto tbb_partitioner = config.tbbPartitioner;
+        return tbb_partitioner;
+    }
     if (name == ov::hint::dynamic_quantization_group_size) {
         return static_cast<decltype(ov::hint::dynamic_quantization_group_size)::value_type>(
             config.fcDynamicQuantizationGroupSize);

src/plugins/intel_cpu/src/config.cpp

@@ -186,6 +186,16 @@ void Config::readProperties(const ov::AnyMap& prop, const ModelType modelType) {
             } else {
                 fcSparseWeiDecompressionRate = val_f;
             }
+        } else if (key == ov::intel_cpu::tbb_partitioner.name()) {
+            try {
+                tbbPartitioner = val.as<ov::intel_cpu::TbbPartitioner>();
+            } catch (ov::Exception&) {
+                OPENVINO_THROW("Wrong value ",
+                               val.as<std::string>(),
+                               "for property key ",
+                               ov::intel_cpu::tbb_partitioner.name(),
+                               ". Expected only ov::intel_cpu::TbbPartitioner::STATIC/AUTO");
+            }
         } else if (key == ov::hint::dynamic_quantization_group_size.name()) {
             try {
                 fcDynamicQuantizationGroupSizeSetExplicitly = true;

src/plugins/intel_cpu/src/config.h

@@ -91,6 +91,7 @@ struct Config {
     bool changedCpuPinning = false;
     bool enableCpuReservation = false;
     ov::hint::SchedulingCoreType schedulingCoreType = ov::hint::SchedulingCoreType::ANY_CORE;
+    ov::intel_cpu::TbbPartitioner tbbPartitioner = ov::intel_cpu::TbbPartitioner::STATIC;
     std::set<ov::hint::ModelDistributionPolicy> modelDistributionPolicy = {};
     int streamsRankLevel = 1;
     int numSubStreams = 0;