Merge branch 'master' into i2

Author: anikulk

pyproject.toml

@@ -23,7 +23,7 @@ dependencies = [
 
 [build-system]
 requires = [
-    "setuptools>=77,<=80.9.0", 
+    "setuptools>=77,<=82.0.0", 
     "wheel<=0.45.1",
     "cmake<=4.2.3", 
     "patchelf<=0.17.2.4; sys_platform == 'linux' and platform_machine == 'x86_64'"

src/bindings/python/constraints.txt

@@ -17,7 +17,7 @@ patchelf<=0.17.2.4
 packaging>=22.0
 
 # Frontends
-h5py>=3.1.0,<3.16.0
+h5py>=3.1.0,<3.17.0
 docopt~=0.6.2
 paddlepaddle==3.0.0
 tensorflow>=1.15.5,<2.21.0

src/common/util/include/openvino/util/mmap_object.hpp

@@ -64,19 +64,11 @@ std::shared_ptr<ov::MappedMemory> load_mmap_object(const std::filesystem::path&
  * @brief Returns mapped memory for a file from provided file handle (cross-platform).
  * Uses mmap on Linux/Unix (with file descriptor) or MapViewOfFile on Windows (with HANDLE).
  * This allows external control of file access through a callback function.
- * Do not call load_mmap_object_from_handle directly, use the template wrapper instead.
  *
  * @param handle Platform-specific file handle (int fd on Linux, HANDLE on Windows).
  * @param offset Offset in the file where the mapping starts.
  * @param size Size of the mapping. If size is std::numeric_limits<size_t>::max(), maps from offset to EOF.
  * @return MappedMemory shared ptr object which keep mmaped memory and control the lifetime.
  */
-std::shared_ptr<ov::MappedMemory> load_mmap_object_from_handle(FileHandle handle,
-                                                               size_t offset = 0,
-                                                               size_t size = auto_size);
-
-template <typename T, std::enable_if_t<std::is_same<T, FileHandle>::value, int> = 0>
-std::shared_ptr<ov::MappedMemory> load_mmap_object(T handle, size_t offset = 0, size_t size = auto_size) {
-    return load_mmap_object_from_handle(static_cast<FileHandle>(handle), offset, size);
-}
+std::shared_ptr<ov::MappedMemory> load_mmap_object(FileHandle handle, size_t offset = 0, size_t size = auto_size);
 }  // namespace ov

src/common/util/src/os/lin/lin_mmap_object.cpp

@@ -137,7 +137,7 @@ std::shared_ptr<MappedMemory> load_mmap_object(const std::filesystem::path& path
     return holder;
 }
 
-std::shared_ptr<ov::MappedMemory> load_mmap_object_from_handle(FileHandle handle, size_t offset, size_t size) {
+std::shared_ptr<ov::MappedMemory> load_mmap_object(FileHandle handle, size_t offset, size_t size) {
     if (handle == -1) {
         throw std::runtime_error("Invalid file descriptor provided for mapping.");
     }

src/common/util/src/os/win/win_mmap_object.cpp

@@ -168,7 +168,7 @@ std::shared_ptr<MappedMemory> load_mmap_object(const std::filesystem::path& path
     return holder;
 }
 
-std::shared_ptr<ov::MappedMemory> load_mmap_object_from_handle(FileHandle handle, size_t offset, size_t size) {
+std::shared_ptr<ov::MappedMemory> load_mmap_object(FileHandle handle, size_t offset, size_t size) {
     if (handle == INVALID_HANDLE_VALUE || handle == nullptr) {
         throw std::runtime_error("Invalid handle provided to load_mmap_object");
     }

src/core/tests/mmap_object.cpp

@@ -157,8 +157,8 @@ TEST_P(RangedMappingTest, compare_data) {
     } else {
         const auto handle_1 = utils::open_ro_file(m_file_path);
         const auto handle_2 = utils::open_ro_file(m_file_path);
-        mm_1 = load_mmap_object_from_handle(handle_1, offset_1, size_1);
-        mm_2 = load_mmap_object_from_handle(handle_2, offset_2, size_2);
+        mm_1 = load_mmap_object(handle_1, offset_1, size_1);
+        mm_2 = load_mmap_object(handle_2, offset_2, size_2);
     }
     ASSERT_NE(mm_1, nullptr);
     ASSERT_NE(mm_2, nullptr);
@@ -187,13 +187,13 @@ TEST_P(RangedMappingTest, compare_id) {
         mm_1_ = load_mmap_object(m_file_path, offset_1, size_1);
     } else {
         const auto handle = utils::open_ro_file(m_file_path);
-        mm_1 = load_mmap_object_from_handle(handle, offset_1, size_1);
-        mm_2 = load_mmap_object_from_handle(handle, offset_2, size_2);
+        mm_1 = load_mmap_object(handle, offset_1, size_1);
+        mm_2 = load_mmap_object(handle, offset_2, size_2);
         const auto other_handle = utils::open_ro_file(other_file_path);
-        other_mm_1 = load_mmap_object_from_handle(other_handle, offset_1, size_1);
-        other_mm_2 = load_mmap_object_from_handle(other_handle, offset_2, size_2);
+        other_mm_1 = load_mmap_object(other_handle, offset_1, size_1);
+        other_mm_2 = load_mmap_object(other_handle, offset_2, size_2);
         const auto handle_ = utils::open_ro_file(m_file_path);
-        mm_1_ = load_mmap_object_from_handle(handle_, offset_1, size_1);
+        mm_1_ = load_mmap_object(handle_, offset_1, size_1);
     }
 
     ASSERT_NE(mm_1, nullptr);

src/inference/src/dev/core_impl.cpp

@@ -876,16 +876,6 @@ ov::SoPtr<ov::ICompiledModel> ov::CoreImpl::compile_model(const std::shared_ptr<
             return ModelCache::compute_hash(model, cache_content.m_model_path, compiled_config);
         });
         cache_content.model = model;
-
-        const auto& cache_mode_it = config.find(cache_mode.name());
-        if (cache_mode_it != config.end() && cache_mode_it->second == CacheMode::OPTIMIZE_SIZE) {
-            const auto& rt_info = model->get_rt_info();
-            auto weights_path = rt_info.find("__weights_path");
-            if (weights_path != rt_info.end()) {
-                parsed.m_config[ov::weights_path.name()] = weights_path->second;
-            }
-        }
-
         const auto lock = m_cache_guard.get_hash_lock(cache_content.m_blob_id);
         compiled_model = load_model_from_cache(cache_content, plugin, parsed.m_config, {}, [&]() {
             return compile_model_and_cache(plugin, model, parsed.m_config, {}, cache_content);

src/plugins/intel_npu/src/al/include/intel_npu/config/options.hpp

@@ -1517,4 +1517,18 @@ struct DISABLE_IDLE_MEMORY_PRUNING final : OptionBase<DISABLE_IDLE_MEMORY_PRUNIN
     }
 };
 
+struct SHARED_COMMON_QUEUE final : OptionBase<SHARED_COMMON_QUEUE, bool> {
+    static std::string_view key() {
+        return ov::intel_npu::shared_common_queue.name();
+    }
+
+    static bool defaultValue() {
+        return true;
+    }
+
+    static OptionMode mode() {
+        return OptionMode::RunTime;
+    }
+};
+
 }  // namespace intel_npu

src/plugins/intel_npu/src/al/include/intel_npu/npu_private_properties.hpp

@@ -450,5 +450,14 @@ static constexpr ov::Property<bool> import_raw_blob{"NPU_IMPORT_RAW_BLOB"};
  */
 static constexpr ov::Property<bool> export_raw_blob{"NPU_EXPORT_RAW_BLOB"};
 
+/**
+ * @brief [Only for NPU Plugin]
+ * Type: boolean, default is true.
+ * This option allows to enable/disable the usage of a shared common queue for all compiled models. If set to false,
+ * each compiled model will have its own common queue. This option is added for enabling the isolation of compiled
+ * models from each other, which can be required for some use cases.
+ */
+static constexpr ov::Property<bool> shared_common_queue{"NPU_SHARED_COMMON_QUEUE"};
+
 }  // namespace intel_npu
 }  // namespace ov

src/plugins/intel_npu/src/backend/include/zero_pipeline.hpp

@@ -60,6 +60,7 @@ class IPipeline {
      */
     size_t _batch_size;
 
+    std::shared_ptr<CommandQueue> _command_queue = nullptr;
     std::vector<std::unique_ptr<Fence>> _fences;
     std::shared_ptr<EventPool> _event_pool;
     std::vector<std::shared_ptr<Event>> _events;