CPU reservation is false on mac (#28544)

sunxiaoxia2022 · wangleis · web-flow · commit fcb9c9d5d6d9 · 2025-03-06T02:28:33.000Z
### Details:
 - *CPU reservation is false on mac*

### Tickets:
 - *ticket-id*

---------

Co-authored-by: Wanglei Shen &lt;wanglei.shen@intel.com&gt;
diff --git a/src/inference/dev_api/openvino/runtime/system_conf.hpp b/src/inference/dev_api/openvino/runtime/system_conf.hpp
@@ -174,13 +174,6 @@ OPENVINO_RUNTIME_API bool with_cpu_x86_avx512_core_amx_fp16();
  */
 OPENVINO_RUNTIME_API bool with_cpu_x86_avx512_core_amx();
 
-/**
- * @brief      Checks whether cpu_mapping Available
- * @ingroup    ov_dev_api_system_conf
- * @return     `True` is CPU mapping is available, `false` otherwise
- */
-OPENVINO_RUNTIME_API bool is_cpu_map_available();
-
 /**
  * @brief      Get number of numa nodes
  * @ingroup    ov_dev_api_system_conf
diff --git a/src/inference/src/dev/threading/cpu_streams_executor.cpp b/src/inference/src/dev/threading/cpu_streams_executor.cpp
@@ -67,7 +67,7 @@ struct CPUStreamsExecutor::Impl {
                                                 _impl->_usedNumaNodes.size()))
                     : _impl->_usedNumaNodes.at(_streamId % _impl->_usedNumaNodes.size());
 #if OV_THREAD == OV_THREAD_TBB || OV_THREAD == OV_THREAD_TBB_AUTO
-            if (is_cpu_map_available() && _impl->_config.get_streams_info_table().size() > 0) {
+            if (_impl->_config.get_streams_info_table().size() > 0) {
                 init_stream();
             }
 #elif OV_THREAD == OV_THREAD_OMP
diff --git a/src/inference/src/system_conf.cpp b/src/inference/src/system_conf.cpp
@@ -271,9 +271,6 @@ std::vector<std::vector<int>> get_proc_type_table() {
 std::vector<std::vector<int>> get_org_proc_type_table() {
     return {{-1}};
 }
-bool is_cpu_map_available() {
-    return false;
-}
 int get_num_numa_nodes() {
     return -1;
 }
@@ -313,11 +310,6 @@ int get_number_of_blocked_cores() {
     return cpu._blocked_cores;
 }
 
-bool is_cpu_map_available() {
-    CPU& cpu = cpu_info();
-    return cpu._proc_type_table.size() > 0;
-}
-
 int get_current_socket_id() {
     return 0;
 }
@@ -393,6 +385,7 @@ std::vector<int> get_available_numa_nodes() {
     return nodes;
 }
 #        endif
+
 int get_current_socket_id() {
     CPU& cpu = cpu_info();
     int cur_processor_id = sched_getcpu();
@@ -419,6 +412,7 @@ int get_current_numa_node_id() {
     return 0;
 }
 #    else
+
 int get_current_socket_id() {
     CPU& cpu = cpu_info();
     int cur_processor_id = GetCurrentProcessorNumber();
@@ -457,11 +451,6 @@ std::vector<std::vector<int>> get_org_proc_type_table() {
     return cpu._org_proc_type_table;
 }
 
-bool is_cpu_map_available() {
-    CPU& cpu = cpu_info();
-    return cpu._cpu_mapping_table.size() > 0;
-}
-
 int get_num_numa_nodes() {
     return cpu_info()._numa_nodes;
 }
diff --git a/src/plugins/intel_cpu/src/config.cpp b/src/plugins/intel_cpu/src/config.cpp
@@ -9,6 +9,7 @@
 #include <string>
 
 #include "cpu/x64/cpu_isa_traits.hpp"
+#include "cpu_map_scheduling.hpp"
 #include "openvino/core/parallel.hpp"
 #include "openvino/core/type/element_type_traits.hpp"
 #include "openvino/runtime/intel_cpu/properties.hpp"
@@ -117,7 +118,11 @@ void Config::readProperties(const ov::AnyMap& prop, const ModelType modelType) {
             }
         } else if (key == ov::hint::enable_cpu_reservation.name()) {
             try {
+#if defined(__APPLE__)
+                enableCpuReservation = false;
+#else
                 enableCpuReservation = val.as<bool>();
+#endif
             } catch (ov::Exception&) {
                 OPENVINO_THROW("Wrong value ",
                                val.as<std::string>(),
diff --git a/src/plugins/intel_cpu/src/cpu_map_scheduling.cpp b/src/plugins/intel_cpu/src/cpu_map_scheduling.cpp
@@ -69,39 +69,42 @@ std::vector<std::vector<int>> apply_hyper_threading(bool& input_ht_hint,
     return result_table;
 }
 
-bool get_cpu_pinning(bool& input_value,
-                     const bool input_changed,
-                     const bool cpu_reservation,
-                     const std::vector<std::vector<int>>& proc_type_table,
-                     const std::vector<std::vector<int>>& streams_info_table) {
+bool check_cpu_pinning(const bool cpu_pinning,
+                       const bool cpu_pinning_changed,
+                       const bool cpu_reservation,
+                       const std::vector<std::vector<int>>& streams_info_table) {
     bool result_value;
 
 #if defined(__APPLE__)
     result_value = false;
 #elif defined(_WIN32)
+    auto proc_type_table = get_proc_type_table();
     if (proc_type_table.size() == 1) {
-        result_value = input_changed ? input_value : cpu_reservation;
+        result_value = cpu_pinning_changed ? cpu_pinning : cpu_reservation;
     } else {
         result_value = false;
     }
 #else
-    if (input_changed) {
-        result_value = input_value;
-    } else {
-        result_value = true;
-        // The following code disables pinning in case stream contains both Pcore and Ecore
+    // The following code disables pinning in case stream contains both Pcore and Ecore
+    auto hyper_cores_in_stream = [&]() {
         if (streams_info_table.size() >= 3) {
             if ((streams_info_table[0][PROC_TYPE] == ALL_PROC) &&
                 (streams_info_table[1][PROC_TYPE] != EFFICIENT_CORE_PROC) &&
                 (streams_info_table[2][PROC_TYPE] == EFFICIENT_CORE_PROC)) {
-                result_value = cpu_reservation;
+                return true;
             }
         }
+        return false;
+    };
+
+    result_value = cpu_pinning_changed ? cpu_pinning : true;
+    if (!cpu_pinning_changed && !cpu_reservation) {
+        if (hyper_cores_in_stream()) {
+            result_value = false;
+        }
     }
 #endif
 
-    input_value = result_value;
-
     return result_value;
 }
 
diff --git a/src/plugins/intel_cpu/src/cpu_map_scheduling.hpp b/src/plugins/intel_cpu/src/cpu_map_scheduling.hpp
@@ -40,18 +40,17 @@ std::vector<std::vector<int>> apply_hyper_threading(bool& input_ht_hint,
                                                     const std::vector<std::vector<int>>& proc_type_table);
 
 /**
- * @brief      whether pinning cpu cores according to enableCpuPinning property
- * @param[in]  input_type indicate value of property enableCpuPinning.
- * @param[in]  input_changed indicate if value is set by user.
- * @param[in]  cpu_reservation indicate if cpu need to be reserved
- * @param[in]  proc_type_table indicate processors information of this platform
+ * @brief      Check enableCpuPinning in different platform
+ * @param[in]  cpu_pinning the property enableCpuPinning set by user.
+ * @param[in]  cpu_pinning_changed the property changedCpuPinning which value depends on whether user sets
+ * enableCpuPinning. true: user sets property enableCpuPinning. false: user does not set property enableCpuPinning.
+ * @param[in]  cpu_reservation the property enableCpuReservation set by user. False by default
  * @param[in]  streams_info_table indicate streams detail of this model
  * @return     whether pinning threads to cpu cores
  */
-bool get_cpu_pinning(bool& input_value,
-                     const bool input_changed,
-                     const bool cpu_reservation,
-                     const std::vector<std::vector<int>>& proc_type_table,
-                     const std::vector<std::vector<int>>& streams_info_table);
+bool check_cpu_pinning(const bool cpu_pinning,
+                       const bool cpu_pinning_changed,
+                       const bool cpu_reservation,
+                       const std::vector<std::vector<int>>& streams_info_table);
 
 }  // namespace ov::intel_cpu
diff --git a/src/plugins/intel_cpu/src/cpu_streams_calculation.cpp b/src/plugins/intel_cpu/src/cpu_streams_calculation.cpp
@@ -729,18 +729,17 @@ std::vector<std::vector<int>> generate_stream_info(const int streams,
             get_streams_rank_table(streams_info_table, config.streamsRankLevel, config.numSubStreams);
     }
 
-    auto cpu_pinning = get_cpu_pinning(config.enableCpuPinning,
-                                       config.changedCpuPinning,
-                                       config.enableCpuReservation,
-                                       proc_type_table,
-                                       streams_info_table);
+    config.enableCpuPinning = check_cpu_pinning(config.enableCpuPinning,
+                                                config.changedCpuPinning,
+                                                config.enableCpuReservation,
+                                                streams_info_table);
 
     config.streamExecutorConfig = IStreamsExecutor::Config{"CPUStreamsExecutor",
                                                            config.streams,
                                                            config.threadsPerStream,
                                                            ov::hint::SchedulingCoreType::ANY_CORE,
                                                            config.enableCpuReservation,
-                                                           cpu_pinning,
+                                                           config.enableCpuPinning,
                                                            true,
                                                            std::move(streams_info_table),
                                                            {},
diff --git a/src/plugins/intel_cpu/tests/functional/custom/behavior/ov_executable_network/properties.cpp b/src/plugins/intel_cpu/tests/functional/custom/behavior/ov_executable_network/properties.cpp
@@ -12,6 +12,10 @@
 #include "openvino/runtime/system_conf.hpp"
 #include "utils/properties_test.hpp"
 
+#if defined(_WIN32)
+#    include <windows.h>
+#endif
+
 namespace {
 
 TEST_F(OVClassConfigTestCPU, smoke_CpuExecNetworkSupportedPropertiesAreAvailable) {
@@ -159,6 +163,47 @@ TEST_F(OVClassConfigTestCPU, smoke_CpuExecNetworkCheckModelZeroStreams) {
     ASSERT_EQ(streams, value);
 }
 
+TEST_F(OVClassConfigTestCPU, smoke_CpuExecNetworkCheckCpuReservation) {
+    ov::Core ie;
+    int32_t threads = 1;
+    int32_t res_threads = -1;
+    bool cpu_reservation = true;
+    bool res_cpu_reservation = false;
+    bool cpu_pinning = false;
+    bool res_cpu_pinning = false;
+
+#if defined(__APPLE__)
+    cpu_reservation = false;
+    cpu_pinning = false;
+#elif defined(__linux__)
+    cpu_pinning = true;
+#elif defined(_WIN32)
+    ULONG highestNodeNumber = 0;
+    if (!GetNumaHighestNodeNumber(&highestNodeNumber)) {
+        std::cout << "Error getting highest NUMA node number: " << GetLastError() << std::endl;
+        return;
+    }
+    if (highestNodeNumber > 0) {
+        cpu_pinning = false;
+    } else {
+        cpu_pinning = true;
+    }
+#endif
+
+    OV_ASSERT_NO_THROW(ie.set_property(deviceName, ov::hint::performance_mode(ov::hint::PerformanceMode::LATENCY)));
+
+    ov::AnyMap config = {{ov::inference_num_threads.name(), threads}, {ov::hint::enable_cpu_reservation.name(), true}};
+    ov::CompiledModel compiledModel = ie.compile_model(model, deviceName, config);
+
+    OV_ASSERT_NO_THROW(res_threads = compiledModel.get_property(ov::inference_num_threads));
+    OV_ASSERT_NO_THROW(res_cpu_reservation = compiledModel.get_property(ov::hint::enable_cpu_reservation));
+    OV_ASSERT_NO_THROW(res_cpu_pinning = compiledModel.get_property(ov::hint::enable_cpu_pinning));
+
+    ASSERT_EQ(res_threads, threads);
+    ASSERT_EQ(res_cpu_reservation, cpu_reservation);
+    ASSERT_EQ(res_cpu_pinning, cpu_pinning);
+}
+
 TEST_F(OVClassConfigTestCPU, smoke_CpuExecNetworkCheckSparseWeigthsDecompressionRate) {
     ov::Core core;
 
diff --git a/src/plugins/intel_cpu/tests/functional/shared_tests_instances/behavior/compiled_model/cpu_reservation_test.cpp b/src/plugins/intel_cpu/tests/functional/shared_tests_instances/behavior/compiled_model/cpu_reservation_test.cpp
@@ -15,6 +15,10 @@
 #include "openvino/runtime/properties.hpp"
 #include "openvino/util/file_util.hpp"
 
+#if defined(_WIN32)
+#    include <windows.h>
+#endif
+
 using namespace testing;
 using Device = std::string;
 using Config = ov::AnyMap;
@@ -80,14 +84,30 @@ TEST_F(DISABLED_CpuReservationTest, Cpu_Reservation_CpuPinning) {
     Config config = {ov::enable_profiling(true)};
     Device target_device(ov::test::utils::DEVICE_CPU);
     models.emplace_back(ov::test::utils::make_2_input_subtract());
+    bool cpu_pinning = false;
+
+#if defined(__linux__)
+    cpu_pinning = true;
+#elif defined(_WIN32)
+    ULONG highestNodeNumber = 0;
+    if (!GetNumaHighestNodeNumber(&highestNodeNumber)) {
+        std::cout << "Error getting highest NUMA node number: " << GetLastError() << std::endl;
+        return;
+    }
+    if (highestNodeNumber > 0) {
+        cpu_pinning = false;
+    } else {
+        cpu_pinning = true;
+    }
+#endif
 
     std::shared_ptr<ov::Core> core = ov::test::utils::PluginCache::get().core();
     core->set_property(target_device, config);
     ov::AnyMap property_config = {{ov::inference_num_threads.name(), 1},
                                   {ov::hint::enable_cpu_reservation.name(), true}};
     auto compiled_model = core->compile_model(models[0], target_device, property_config);
-    auto cpu_pinning = compiled_model.get_property(ov::hint::enable_cpu_pinning.name());
-    ASSERT_EQ(cpu_pinning, true);
+    auto res_cpu_pinning = compiled_model.get_property(ov::hint::enable_cpu_pinning.name());
+    ASSERT_EQ(res_cpu_pinning, cpu_pinning);
 }
 
 TEST_F(CpuReservationTest, Cpu_Reservation_CompiledModel_Release) {
diff --git a/src/plugins/intel_cpu/tests/unit/streams_info/cpu_pinning_test.cpp b/src/plugins/intel_cpu/tests/unit/streams_info/cpu_pinning_test.cpp
diff --git a/src/plugins/intel_cpu/tests/unit/streams_info/streams_e2e_test.cpp b/src/plugins/intel_cpu/tests/unit/streams_info/streams_e2e_test.cpp

Original file line number	Diff line number	Diff line change
`@@ -67,7 +67,7 @@ struct CPUStreamsExecutor::Impl {`
`67`	`67`	`_impl->_usedNumaNodes.size()))`
`68`	`68`	`: _impl->_usedNumaNodes.at(_streamId % _impl->_usedNumaNodes.size());`
`69`	`69`	`#if OV_THREAD == OV_THREAD_TBB \|\| OV_THREAD == OV_THREAD_TBB_AUTO`
`70`		`- if (is_cpu_map_available() && _impl->_config.get_streams_info_table().size() > 0) {`
	`70`	`+ if (_impl->_config.get_streams_info_table().size() > 0) {`
`71`	`71`	`init_stream();`
`72`	`72`	`}`
`73`	`73`	`#elif OV_THREAD == OV_THREAD_OMP`
Original file line number	Diff line number	Diff line change
`@@ -271,9 +271,6 @@ std::vector<std::vector<int>> get_proc_type_table() {`
`271`	`271`	`std::vector<std::vector<int>> get_org_proc_type_table() {`
`272`	`272`	`return {{-1}};`
`273`	`273`	`}`
`274`		`-bool is_cpu_map_available() {`
`275`		`- return false;`
`276`		`-}`
`277`	`274`	`int get_num_numa_nodes() {`
`278`	`275`	`return -1;`
`279`	`276`	`}`
`@@ -313,11 +310,6 @@ int get_number_of_blocked_cores() {`
`313`	`310`	`return cpu._blocked_cores;`
`314`	`311`	`}`
`315`	`312`
`316`		`-bool is_cpu_map_available() {`
`317`		`- CPU& cpu = cpu_info();`
`318`		`- return cpu._proc_type_table.size() > 0;`
`319`		`-}`
`320`		`-`
`321`	`313`	`int get_current_socket_id() {`
`322`	`314`	`return 0;`
`323`	`315`	`}`
`@@ -393,6 +385,7 @@ std::vector<int> get_available_numa_nodes() {`
`393`	`385`	`return nodes;`
`394`	`386`	`}`
`395`	`387`	`# endif`
	`388`	`+`
`396`	`389`	`int get_current_socket_id() {`
`397`	`390`	`CPU& cpu = cpu_info();`
`398`	`391`	`int cur_processor_id = sched_getcpu();`
`@@ -419,6 +412,7 @@ int get_current_numa_node_id() {`
`419`	`412`	`return 0;`
`420`	`413`	`}`
`421`	`414`	`# else`
	`415`	`+`
`422`	`416`	`int get_current_socket_id() {`
`423`	`417`	`CPU& cpu = cpu_info();`
`424`	`418`	`int cur_processor_id = GetCurrentProcessorNumber();`
`@@ -457,11 +451,6 @@ std::vector<std::vector<int>> get_org_proc_type_table() {`
`457`	`451`	`return cpu._org_proc_type_table;`
`458`	`452`	`}`
`459`	`453`
`460`		`-bool is_cpu_map_available() {`
`461`		`- CPU& cpu = cpu_info();`
`462`		`- return cpu._cpu_mapping_table.size() > 0;`
`463`		`-}`
`464`		`-`
`465`	`454`	`int get_num_numa_nodes() {`
`466`	`455`	`return cpu_info()._numa_nodes;`
`467`	`456`	`}`