Update threading configuration for NVL and PTL (#36367)

### Details:
 - *Update threading configuration for NVL and PTL*
1. Improve hybrid CPU latency heuristics to enable more ALL/AUTO
configurations on high LP E-core-share platforms.
2. Add new model-profile-based AUTO rules using lp_ecore_share, memory
tolerance, convolution pressure, and GEMM ratio.
3. Refine latency stream sizing so model_prefer_threads is honored when
building single-stream ALL core configurations.
4. Extend CPUStreamsExecutor internal stream metadata from a single core
type to multiple core types.
5. Update task arena creation logic to bind streams by the actual set of
eligible core types instead of forcing a single-type binding.
6. Add unit coverage for mixed-core stream metadata and stream type
selection behavior.
 
Dependency PR:
[PR#36286](#36286)
### Tickets:
 - CVS-183947
 - CVS-180761

### Test data:

Machine: 
1.NVL windows from validation team (8Pcores+16Ecores+4LPEcores), 
2.PTL X7 358H 32GB windows (4Pcores+8Ecores+4LPEcores)
Models: 209 static models from WW05_static_2026.0.0-20947

The geomean of latency with PR vs master:
NVL: 0.97583
PTL: 0.92095

The performance data for all models:
<img width="285" height="188" alt="image"
src="https://github.com/user-attachments/assets/d6046306-e68e-4a9a-8f3b-dfe616539805"
/>
The performance data for the models with **threads and partitioner
changed in current PR**:
<img width="284" height="165" alt="image"
src="https://github.com/user-attachments/assets/e869d620-e743-4dd0-b649-b66ca6ffe713"
/>

---------

Co-authored-by: Chen Peter <peter.chen@intel.com>

Author: sunxiaoxia2022

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

@@ -30,17 +30,18 @@ enum StreamCreateType {
  * @param[in]  streams_info_table streams information table
  * @param[out]  stream_type stream create type
  * @param[out]  concurrency the number of threads created at the same time
- * @param[out]  core_type core type
+ * @param[out]  core_types core types used for thread binding
  * @param[out]  numa_node_id numa node id
+ * @param[out]  socket_id socket id
  * @param[out]  max_threads_per_core the max number of threads per cpu core
  */
 void get_cur_stream_info(const int stream_id,
                          const bool cpu_pinning,
-                         const std::vector<std::vector<int>> org_proc_type_table,
-                         const std::vector<std::vector<int>> streams_info_table,
+                         const std::vector<std::vector<int>>& org_proc_type_table,
+                         const std::vector<std::vector<int>>& streams_info_table,
                          StreamCreateType& stream_type,
                          int& concurrency,
-                         int& core_type,
+                         std::vector<int>& core_types,
                          int& numa_node_id,
                          int& socket_id,
                          int& max_threads_per_core);

src/inference/src/dev/threading/cpu_streams_executor.cpp

@@ -4,6 +4,7 @@
 
 #include "openvino/runtime/threading/cpu_streams_executor.hpp"
 
+#include <algorithm>
 #include <atomic>
 #include <condition_variable>
 #include <memory>
@@ -99,22 +100,60 @@ struct CPUStreamsExecutor::Impl {
         }
 
 #if OV_THREAD == OV_THREAD_TBB || OV_THREAD == OV_THREAD_TBB_AUTO || OV_THREAD == OV_THREAD_TBB_ADAPTIVE
+        custom::core_type_id map_proc_kind_to_tbb_core_type(const std::vector<custom::core_type_id>& sys_core_types,
+                                                            const int proc_kind) {
+            if (sys_core_types.empty()) {
+                return custom::task_arena::automatic;
+            }
+
+            switch (proc_kind) {
+            case MAIN_CORE_PROC:
+            case HYPER_THREADING_PROC:
+                return sys_core_types.back();
+            case EFFICIENT_CORE_PROC:
+                return sys_core_types.size() >= 2 ? *(sys_core_types.end() - 2) : sys_core_types.back();
+            case LP_EFFICIENT_CORE_PROC:
+                return sys_core_types.front();
+            default:
+                return sys_core_types.back();
+            }
+        }
+
+        std::vector<custom::core_type_id> map_proc_kinds_to_tbb_core_types(
+            const std::vector<custom::core_type_id>& sys_core_types,
+            const std::vector<int>& proc_kinds) {
+            std::vector<custom::core_type_id> mapped_core_types;
+            mapped_core_types.reserve(proc_kinds.size());
+
+            for (const auto proc_kind : proc_kinds) {
+                const auto core_type = map_proc_kind_to_tbb_core_type(sys_core_types, proc_kind);
+                if (core_type != custom::task_arena::automatic &&
+                    std::find(mapped_core_types.begin(), mapped_core_types.end(), core_type) ==
+                        mapped_core_types.end()) {
+                    mapped_core_types.push_back(core_type);
+                }
+            }
+
+            return mapped_core_types;
+        }
+
         void create_tbb_task_arena(const int stream_id,
                                    const StreamCreateType stream_type,
                                    const int concurrency,
-                                   const int core_type,
+                                   const std::vector<int>& core_types,
                                    const int numa_node_id,
                                    const int socket_id,
                                    const int max_threads_per_core) {
             auto stream_processors = _impl->_config.get_stream_processor_ids();
             _numaNodeId = numa_node_id;
             _socketId = socket_id;
+            auto _stream_type = stream_type;
 #    if (TBB_INTERFACE_VERSION < 12000)
             const auto tbb_version = tbb::TBB_runtime_interface_version();
 #    else
             const auto tbb_version = TBB_runtime_interface_version();
 #    endif
-            if (stream_type == STREAM_WITHOUT_PARAM) {
+            if (_stream_type == STREAM_WITH_CORE_TYPE) {
                 int version_major = tbb_version / 10;
                 int version_patch = tbb_version % 10;
                 bool support_core_types = false;
@@ -124,19 +163,17 @@ struct CPUStreamsExecutor::Impl {
                      version_patch >= TBB_VERSION_PATCH_CORE_TYPES_LINUX)) {
                     support_core_types = true;
                 }
-                const auto core_types = custom::info::core_types();
-                if (support_core_types && core_types.size() >= MIN_CORE_TYPES_FOR_PTL) {
-                    _taskArena.reset(new custom::task_arena{
-                        custom::task_arena::constraints{}
-                            .set_max_concurrency(concurrency)
-                            .set_max_threads_per_core(max_threads_per_core)
-                            .set_core_types({core_types.end() - MIN_CORE_TYPES_FOR_PTL + 1, core_types.end()})});
+                if (core_types.size() == 1 || (core_types.size() > 1 && support_core_types)) {
+                    _stream_type = STREAM_WITH_CORE_TYPE;
                 } else {
-                    _taskArena.reset(new custom::task_arena{custom::task_arena::constraints{}
-                                                                .set_max_concurrency(concurrency)
-                                                                .set_max_threads_per_core(max_threads_per_core)});
+                    _stream_type = STREAM_WITHOUT_PARAM;
                 }
-            } else if (stream_type == STREAM_WITH_NUMA_ID) {
+            }
+            if (_stream_type == STREAM_WITHOUT_PARAM) {
+                _taskArena.reset(new custom::task_arena{custom::task_arena::constraints{}
+                                                            .set_max_concurrency(concurrency)
+                                                            .set_max_threads_per_core(max_threads_per_core)});
+            } else if (_stream_type == STREAM_WITH_NUMA_ID) {
                 // Numa node id has used different mapping methods in TBBBind since oneTBB 2021.4.0
 #    if USE_TBBBIND_2_5
                 auto real_numa_node_id = _numaNodeId;
@@ -150,19 +187,21 @@ struct CPUStreamsExecutor::Impl {
                                                             .set_numa_id(real_numa_node_id)
                                                             .set_max_concurrency(concurrency)
                                                             .set_max_threads_per_core(max_threads_per_core)});
-            } else if (stream_type == STREAM_WITH_CORE_TYPE) {
-                const auto core_types = custom::info::core_types();
-                auto real_core_type = (core_type == MAIN_CORE_PROC || core_type == HYPER_THREADING_PROC)
-                                          ? core_types.back()
-                                          : core_types.front();
-                // core_types=[LPECore, Ecore, Pcore]
-                if (core_type == EFFICIENT_CORE_PROC && core_types.size() >= MIN_CORE_TYPES_FOR_PTL) {
-                    real_core_type = *(core_types.end() - MIN_CORE_TYPES_FOR_PTL + 1);
+            } else if (_stream_type == STREAM_WITH_CORE_TYPE) {
+                // sys_core_types = [LPECore, Ecore, Pcore]
+                const auto sys_core_types = custom::info::core_types();
+                const auto mapped_core_types = map_proc_kinds_to_tbb_core_types(sys_core_types, core_types);
+                auto constraints = custom::task_arena::constraints{}
+                                       .set_max_concurrency(concurrency)
+                                       .set_max_threads_per_core(max_threads_per_core);
+
+                if (mapped_core_types.empty()) {
+                    _taskArena.reset(new custom::task_arena{constraints});
+                } else if (mapped_core_types.size() == 1) {
+                    _taskArena.reset(new custom::task_arena{constraints.set_core_type(mapped_core_types.front())});
+                } else {
+                    _taskArena.reset(new custom::task_arena{constraints.set_core_types(mapped_core_types)});
                 }
-                _taskArena.reset(new custom::task_arena{custom::task_arena::constraints{}
-                                                            .set_core_type(real_core_type)
-                                                            .set_max_concurrency(concurrency)
-                                                            .set_max_threads_per_core(max_threads_per_core)});
             } else {
                 _taskArena.reset(new custom::task_arena{concurrency});
                 _cpu_ids =
@@ -180,7 +219,7 @@ struct CPUStreamsExecutor::Impl {
         }
         void init_stream() {
             int concurrency;
-            int cpu_core_type;
+            std::vector<int> cpu_core_types;
             int numa_node_id;
             int socket_id;
             int max_threads_per_core;
@@ -195,7 +234,7 @@ struct CPUStreamsExecutor::Impl {
                                 _impl->_config.get_streams_info_table(),
                                 stream_type,
                                 concurrency,
-                                cpu_core_type,
+                                cpu_core_types,
                                 numa_node_id,
                                 socket_id,
                                 max_threads_per_core);
@@ -205,7 +244,7 @@ struct CPUStreamsExecutor::Impl {
             create_tbb_task_arena(stream_id,
                                   stream_type,
                                   concurrency,
-                                  cpu_core_type,
+                                  cpu_core_types,
                                   numa_node_id,
                                   socket_id,
                                   max_threads_per_core);

src/inference/src/dev/threading/cpu_streams_executor_internal.cpp

@@ -15,18 +15,33 @@ namespace threading {
 
 void get_cur_stream_info(const int stream_id,
                          const bool cpu_pinning,
-                         const std::vector<std::vector<int>> proc_type_table,
-                         const std::vector<std::vector<int>> streams_info_table,
+                         const std::vector<std::vector<int>>& proc_type_table,
+                         const std::vector<std::vector<int>>& streams_info_table,
                          StreamCreateType& stream_type,
                          int& concurrency,
-                         int& core_type,
+                         std::vector<int>& core_types,
                          int& numa_node_id,
                          int& socket_id,
                          int& max_threads_per_core) {
+    const auto append_core_type = [](std::vector<int>& proc_core_types, int proc_core_type) {
+        if (std::find(proc_core_types.begin(), proc_core_types.end(), proc_core_type) == proc_core_types.end()) {
+            proc_core_types.push_back(proc_core_type);
+        }
+    };
+    const auto get_bindable_core_type_count = [](const std::vector<std::vector<int>>& available_proc_type_table) {
+        if (available_proc_type_table.empty()) {
+            return 0;
+        }
+
+        return static_cast<int>(available_proc_type_table[0][MAIN_CORE_PROC] > 0) +
+               static_cast<int>(available_proc_type_table[0][EFFICIENT_CORE_PROC] > 0) +
+               static_cast<int>(available_proc_type_table[0][LP_EFFICIENT_CORE_PROC] > 0);
+    };
+
     int stream_total = 0;
     size_t stream_info_id = 0;
     bool pinning = cpu_pinning;
-    bool ecore_used = false;
+    core_types.clear();
     for (size_t i = 0; i < streams_info_table.size(); i++) {
         stream_total += std::abs(streams_info_table[i][NUMBER_OF_STREAMS]);
         if (stream_id < stream_total) {
@@ -35,42 +50,46 @@ void get_cur_stream_info(const int stream_id,
         }
     }
     concurrency = streams_info_table[stream_info_id][THREADS_PER_STREAM];
-    core_type = streams_info_table[stream_info_id][PROC_TYPE];
+    int core_type = streams_info_table[stream_info_id][PROC_TYPE];
     numa_node_id = streams_info_table[stream_info_id][STREAM_NUMA_NODE_ID];
     socket_id = streams_info_table[stream_info_id][STREAM_SOCKET_ID];
     max_threads_per_core = 1;
     if (core_type == ALL_PROC) {
         for (size_t i = stream_info_id + 1; i < streams_info_table.size(); i++) {
             if (streams_info_table[i][NUMBER_OF_STREAMS] == 0) {
-                if (streams_info_table[i][PROC_TYPE] == EFFICIENT_CORE_PROC) {
-                    ecore_used = true;
-                } else if (streams_info_table[i][PROC_TYPE] == HYPER_THREADING_PROC) {
+                if (streams_info_table[i][PROC_TYPE] == HYPER_THREADING_PROC) {
                     max_threads_per_core = 2;
+                    append_core_type(core_types, MAIN_CORE_PROC);
+                } else {
+                    append_core_type(core_types, streams_info_table[i][PROC_TYPE]);
                 }
             } else {
                 break;
             }
         }
     } else if (core_type == HYPER_THREADING_PROC) {
         max_threads_per_core = 2;
+        append_core_type(core_types, MAIN_CORE_PROC);
     }
 
 #if defined(__APPLE__)
     pinning = false;
 #endif
+    if (core_type != ALL_PROC && core_types.empty()) {
+        append_core_type(core_types, core_type == HYPER_THREADING_PROC ? MAIN_CORE_PROC : core_type);
+    }
+
     if (pinning) {
         stream_type = STREAM_WITH_OBSERVE;
     } else {
         stream_type = STREAM_WITHOUT_PARAM;
         // Pcore only or Ecore only with no cpu binding in hybrid cores machine
-        if ((proc_type_table[0][EFFICIENT_CORE_PROC] > 0 || proc_type_table[0][LP_EFFICIENT_CORE_PROC] > 0) &&
-            core_type != ALL_PROC) {
-            stream_type = STREAM_WITH_CORE_TYPE;
-        } else if ((proc_type_table[0][EFFICIENT_CORE_PROC] > 0 || proc_type_table[0][LP_EFFICIENT_CORE_PROC] > 0) &&
-                   core_type == ALL_PROC &&
-                   !ecore_used) {  // Latency mode and enable hyper threading in hybrid cores machine
-            stream_type = STREAM_WITH_CORE_TYPE;
-            core_type = MAIN_CORE_PROC;
+        if (!proc_type_table.empty() &&
+            (proc_type_table[0][EFFICIENT_CORE_PROC] > 0 || proc_type_table[0][LP_EFFICIENT_CORE_PROC] > 0)) {
+            const auto bindable_core_types = get_bindable_core_type_count(proc_type_table);
+            if (!core_types.empty() && core_types.size() < static_cast<size_t>(bindable_core_types)) {
+                stream_type = STREAM_WITH_CORE_TYPE;
+            }
         } else if (proc_type_table.size() > 1 && numa_node_id >= 0 &&
                    // Both commands "numactl" and "docker run --cpuset-cpus" can restrict the use of numa nodes.
                    // Some situation of numa_node_id differs from the original numa_node_id may cause oneTBB to crash

src/inference/src/dev/threading/parallel_custom_arena.hpp

@@ -29,7 +29,6 @@
 // In this case, tbbbind static library is needed.
 #    define USE_TBBBIND_2_5 TBBBIND_2_5_AVAILABLE
 
-constexpr int MIN_CORE_TYPES_FOR_PTL = 3;
 constexpr int TBB_VERSION_MAJOR_CORE_TYPES_WINDOWS = 1202;
 constexpr int TBB_VERSION_PATCH_CORE_TYPES_WINDOWS = 6;
 constexpr int TBB_VERSION_MAJOR_CORE_TYPES_LINUX = 1213;