[AUTO] Refine the logic of creating HW plugins in AUTO (openvinotoolkit#27691)

### Details:
- The core needs to pass the `ov::device::priorities` into meta plugin
to avoid creating the unnecessary HW plugin when the core is checking if
meta plugin supports caching property.
- AUTO only creates/holds the HW plugins based on the device list that
is specified from user
- AUTO collects the capabilities from specified device candidate list
rather than from all of registered devices in core.

### Tickets:
 - CVS-157496

---------

Co-authored-by: Wanglei Shen <wanglei.shen@intel.com>

Author: yangwang201911

src/inference/src/dev/core_impl.cpp

@@ -774,7 +774,7 @@ ov::SoPtr<ov::ICompiledModel> ov::CoreImpl::compile_model(const std::shared_ptr<
     // will consume ov::cache_dir if plugin not support it
     auto cacheManager = parsed._core_config.get_cache_config_for_device(plugin, parsed._config)._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)) {
+    if (cacheManager && device_supports_model_caching(plugin, parsed._config) && !is_proxy_device(plugin)) {
         CacheContent cacheContent{cacheManager, parsed._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);
@@ -808,7 +808,7 @@ ov::SoPtr<ov::ICompiledModel> ov::CoreImpl::compile_model(const std::shared_ptr<
     // will consume ov::cache_dir if plugin not support it
     auto cacheManager = parsed._core_config.get_cache_config_for_device(plugin, parsed._config)._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)) {
+    if (cacheManager && device_supports_model_caching(plugin, parsed._config) && !is_proxy_device(plugin)) {
         CacheContent cacheContent{cacheManager, parsed._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);
@@ -832,7 +832,7 @@ ov::SoPtr<ov::ICompiledModel> ov::CoreImpl::compile_model(const std::string& mod
     // will consume ov::cache_dir if plugin not support it
     auto cacheManager = parsed._core_config.get_cache_config_for_device(plugin, parsed._config)._cacheManager;
 
-    if (cacheManager && device_supports_model_caching(plugin) && !is_proxy_device(plugin)) {
+    if (cacheManager && device_supports_model_caching(plugin, parsed._config) && !is_proxy_device(plugin)) {
         // Skip caching for proxy plugin. HW plugin will load network from the cache
         CoreConfig::remove_core_skip_cache_dir(parsed._config);
         CacheContent cacheContent{cacheManager, parsed._core_config.get_enable_mmap(), model_path};
@@ -860,7 +860,7 @@ ov::SoPtr<ov::ICompiledModel> ov::CoreImpl::compile_model(const std::string& mod
     // will consume ov::cache_dir if plugin not support it
     auto cacheManager = parsed._core_config.get_cache_config_for_device(plugin, parsed._config)._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)) {
+    if (cacheManager && device_supports_model_caching(plugin, parsed._config) && !is_proxy_device(plugin)) {
         CacheContent cacheContent{cacheManager, parsed._core_config.get_enable_mmap()};
         cacheContent.blobId =
             ov::ModelCache::compute_hash(model_str, weights, create_compile_config(plugin, parsed._config));
@@ -1378,8 +1378,8 @@ bool ov::CoreImpl::device_supports_internal_property(const ov::Plugin& plugin, c
     return util::contains(plugin.get_property(ov::internal::supported_properties), key);
 }
 
-bool ov::CoreImpl::device_supports_model_caching(const ov::Plugin& plugin) const {
-    return plugin.supports_model_caching();
+bool ov::CoreImpl::device_supports_model_caching(const ov::Plugin& plugin, const ov::AnyMap& arguments) const {
+    return plugin.supports_model_caching(arguments);
 }
 
 bool ov::CoreImpl::device_supports_cache_dir(const ov::Plugin& plugin) const {

src/inference/src/dev/core_impl.hpp

@@ -216,7 +216,7 @@ class CoreImpl : public ov::ICore, public std::enable_shared_from_this<ov::ICore
         const ov::SoPtr<ov::IRemoteContext>& context,
         std::function<ov::SoPtr<ov::ICompiledModel>()> compile_model_lambda) const;
 
-    bool device_supports_model_caching(const ov::Plugin& plugin) const;
+    bool device_supports_model_caching(const ov::Plugin& plugin, const ov::AnyMap& origConfig = {}) const;
 
     bool device_supports_property(const ov::Plugin& plugin, const ov::PropertyName& key) const;
     bool device_supports_internal_property(const ov::Plugin& plugin, const ov::PropertyName& key) const;

src/inference/src/dev/plugin.cpp

@@ -101,10 +101,11 @@ ov::Any ov::Plugin::get_property(const std::string& name, const AnyMap& argument
     return {m_ptr->get_property(name, arguments), {m_so}};
 }
 
-bool ov::Plugin::supports_model_caching() const {
+bool ov::Plugin::supports_model_caching(const ov::AnyMap& arguments) const {
     bool supported(false);
-    supported = util::contains(get_property(ov::supported_properties), ov::device::capabilities) &&
-                util::contains(get_property(ov::device::capabilities), ov::device::capability::EXPORT_IMPORT) &&
-                util::contains(get_property(ov::internal::supported_properties), ov::internal::caching_properties);
+    supported =
+        util::contains(get_property(ov::supported_properties), ov::device::capabilities) &&
+        util::contains(get_property(ov::device::capabilities, arguments), ov::device::capability::EXPORT_IMPORT) &&
+        util::contains(get_property(ov::internal::supported_properties), ov::internal::caching_properties);
     return supported;
 }

src/inference/src/dev/plugin.hpp

@@ -74,7 +74,7 @@ class Plugin {
     T get_property(const ov::Property<T, M>& property, const AnyMap& arguments) const {
         return get_property(property.name(), arguments).template as<T>();
     }
-    bool supports_model_caching() const;
+    bool supports_model_caching(const AnyMap& arguments = {}) const;
 };
 
 }  // namespace ov

src/plugins/auto/src/auto_schedule.cpp

@@ -101,6 +101,8 @@ void AutoSchedule::init() {
     auto load_device_task = [&](AutoCompileContext* context_ptr, const std::shared_ptr<ov::Model>& model) {
         try_to_compile_model(*context_ptr, model);
         if (context_ptr->m_is_load_success) {
+            // release cloned model here
+            const_cast<std::shared_ptr<ov::Model>&>(model).reset();
             if (context_ptr->m_worker_name.empty()) {
                 context_ptr->m_worker_name = context_ptr->m_device_info.device_name;
             }
@@ -187,12 +189,14 @@ void AutoSchedule::init() {
         } else {
             customize_helper_context_from_cache_setting(is_actual_cpu, m_compile_context, m_context);
         }
+        std::shared_ptr<ov::Model> model;
         // initialize the rest members of load context
         for (int i = 0; i < CONTEXTNUM; i++) {
             if (m_compile_context[i].m_is_enabled) {
                 m_compile_context[i].m_future = m_compile_context[i].m_promise.get_future();
                 auto* context_ptr = &m_compile_context[i];
-                auto model = m_context->m_model;
+                // clone this model if multi HW plugins need to load model in a background thread
+                model = !model ? m_context->m_model : m_context->m_model->clone();
                 m_compile_context[i].m_task = std::bind(load_device_task, context_ptr, model);
             }
         }
@@ -297,6 +301,11 @@ void AutoSchedule::init() {
         // only one device need to compile model, do not need to compile it async
         m_compile_context[ACTUALDEVICE].m_task();
         m_passthrough_compiled_model = m_compile_context[ACTUALDEVICE].m_compiled_model;
+        if (!m_context->m_bind_buffer) {
+            m_worker_requests.clear();
+            m_idle_worker_requests.clear();
+            m_infer_pipeline_tasks_device_specific.clear();
+        }
     }
     m_context->m_hw_compiled_model = wait_first_compiled_model_ready();
 }