Changing "SEPARATE_WEIGHTS": bool -> "SEPARATE_WEIGHTS_VERSION": uint…

…32_t

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

@@ -265,13 +265,31 @@ struct BATCH_MODE final : OptionBase<BATCH_MODE, ov::intel_npu::BatchMode> {
     static std::string toString(const ov::intel_npu::BatchMode& val);
 };
 
-struct SEPARATE_WEIGHTS final : OptionBase<SEPARATE_WEIGHTS, bool> {
+struct SEPARATE_WEIGHTS_VERSION final : OptionBase<SEPARATE_WEIGHTS_VERSION, uint32_t> {
     static std::string_view key() {
-        return ov::intel_npu::separate_weights.name();
+        return ov::intel_npu::separate_weights_version.name();
     }
 
-    static bool defaultValue() {
-        return true;
+    static uint32_t defaultValue() {
+        return 2;
+    }
+
+    static uint32_t parse(std::string_view val) {
+        int val_i = -1;
+        try {
+            val_i = std::stoi(val.data());
+            if (val_i >= 0) {
+                return val_i;
+            } else {
+                throw std::logic_error("wrong val");
+            }
+        } catch (const std::exception&) {
+            OPENVINO_THROW("Wrong value of ",
+                           val.data(),
+                           " for property key ",
+                           ov::intel_npu::separate_weights_version.name(),
+                           ". Expected only positive integer numbers");
+        }
     }
 };
 

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

@@ -58,8 +58,18 @@ class ICompiler : public std::enable_shared_from_this<ICompiler> {
      * @param config
      * @return NetworkDescription
      */
-    virtual std::vector<std::shared_ptr<NetworkDescription>> compileWS(const std::shared_ptr<ov::Model>& model,
-                                                                       const Config& config) const = 0;
+    virtual std::vector<std::shared_ptr<NetworkDescription>> compileWS_v1(const std::shared_ptr<ov::Model>& model,
+                                                                          const Config& config) const = 0;
+
+    /**
+     * @brief TODO
+     *
+     * @param model
+     * @param config
+     * @return NetworkDescription
+     */
+    virtual std::shared_ptr<NetworkDescription> compileWS_v2(const std::shared_ptr<ov::Model>& model,
+                                                             const Config& config) = 0;
 
     /**
      * @brief Returns information about supported layers of the network passed

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

@@ -347,7 +347,7 @@ static constexpr ov::Property<BatchMode> batch_mode{"NPU_BATCH_MODE"};
 /**
  * @brief TODO
  */
-static constexpr ov::Property<bool> separate_weights{"NPU_SEPARATE_WEIGHTS"};
+static constexpr ov::Property<uint32_t> separate_weights_version{"NPU_SEPARATE_WEIGHTS_VERSION"};
 
 static constexpr ov::Property<bool> benchmark_init{"NPU_BENCHMARK_INIT"};
 

src/plugins/intel_npu/src/al/src/config/common.cpp

@@ -22,7 +22,7 @@ void intel_npu::registerCommonOptions(OptionsDesc& desc) {
     desc.add<CACHE_DIR>();
     desc.add<LOADED_FROM_CACHE>();
     desc.add<BATCH_MODE>();
-    desc.add<SEPARATE_WEIGHTS>();
+    desc.add<SEPARATE_WEIGHTS_VERSION>();
     desc.add<BENCHMARK_INIT>();
 }
 

src/plugins/intel_npu/src/compiler_adapter/src/driver_compiler_adapter.cpp

@@ -643,10 +643,10 @@ std::string DriverCompilerAdapter::serializeConfig(const Config& config,
                    << VALUE_DELIMITER;
     content = std::regex_replace(content, std::regex(umdcachestring.str()), "");
 
-    // SEPARATE_WEIGHTS does not involve the compiler (yet)
+    // SEPARATE_WEIGHTS_VERSION does not involve the compiler (yet)
     std::ostringstream separateWeightsStream;
-    separateWeightsStream << ov::intel_npu::separate_weights.name() << KEY_VALUE_SEPARATOR << VALUE_DELIMITER << "\\S+"
-                          << VALUE_DELIMITER;
+    separateWeightsStream << ov::intel_npu::separate_weights_version.name() << KEY_VALUE_SEPARATOR << VALUE_DELIMITER
+                          << "\\S+" << VALUE_DELIMITER;
     content = std::regex_replace(content, std::regex(separateWeightsStream.str()), "");
 
     std::ostringstream benchmarkInitStream;

src/plugins/intel_npu/src/compiler_adapter/src/plugin_compiler_adapter.cpp

@@ -127,17 +127,34 @@ std::shared_ptr<IGraph> PluginCompilerAdapter::compile(const std::shared_ptr<con
                                          std::move(networkDesc.compiledNetwork),
                                          config);
 }
+
 std::vector<std::shared_ptr<IGraph>> PluginCompilerAdapter::compileWS(const std::shared_ptr<ov::Model>& model,
                                                                       const Config& config) const {
     OV_ITT_TASK_CHAIN(COMPILE_BLOB, itt::domains::NPUPlugin, "PluginCompilerAdapter", "compileWS");
 
+    std::shared_ptr<NetworkDescription> initNetworkDescription;
+    std::shared_ptr<NetworkDescription> mainNetworkDescription;
+
     _logger.debug("compile start");
-    const std::vector<std::shared_ptr<NetworkDescription>> initMainNetworkDescriptions =
-        _compiler->compileWS(model, config);
-    _logger.debug("compile end");
 
-    auto initNetworkDescription = initMainNetworkDescriptions[0];
-    auto mainNetworkDescription = initMainNetworkDescriptions[1];
+    switch (config.get<SEPARATE_WEIGHTS_VERSION>()) {
+    case 1: {
+        const std::vector<std::shared_ptr<NetworkDescription>> initMainNetworkDescriptions =
+            _compiler->compileWS_v1(model, config);
+
+        initNetworkDescription = initMainNetworkDescriptions[0];
+        mainNetworkDescription = initMainNetworkDescriptions[1];
+    } break;
+    case 2: {
+        initNetworkDescription = _compiler->compileWS_v2(model, config);
+        mainNetworkDescription = _compiler->compileWS_v2(model, config);
+    } break;
+    default:
+        OPENVINO_THROW("Invalid \"SEPARATE_WEIGHTS_VERSION\" value found within the \"compileWS\" call");
+        break;
+    }
+
+    _logger.debug("compile end");
 
     ze_graph_handle_t initGraphHandle = nullptr;
     ze_graph_handle_t mainGraphHandle = nullptr;

src/plugins/intel_npu/src/plugin/src/compiled_model.cpp

@@ -48,7 +48,7 @@ CompiledModel::CompiledModel(const std::shared_ptr<const ov::Model>& model,
     initialize_properties();
     configure_stream_executors();
 
-    if (_config.get<SEPARATE_WEIGHTS>() && _initGraph != nullptr) {
+    if (_config.get<SEPARATE_WEIGHTS_VERSION>() != 0 && _initGraph != nullptr) {
         if (_config.get<CREATE_EXECUTOR>() && !_config.get<DEFER_WEIGHTS_LOAD>()) {
             begin = std::chrono::steady_clock::now();
             _weightsInputs = _device->runInit(_initGraph, _initModel, get_context(), _config);
@@ -77,7 +77,7 @@ std::shared_ptr<ov::IAsyncInferRequest> CompiledModel::create_infer_request() co
         _device->createInferRequest(shared_from_this(), _config);
     syncInferRequest->initialize_states();
 
-    if (_config.get<SEPARATE_WEIGHTS>() && _initGraph != nullptr) {
+    if (_config.get<SEPARATE_WEIGHTS_VERSION>() != 0 && _initGraph != nullptr) {
         if (!_config.get<CREATE_EXECUTOR>() || _config.get<DEFER_WEIGHTS_LOAD>()) {
             begin = std::chrono::steady_clock::now();
             _initGraph->initialize(_config);
@@ -101,9 +101,10 @@ std::shared_ptr<ov::IAsyncInferRequest> CompiledModel::create_infer_request() co
         end = std::chrono::steady_clock::now();
         std::cout << "set_weights_inputs() call "
                   << std::chrono::duration_cast<std::chrono::milliseconds>(end - begin).count() << "[ms]" << std::endl;
-    } else if (_config.get<SEPARATE_WEIGHTS>() && _initGraph == nullptr) {
-        _logger.warning("SEPARATE_WEIGHTS config option was set but no compiled model for the init schedule was found. "
-                        "run_init() will not run.");
+    } else if (_config.get<SEPARATE_WEIGHTS_VERSION>() != 0 && _initGraph == nullptr) {
+        _logger.warning(
+            "SEPARATE_WEIGHTS_VERSION config option was set but no compiled model for the init schedule was found. "
+            "run_init() will not run.");
     }
 
     return std::make_shared<AsyncInferRequest>(syncInferRequest,
@@ -121,7 +122,7 @@ std::shared_ptr<ov::ISyncInferRequest> CompiledModel::create_sync_infer_request(
 void CompiledModel::export_model(std::ostream& stream) const {
     _logger.debug("CompiledModel::export_model");
 
-    if (_config.get<SEPARATE_WEIGHTS>()) {
+    if (_config.get<SEPARATE_WEIGHTS_VERSION>() != 0) {
         _graph->custom_export(stream, _initGraph, _initModel);
         return;
     }

src/plugins/intel_npu/src/plugin/src/plugin.cpp

@@ -619,11 +619,11 @@ Plugin::Plugin()
           [](const Config& config) {
               return config.getString<BATCH_MODE>();
           }}},
-        {ov::intel_npu::separate_weights.name(),
+        {ov::intel_npu::separate_weights_version.name(),
          {false,
           ov::PropertyMutability::RW,
           [](const Config& config) {
-              return config.getString<SEPARATE_WEIGHTS>();
+              return config.getString<SEPARATE_WEIGHTS_VERSION>();
           }}},
         {ov::intel_npu::benchmark_init.name(),
          {false,
@@ -766,7 +766,7 @@ std::shared_ptr<ov::ICompiledModel> Plugin::compile_model(const std::shared_ptr<
     try {
         _logger.debug("performing compile");
 
-        if (!localConfig.get<SEPARATE_WEIGHTS>()) {
+        if (localConfig.get<SEPARATE_WEIGHTS_VERSION>() == 0) {
             graph = compiler->compile(model, localConfig);
         } else {
             initModel = model->clone();
@@ -855,7 +855,7 @@ std::shared_ptr<ov::ICompiledModel> Plugin::import_model(std::istream& stream, c
     try {
         auto compiler = getCompiler(localConfig);
 
-        if (!localConfig.get<SEPARATE_WEIGHTS>()) {
+        if (localConfig.get<SEPARATE_WEIGHTS_VERSION>() == 0) {
             auto graphSize = getFileSize(stream);
 
             std::vector<uint8_t> blob(graphSize);