[core] Split configuration for device and others in compile model

src/inference/src/dev/core_impl.cpp

@@ -38,6 +38,18 @@
 
 ov::ICore::~ICore() = default;
 
+namespace ov {
+namespace util {
+template <class T = void, class... Args>
+constexpr std::array<
+    typename std::conditional<std::is_void<T>::value, typename std::common_type<Args...>::type, T>::type,
+    sizeof...(Args)>
+make_array(Args&&... args) {
+    return {std::forward<Args>(args)...};
+}
+}  // namespace util
+}  // namespace ov
+
 namespace {
 
 #ifdef PROXY_PLUGIN_ENABLED
@@ -205,6 +217,14 @@ void clean_batch_properties(const std::string& deviceName, ov::AnyMap& config, c
         }
     }
 }
+
+constexpr bool keep_core = true;
+
+static const auto core_properties_names =
+    ov::util::make_array(ov::cache_dir.name(), ov::enable_mmap.name(), ov::force_tbb_terminate.name());
+
+static const auto auto_batch_properties_names =
+    ov::util::make_array(ov::auto_batch_timeout.name(), ov::hint::allow_auto_batching.name());
 }  // namespace
 
 bool ov::is_config_applicable(const std::string& user_device_name, const std::string& subprop_device_name) {
@@ -304,8 +324,9 @@ ov::Parsed ov::parseDeviceNameIntoConfig(const std::string& deviceName,
 
     // keep batch property only when called from query_supported_property
     if (!keep_core_property) {
-        clean_batch_properties(updated_device_name, updated_config, ov::hint::allow_auto_batching);
-        clean_batch_properties(updated_device_name, updated_config, ov::auto_batch_timeout);
+        for (const auto& name : auto_batch_properties_names) {
+            clean_batch_properties(updated_device_name, updated_config, name);
+        }
     }
 
     return {std::move(updated_device_name), std::move(updated_config)};
@@ -663,8 +684,7 @@ ov::Plugin ov::CoreImpl::get_plugin(const std::string& pluginName) const {
             {
                 OPENVINO_SUPPRESS_DEPRECATED_START
                 if (device_supports_cache_dir(plugin)) {
-                    ov::AnyMap empty_map;
-                    auto cacheConfig = coreConfig.get_cache_config_for_device(plugin, empty_map);
+                    auto cacheConfig = coreConfig.get_cache_config_for_device(plugin);
                     if (cacheConfig._cacheManager) {
                         desc.defaultConfig[ov::cache_dir.name()] = cacheConfig._cacheDir;
                     }
@@ -737,13 +757,16 @@ ov::SoPtr<ov::ICompiledModel> ov::CoreImpl::compile_model(const std::shared_ptr<
     // if auto-batching is applicable, the below function will patch the device name and config accordingly:
     auto model = apply_auto_batching(model_, deviceName, config_with_batch);
 
-    auto parsed = parseDeviceNameIntoConfig(deviceName, config_with_batch, is_proxy_device(device_name));
+    auto local_core_config = coreConfig;
+    auto parsed = parseDeviceNameIntoConfig(deviceName, config_with_batch, is_proxy_device(deviceName));
+    local_core_config.set_and_update(parsed._config);
     auto plugin = get_plugin(parsed._deviceName);
+
     ov::SoPtr<ov::ICompiledModel> res;
-    auto cacheManager = coreConfig.get_cache_config_for_device(plugin, parsed._config)._cacheManager;
+    auto cacheManager = local_core_config.get_cache_config_for_device(plugin)._cacheManager;
     // Skip caching for proxy plugin. HW plugin will load network from the cache
     if (cacheManager && device_supports_model_caching(plugin) && !is_proxy_device(plugin)) {
-        CacheContent cacheContent{cacheManager};
+        CacheContent cacheContent{cacheManager, local_core_config.get_enable_mmap()};
         cacheContent.blobId = ov::ModelCache::compute_hash(model, create_compile_config(plugin, parsed._config));
         std::unique_ptr<CacheGuardEntry> lock = cacheGuard.get_hash_lock(cacheContent.blobId);
         res = load_model_from_cache(cacheContent, plugin, parsed._config, ov::SoPtr<ov::IRemoteContext>{}, [&]() {
@@ -770,13 +793,16 @@ ov::SoPtr<ov::ICompiledModel> ov::CoreImpl::compile_model(const std::shared_ptr<
     // if auto-batching is applicable, the below function will patch the device name and config accordingly:
     auto model = apply_auto_batching(model_, deviceName, config_with_batch);
 
+    auto local_core_config = coreConfig;
     auto parsed = parseDeviceNameIntoConfig(deviceName, config_with_batch, is_proxy_device(deviceName));
+    local_core_config.set_and_update(parsed._config);
     auto plugin = get_plugin(parsed._deviceName);
+
     ov::SoPtr<ov::ICompiledModel> res;
-    auto cacheManager = coreConfig.get_cache_config_for_device(plugin, parsed._config)._cacheManager;
+    auto cacheManager = local_core_config.get_cache_config_for_device(plugin)._cacheManager;
     // Skip caching for proxy plugin. HW plugin will load network from the cache
     if (cacheManager && device_supports_model_caching(plugin) && !is_proxy_device(plugin)) {
-        CacheContent cacheContent{cacheManager};
+        CacheContent cacheContent{cacheManager, local_core_config.get_enable_mmap()};
         cacheContent.blobId = ov::ModelCache::compute_hash(model, create_compile_config(plugin, parsed._config));
         std::unique_ptr<CacheGuardEntry> lock = cacheGuard.get_hash_lock(cacheContent.blobId);
         res = load_model_from_cache(cacheContent, plugin, parsed._config, context, [&]() {
@@ -792,21 +818,23 @@ ov::SoPtr<ov::ICompiledModel> ov::CoreImpl::compile_model(const std::string& mod
                                                           const std::string& device_name,
                                                           const ov::AnyMap& config) const {
     OV_ITT_SCOPE(FIRST_INFERENCE, ov::itt::domains::LoadTime, "Core::compile_model::Path");
-    auto parsed = parseDeviceNameIntoConfig(device_name, config);
+    auto parsed = parseDeviceNameIntoConfig(device_name, config, keep_core);
+    auto local_core_config = coreConfig;
     // in case of compile_model(file_name), we need to clear-up core-level properties
+    local_core_config.set_and_update(parsed._config);
     auto plugin = get_plugin(parsed._deviceName);
-    ov::SoPtr<ov::ICompiledModel> compiled_model;
-
-    auto cacheManager = coreConfig.get_cache_config_for_device(plugin, parsed._config)._cacheManager;
 
+    ov::SoPtr<ov::ICompiledModel> compiled_model;
+    auto cacheManager = local_core_config.get_cache_config_for_device(plugin)._cacheManager;
+    // Skip caching for proxy plugin. HW plugin will load network from the cache
     if (cacheManager && device_supports_model_caching(plugin) && !is_proxy_device(plugin)) {
-        // Skip caching for proxy plugin. HW plugin will load network from the cache
-        CacheContent cacheContent{cacheManager, model_path};
+        CacheContent cacheContent{cacheManager, local_core_config.get_enable_mmap(), model_path};
         cacheContent.blobId = ov::ModelCache::compute_hash(model_path, create_compile_config(plugin, parsed._config));
         std::unique_ptr<CacheGuardEntry> lock = cacheGuard.get_hash_lock(cacheContent.blobId);
         compiled_model =
             load_model_from_cache(cacheContent, plugin, parsed._config, ov::SoPtr<ov::IRemoteContext>{}, [&]() {
-                auto model = read_model(model_path, std::string{});
+                auto model =
+                    ov::util::read_model(model_path, std::string{}, extensions, local_core_config.get_enable_mmap());
                 return compile_model_and_cache(plugin, model, parsed._config, {}, cacheContent);
             });
     } else {
@@ -820,15 +848,16 @@ ov::SoPtr<ov::ICompiledModel> ov::CoreImpl::compile_model(const std::string& mod
                                                           const std::string& device_name,
                                                           const ov::AnyMap& config) const {
     OV_ITT_SCOPED_TASK(ov::itt::domains::OV, "Core::compile_model::from_memory");
-    auto parsed = parseDeviceNameIntoConfig(device_name, config);
-    // in case of compile_model(file_name), we need to clear-up core-level properties
+    auto parsed = parseDeviceNameIntoConfig(device_name, config, keep_core);
+    auto local_core_config = coreConfig;
+    local_core_config.set_and_update(parsed._config);
     auto plugin = get_plugin(parsed._deviceName);
-    ov::SoPtr<ov::ICompiledModel> compiled_model;
 
-    auto cacheManager = coreConfig.get_cache_config_for_device(plugin, parsed._config)._cacheManager;
+    ov::SoPtr<ov::ICompiledModel> compiled_model;
+    auto cacheManager = local_core_config.get_cache_config_for_device(plugin)._cacheManager;
     // Skip caching for proxy plugin. HW plugin will load network from the cache
     if (cacheManager && device_supports_model_caching(plugin) && !is_proxy_device(plugin)) {
-        CacheContent cacheContent{cacheManager};
+        CacheContent cacheContent{cacheManager, local_core_config.get_enable_mmap()};
         cacheContent.blobId =
             ov::ModelCache::compute_hash(model_str, weights, create_compile_config(plugin, parsed._config));
         std::unique_ptr<CacheGuardEntry> lock = cacheGuard.get_hash_lock(cacheContent.blobId);
@@ -948,7 +977,7 @@ ov::AnyMap ov::CoreImpl::get_supported_property(const std::string& full_device_n
         // ov::device::priority cannot be shared, because it's specific for current virtual
         // plugin. So, we need to remove ov::device::priorities from the list, because it's
         // supposed to be set for current virtual plugin and cannot be propagated down
-        ov::AnyMap return_properties = user_properties;
+        auto return_properties = user_properties;
         auto device_priorities_it = return_properties.find(ov::device::priorities.name());
         if (device_priorities_it != return_properties.end()) {
             return_properties.erase(device_priorities_it);
@@ -957,23 +986,17 @@ ov::AnyMap ov::CoreImpl::get_supported_property(const std::string& full_device_n
         return return_properties;
     }
 
-    static const std::vector<std::string> core_level_properties = {
-        ov::cache_dir.name(),
-        ov::force_tbb_terminate.name(),
-        // auto-batch properties are also treated as core-level
-        ov::auto_batch_timeout.name(),
-        ov::hint::allow_auto_batching.name(),
-    };
-
-    const auto flattened = ov::parseDeviceNameIntoConfig(full_device_name, user_properties, true);
-    const std::string& device_name = flattened._deviceName;
+    const auto flattened = parseDeviceNameIntoConfig(full_device_name, user_properties, keep_core_property);
     const auto& flattened_config = flattened._config;
+    const auto& device_name = flattened._deviceName;
 
     // virtual plugins should bypass core-level properties to HW plugins
     // so, we need to report them as supported
     std::vector<std::string> supported_config_keys;
-    if (keep_core_property) {
-        supported_config_keys = core_level_properties;
+    if (keep_core) {
+        auto last = supported_config_keys.end();
+        last = supported_config_keys.insert(last, core_properties_names.begin(), core_properties_names.end());
+        supported_config_keys.insert(last, auto_batch_properties_names.begin(), auto_batch_properties_names.end());
     }
 
     // try to search against OV API 2.0' mutable supported_properties
@@ -1160,8 +1183,7 @@ ov::Any ov::CoreImpl::get_property(const std::string& device_name,
     if (parsed._deviceName.empty()) {
         return get_property_for_core(name);
     } else if (name == ov::cache_dir.name()) {
-        ov::AnyMap empty_map;
-        return coreConfig.get_cache_config_for_device(get_plugin(parsed._deviceName), empty_map)._cacheDir;
+        return coreConfig.get_cache_config_for_device(get_plugin(parsed._deviceName))._cacheDir;
     }
     return get_plugin(parsed._deviceName).get_property(name, parsed._config);
 }
@@ -1299,9 +1321,7 @@ void ov::CoreImpl::set_property_for_device(const ov::AnyMap& configMap, const st
             {
                 OPENVINO_SUPPRESS_DEPRECATED_START
                 if (device_supports_cache_dir(plugin.second)) {
-                    ov::AnyMap empty_map = {};
-                    configCopy[ov::cache_dir.name()] =
-                        coreConfig.get_cache_config_for_device(plugin.second, empty_map)._cacheDir;
+                    configCopy[ov::cache_dir.name()] = coreConfig.get_cache_config_for_device(plugin.second)._cacheDir;
                 } else if (configCopy.count(ov::cache_dir.name()) > 0) {
                     // Remove "CACHE_DIR" from config if it is not supported by plugin
                     configCopy.erase(ov::cache_dir.name());
@@ -1411,8 +1431,8 @@ ov::SoPtr<ov::ICompiledModel> ov::CoreImpl::load_model_from_cache(
     try {
         cacheContent.cacheManager->read_cache_entry(
             cacheContent.blobId,
-            coreConfig.get_enable_mmap() && ov::util::contains(plugin.get_property(ov::internal::supported_properties),
-                                                               ov::internal::caching_with_mmap),
+            cacheContent.mmap_enabled && ov::util::contains(plugin.get_property(ov::internal::supported_properties),
+                                                            ov::internal::caching_with_mmap),
             [&](std::istream& networkStream) {
                 OV_ITT_SCOPE(FIRST_INFERENCE,
                              ov::itt::domains::LoadTime,
@@ -1513,6 +1533,15 @@ ov::AnyMap ov::CoreImpl::create_compile_config(const ov::Plugin& plugin, const o
     return compile_config;
 }
 
+ov::CoreImpl::CoreConfig::CoreConfig(const CoreConfig& other) {
+    {
+        std::lock_guard<std::mutex> lock(other._cacheConfigMutex);
+        _cacheConfig = other._cacheConfig;
+        _cacheConfigPerDevice = other._cacheConfigPerDevice;
+    }
+    _flag_enable_mmap = other._flag_enable_mmap;
+}
+
 void ov::CoreImpl::CoreConfig::set_and_update(ov::AnyMap& config) {
     auto it = config.find(ov::cache_dir.name());
     if (it != config.end()) {
@@ -1555,30 +1584,10 @@ bool ov::CoreImpl::CoreConfig::get_enable_mmap() const {
     return _flag_enable_mmap;
 }
 
-// Creating thread-safe copy of config including shared_ptr to ICacheManager
-// Passing empty or not-existing name will return global cache config
 ov::CoreImpl::CoreConfig::CacheConfig ov::CoreImpl::CoreConfig::get_cache_config_for_device(
-    const ov::Plugin& plugin,
-    ov::AnyMap& parsedConfig) const {
-    // cache_dir is enabled locally in compile_model only
-    if (parsedConfig.count(ov::cache_dir.name())) {
-        const auto& cache_dir_val = parsedConfig.at(ov::cache_dir.name()).as<std::string>();
-        const auto& tempConfig = CoreConfig::CacheConfig::create(cache_dir_val);
-        // if plugin does not explicitly support cache_dir, and if plugin is not virtual, we need to remove
-        // it from config
-        if (!util::contains(plugin.get_property(ov::supported_properties), ov::cache_dir) &&
-            !is_virtual_device(plugin.get_name())) {
-            parsedConfig.erase(ov::cache_dir.name());
-        }
-        return tempConfig;
-    } else {  // cache_dir is set to Core globally or for the specific device
-        std::lock_guard<std::mutex> lock(_cacheConfigMutex);
-        if (_cacheConfigPerDevice.count(plugin.get_name()) > 0) {
-            return _cacheConfigPerDevice.at(plugin.get_name());
-        } else {
-            return _cacheConfig;
-        }
-    }
+    const ov::Plugin& plugin) const {
+    std::lock_guard<std::mutex> lock(_cacheConfigMutex);
+    return _cacheConfigPerDevice.count(plugin.get_name()) ? _cacheConfigPerDevice.at(plugin.get_name()) : _cacheConfig;
 }
 
 ov::CoreImpl::CoreConfig::CacheConfig ov::CoreImpl::CoreConfig::CacheConfig::create(const std::string& dir) {

src/inference/src/dev/core_impl.hpp

@@ -63,6 +63,9 @@ class CoreImpl : public ov::ICore, public std::enable_shared_from_this<ov::ICore
 
     class CoreConfig final {
     public:
+        CoreConfig() = default;
+        CoreConfig(const CoreConfig& other);
+
         struct CacheConfig {
             std::string _cacheDir;
             std::shared_ptr<ov::ICacheManager> _cacheManager;
@@ -83,9 +86,8 @@ class CoreImpl : public ov::ICore, public std::enable_shared_from_this<ov::ICore
 
         bool get_enable_mmap() const;
 
-        // Creating thread-safe copy of config including shared_ptr to ICacheManager
-        // Passing empty or not-existing name will return global cache config
-        CacheConfig get_cache_config_for_device(const ov::Plugin& plugin, ov::AnyMap& parsedConfig) const;
+        // Creating thread-safe copy of global config including shared_ptr to ICacheManager
+        CacheConfig get_cache_config_for_device(const ov::Plugin& plugin) const;
 
     private:
         mutable std::mutex _cacheConfigMutex;
@@ -96,12 +98,15 @@ class CoreImpl : public ov::ICore, public std::enable_shared_from_this<ov::ICore
 
     struct CacheContent {
         explicit CacheContent(const std::shared_ptr<ov::ICacheManager>& cache_manager,
+                              bool mmap_enabled = false,
                               const std::string model_path = {})
             : cacheManager(cache_manager),
-              modelPath(model_path) {}
+              modelPath(model_path),
+              mmap_enabled{mmap_enabled} {}
         std::shared_ptr<ov::ICacheManager> cacheManager;
         std::string blobId = {};
         std::string modelPath = {};
+        bool mmap_enabled = false;
     };
 
     // Core settings (cache config, etc)
@@ -291,7 +296,9 @@ class CoreImpl : public ov::ICore, public std::enable_shared_from_this<ov::ICore
 
     ov::SoPtr<ov::IRemoteContext> create_context(const std::string& device_name, const AnyMap& args) const override;
 
-    ov::AnyMap get_supported_property(const std::string& device_name, const ov::AnyMap& config, const bool keep_core_property = true) const override;
+    ov::AnyMap get_supported_property(const std::string& device_name,
+                                      const ov::AnyMap& config,
+                                      const bool keep_core_property = true) const override;
 
     ov::SoPtr<ov::IRemoteContext> get_default_context(const std::string& device_name) const override;
 

src/plugins/auto/tests/functional/behavior/caching_test.cpp

@@ -190,4 +190,4 @@ TEST_F(AutoFuncTests, compiled_with_cache_enabled_batch_enabled) {
     ASSERT_EQ(ov::test::utils::listFilesWithExt(cache_path, "blob").size(), 5);
     core.set_property(ov::cache_dir(""));
 #endif
-}
+}

src/plugins/auto_batch/src/plugin.hpp

@@ -68,4 +68,4 @@ class Plugin : public ov::IPlugin {
     mutable ov::AnyMap m_plugin_config;
 };
 }  // namespace autobatch_plugin
-}  // namespace ov
+}  // namespace ov

src/plugins/intel_gpu/src/plugin/plugin.cpp

@@ -598,6 +598,7 @@ std::vector<ov::PropertyName> Plugin::get_supported_properties() const {
         ov::PropertyName{ov::hint::dynamic_quantization_group_size.name(), PropertyMutability::RW},
         ov::PropertyName{ov::hint::activations_scale_factor.name(), PropertyMutability::RW},
         ov::PropertyName{ov::weights_path.name(), PropertyMutability::RW},
+        ov::PropertyName{ov::hint::kv_cache_precision.name(), PropertyMutability::RW},
     };
 
     return supported_properties;