[CPU] New plugin config impl

Author: dmitry-gorokhov

src/inference/CMakeLists.txt

@@ -87,6 +87,7 @@ target_include_directories(${TARGET_NAME}_obj SYSTEM PRIVATE
 target_include_directories(${TARGET_NAME}_obj PRIVATE
     "${CMAKE_CURRENT_SOURCE_DIR}/src"
     $<TARGET_PROPERTY:openvino::runtime::dev,INTERFACE_INCLUDE_DIRECTORIES>
+    $<TARGET_PROPERTY:openvino::shape_inference,INTERFACE_INCLUDE_DIRECTORIES>
     $<$<TARGET_EXISTS:openvino_proxy_plugin_obj>:$<TARGET_PROPERTY:openvino_proxy_plugin_obj,INTERFACE_INCLUDE_DIRECTORIES>>
     # for ov_plugins.hpp
     $<IF:$<AND:$<BOOL:${OV_GENERATOR_MULTI_CONFIG}>,$<VERSION_GREATER_EQUAL:${CMAKE_VERSION},3.20>>,${CMAKE_CURRENT_BINARY_DIR}/$<CONFIG>,${CMAKE_CURRENT_BINARY_DIR}>)
@@ -105,7 +106,7 @@ endif()
 # Create library file from object library
 
 add_library(${TARGET_NAME} INTERFACE)
-target_link_libraries(${TARGET_NAME} INTERFACE openvino::runtime)
+target_link_libraries(${TARGET_NAME} INTERFACE openvino::runtime openvino::shape_inference)
 target_include_directories(${TARGET_NAME} INTERFACE $<BUILD_INTERFACE:${PUBLIC_HEADERS_DIR}>)
 
 ov_add_clang_format_target(${TARGET_NAME}_clang FOR_SOURCES ${LIBRARY_SRC} ${LIBRARY_HEADERS} ${PUBLIC_HEADERS})
@@ -126,10 +127,11 @@ if (TBBBIND_2_5_FOUND)
 endif()
 
 target_include_directories(${TARGET_NAME}_s PUBLIC
-    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src>)
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src>
+    $<TARGET_PROPERTY:openvino::shape_inference,INTERFACE_INCLUDE_DIRECTORIES>)
 
 target_link_libraries(${TARGET_NAME}_s PRIVATE openvino::itt ${CMAKE_DL_LIBS}
-    openvino::runtime::dev openvino::pugixml)
+    openvino::runtime::dev openvino::pugixml openvino::shape_inference)
 
 target_compile_definitions(${TARGET_NAME}_s PUBLIC USE_STATIC_IE)
 

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

@@ -181,6 +181,12 @@ class OPENVINO_RUNTIME_API PluginConfig {
         m_options_map.emplace(name, ptr);
     }
 
+    // TODO: move to protected
+    template <typename T, PropertyMutability mutability>
+    bool is_set_by_user(const ov::Property<T, mutability>& property) const {
+        return m_user_properties.find(property.name()) != m_user_properties.end();
+    }
+
 protected:
     template <typename OptionType>
     class GlobalOptionInitializer {
@@ -203,13 +209,10 @@ class OPENVINO_RUNTIME_API PluginConfig {
     void apply_config_options(std::string_view device_name, std::filesystem::path config_path = "");
     virtual void finalize_impl(const IRemoteContext* context) {}
 
-    template <typename T, PropertyMutability mutability>
-    bool is_set_by_user(const ov::Property<T, mutability>& property) const {
-        return m_user_properties.find(property.name()) != m_user_properties.end();
-    }
-
+protected:
     ConfigOptionBase* get_option_ptr(const std::string& name) const {
         auto it = m_options_map.find(name);
+        // TODO: print more meaningful error message
         OPENVINO_ASSERT(it != m_options_map.end(), "Option not found: ", name);
         OPENVINO_ASSERT(it->second != nullptr, "Option is invalid: ", name);
 

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

@@ -1230,7 +1230,7 @@ namespace streams {
  * @ingroup ov_runtime_cpp_prop_api
  */
 struct Num {
-    using Base = std::tuple<int32_t>;  //!< NumStreams is representable as int32_t
+    // using Base = std::tuple<int32_t>;  //!< NumStreams is representable as int32_t
 
     constexpr Num() : num{-1} {};
 

src/plugins/intel_cpu/CMakeLists.txt

@@ -160,6 +160,7 @@ if(WIN32)
 endif()
 
 if(ENABLE_CPU_DEBUG_CAPS)
+    add_definitions(-DENABLE_DEBUG_CAPS)
     add_definitions(-DCPU_DEBUG_CAPS)
 endif()
 
@@ -370,11 +371,11 @@ if(BUILD_SHARED_LIBS)
         PRIVATE
             $<TARGET_PROPERTY:openvino::runtime::dev,INTERFACE_INCLUDE_DIRECTORIES>
             $<TARGET_PROPERTY:openvino::itt,INTERFACE_INCLUDE_DIRECTORIES>
-            $<TARGET_PROPERTY:openvino::shape_inference,INTERFACE_INCLUDE_DIRECTORIES>
             $<TARGET_PROPERTY:openvino::snippets,INTERFACE_INCLUDE_DIRECTORIES>
             $<TARGET_PROPERTY:openvino::reference,INTERFACE_INCLUDE_DIRECTORIES>
         PUBLIC
             ${CMAKE_CURRENT_SOURCE_DIR}/src
+            $<TARGET_PROPERTY:openvino::shape_inference,INTERFACE_INCLUDE_DIRECTORIES>
             $<TARGET_PROPERTY:openvino::conditional_compilation,INTERFACE_INCLUDE_DIRECTORIES>)
 
     target_include_directories(${TARGET_NAME}_obj SYSTEM PUBLIC $<TARGET_PROPERTY:dnnl,INCLUDE_DIRECTORIES>)

src/plugins/intel_cpu/src/compiled_model.cpp

@@ -55,15 +55,17 @@ CompiledModel::CompiledModel(const std::shared_ptr<ov::Model>& model,
       m_cfg{std::move(cfg)},
       m_name{model->get_name()},
       m_loaded_from_cache(loaded_from_cache),
-      m_sub_memory_manager(std::move(sub_memory_manager)) {
+      m_sub_memory_manager(std::move(sub_memory_manager)),
+      m_model_name(model->get_friendly_name()) {
     m_mutex = std::make_shared<std::mutex>();
     const auto& core = m_plugin->get_core();
     if (!core) {
         OPENVINO_THROW("Unable to get API version. Core is unavailable");
     }
 
+
     IStreamsExecutor::Config executor_config;
-    if (m_cfg.exclusiveAsyncRequests) {
+    if (m_cfg.get_exclusive_async_requests()) {
         // special case when all InferRequests are muxed into a single queue
         m_task_executor = m_plugin->get_executor_manager()->get_executor("CPU");
     } else {
@@ -162,7 +164,7 @@ CompiledModel::GraphGuard::Lock CompiledModel::get_graph() const {
                 GraphContext::Ptr ctx;
                 {
                     std::lock_guard<std::mutex> lock{*m_mutex.get()};
-                    auto isQuantizedFlag = (m_cfg.lpTransformsMode == Config::On) &&
+                    auto isQuantizedFlag = (m_cfg.get_enable_lp_transformations()) &&
                                            ov::pass::low_precision::LowPrecision::isFunctionQuantized(m_model);
                     ctx = std::make_shared<GraphContext>(m_cfg,
                                                          m_socketWeights[socketId],
@@ -229,16 +231,16 @@ ov::Any CompiledModel::get_property(const std::string& name) const {
         return m_loaded_from_cache;
     }
 
-    Config engConfig = get_graph()._graph.getConfig();
-    auto option = engConfig._config.find(name);
-    if (option != engConfig._config.end()) {
-        return option->second;
-    }
+    // Config engConfig = get_graph()._graph.getConfig();
+    // auto option = engConfig._config.find(name);
+    // if (option != engConfig._config.end()) {
+    //     return option->second;
+    // }
 
-    // @todo Can't we just use local copy (_cfg) instead?
-    auto graphLock = get_graph();
-    const auto& graph = graphLock._graph;
-    const auto& config = graph.getConfig();
+    // // @todo Can't we just use local copy (_cfg) instead?
+    // auto graphLock = get_graph();
+    // const auto& graph = graphLock._graph;
+    // const auto& config = graph.getConfig();
 
     auto RO_property = [](const std::string& propertyName) {
         return ov::PropertyName(propertyName, ov::PropertyMutability::RO);
@@ -277,98 +279,25 @@ ov::Any CompiledModel::get_property(const std::string& name) const {
     }
 
     if (name == ov::model_name) {
-        // @todo Does not seem ok to 'dump()' the whole graph everytime in order to get a name
-        const std::string modelName = graph.dump()->get_friendly_name();
-        return decltype(ov::model_name)::value_type(modelName);
+        return decltype(ov::model_name)::value_type {m_model_name};
+    }
+    if (name == ov::loaded_from_cache) {
+        return decltype(ov::loaded_from_cache)::value_type {m_loaded_from_cache};
     }
     if (name == ov::optimal_number_of_infer_requests) {
-        const auto streams = config.streamExecutorConfig.get_streams();
-        return static_cast<decltype(ov::optimal_number_of_infer_requests)::value_type>(
+        const auto streams = m_cfg.streamExecutorConfig.get_streams();
+        return decltype(ov::optimal_number_of_infer_requests)::value_type(
             streams > 0 ? streams : 1);  // ov::optimal_number_of_infer_requests has no negative values
     }
-    if (name == ov::num_streams) {
-        const auto streams = config.streamExecutorConfig.get_streams();
-        return decltype(ov::num_streams)::value_type(
-            streams);  // ov::num_streams has special negative values (AUTO = -1, NUMA = -2)
-    }
-    if (name == ov::inference_num_threads) {
-        const auto num_threads = config.streamExecutorConfig.get_threads();
-        return static_cast<decltype(ov::inference_num_threads)::value_type>(num_threads);
-    }
-    if (name == ov::enable_profiling.name()) {
-        const bool perfCount = config.collectPerfCounters;
-        return static_cast<decltype(ov::enable_profiling)::value_type>(perfCount);
-    }
-    if (name == ov::hint::inference_precision) {
-        return decltype(ov::hint::inference_precision)::value_type(config.inferencePrecision);
-    }
-    if (name == ov::hint::performance_mode) {
-        return static_cast<decltype(ov::hint::performance_mode)::value_type>(config.hintPerfMode);
-    }
-    if (name == ov::log::level) {
-        return static_cast<decltype(ov::log::level)::value_type>(config.logLevel);
-    }
-    if (name == ov::hint::enable_cpu_pinning.name()) {
-        const bool use_pin = config.enableCpuPinning;
-        return static_cast<decltype(ov::hint::enable_cpu_pinning)::value_type>(use_pin);
-    }
-    if (name == ov::hint::enable_cpu_reservation.name()) {
-        const bool use_reserve = config.enableCpuReservation;
-        return static_cast<decltype(ov::hint::enable_cpu_reservation)::value_type>(use_reserve);
-    }
-    if (name == ov::hint::scheduling_core_type) {
-        const auto stream_mode = config.schedulingCoreType;
-        return stream_mode;
-    }
-    if (name == ov::hint::model_distribution_policy) {
-        const auto& distribution_policy = config.modelDistributionPolicy;
-        return distribution_policy;
-    }
-    if (name == ov::hint::enable_hyper_threading.name()) {
-        const bool use_ht = config.enableHyperThreading;
-        return static_cast<decltype(ov::hint::enable_hyper_threading)::value_type>(use_ht);
-    }
-    if (name == ov::hint::execution_mode) {
-        return config.executionMode;
-    }
-    if (name == ov::hint::num_requests) {
-        return static_cast<decltype(ov::hint::num_requests)::value_type>(config.hintNumRequests);
-    }
     if (name == ov::execution_devices) {
         return decltype(ov::execution_devices)::value_type{m_plugin->get_device_name()};
     }
-    if (name == ov::intel_cpu::denormals_optimization) {
-        return static_cast<decltype(ov::intel_cpu::denormals_optimization)::value_type>(
-            config.denormalsOptMode == Config::DenormalsOptMode::DO_On);
-    }
-    if (name == ov::intel_cpu::sparse_weights_decompression_rate) {
-        return static_cast<decltype(ov::intel_cpu::sparse_weights_decompression_rate)::value_type>(
-            config.fcSparseWeiDecompressionRate);
-    }
-    if (name == ov::hint::dynamic_quantization_group_size) {
-        return static_cast<decltype(ov::hint::dynamic_quantization_group_size)::value_type>(
-            config.fcDynamicQuantizationGroupSize);
-    }
-    if (name == ov::hint::kv_cache_precision) {
-        return decltype(ov::hint::kv_cache_precision)::value_type(config.kvCachePrecision);
-    }
-    if (name == ov::key_cache_precision) {
-        return decltype(ov::key_cache_precision)::value_type(config.keyCachePrecision);
-    }
-    if (name == ov::value_cache_precision) {
-        return decltype(ov::value_cache_precision)::value_type(config.valueCachePrecision);
-    }
-    if (name == ov::key_cache_group_size) {
-        return static_cast<decltype(ov::key_cache_group_size)::value_type>(config.keyCacheGroupSize);
-    }
-    if (name == ov::value_cache_group_size) {
-        return static_cast<decltype(ov::value_cache_group_size)::value_type>(config.valueCacheGroupSize);
-    }
-    OPENVINO_THROW("Unsupported property: ", name);
+
+    return m_cfg.get_property(name);
 }
 
 void CompiledModel::export_model(std::ostream& modelStream) const {
-    ModelSerializer serializer(modelStream, m_cfg.cacheEncrypt);
+    ModelSerializer serializer(modelStream, m_cfg.get_cache_encryption_callbacks().encrypt);
     serializer << m_model;
 }
 

src/plugins/intel_cpu/src/compiled_model.h

@@ -100,6 +100,8 @@ class CompiledModel : public ov::ICompiledModel {
     std::vector<std::shared_ptr<CompiledModel>> m_sub_compiled_models;
     std::shared_ptr<SubMemoryManager> m_sub_memory_manager = nullptr;
     bool m_has_sub_compiled_models = false;
+
+    std::string m_model_name;
 };
 
 // This class provides safe access to the internal CompiledModel structures and helps to decouple SyncInferRequest and