Adding the new option and some code for converting between the two switches

Author: razvanapetroaie

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

@@ -1426,4 +1426,35 @@ struct USE_BASE_MODEL_SERIALIZER final : OptionBase<USE_BASE_MODEL_SERIALIZER, b
     }
 };
 
+struct MODEL_SERIALIZER_VERSION final : OptionBase<MODEL_SERIALIZER_VERSION, ov::intel_npu::ModelSerializerVersion> {
+    static std::string_view key() {
+        return ov::intel_npu::model_serializer_version.name();
+    }
+
+    static constexpr std::string_view getTypeName() {
+        return "ov::intel_npu::ModelSerializerVersion";
+    }
+
+    static ov::intel_npu::ModelSerializerVersion defaultValue() {
+        return ov::intel_npu::ModelSerializerVersion::AUTO;
+    }
+
+    static ov::intel_npu::ModelSerializerVersion parse(std::string_view val) {
+        std::istringstream stringStream = std::istringstream(std::string(val));
+        ov::intel_npu::ModelSerializerVersion version;
+        stringStream >> version;
+        return version;
+    }
+
+    static std::string toString(const ov::intel_npu::ModelSerializerVersion& val) {
+        std::stringstream strStream;
+        strStream << val;
+        return strStream.str();
+    }
+
+    static OptionMode mode() {
+        return OptionMode::CompileTime;
+    }
+};
+
 }  // namespace intel_npu

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

@@ -188,6 +188,50 @@ inline std::istream& operator>>(std::istream& is, WSVersion& wsVersion) {
     return is;
 }
 
+/**
+ * @brief [Only for NPU Plugin]
+ * Default is "AUTO".
+ * Switches between different implementations of the VCL serializer.
+ */
+enum class ModelSerializerVersion {
+    AUTO = 0,
+    ALL_WEIGHTS_COPY = 1,
+    NO_WEIGHTS_COPY = 2,
+};
+
+inline std::ostream& operator<<(std::ostream& out, const ModelSerializerVersion& modelSerializerVersion) {
+    switch (modelSerializerVersion) {
+    case ModelSerializerVersion::AUTO: {
+        out << "AUTO";
+    } break;
+    case ModelSerializerVersion::ALL_WEIGHTS_COPY: {
+        out << "ALL_WEIGHTS_COPY";
+    } break;
+    case ModelSerializerVersion::NO_WEIGHTS_COPY: {
+        out << "NO_WEIGHTS_COPY";
+    } break;
+    default: {
+        OPENVINO_THROW("Unsupported value for the model serializer version:", modelSerializerVersion);
+    }
+    }
+    return out;
+}
+
+inline std::istream& operator>>(std::istream& is, ModelSerializerVersion& modelSerializerVersion) {
+    std::string str;
+    is >> str;
+    if (str == "AUTO") {
+        modelSerializerVersion = ModelSerializerVersion::AUTO;
+    } else if (str == "ALL_WEIGHTS_COPY") {
+        modelSerializerVersion = ModelSerializerVersion::ALL_WEIGHTS_COPY;
+    } else if (str == "NO_WEIGHTS_COPY") {
+        modelSerializerVersion = ModelSerializerVersion::NO_WEIGHTS_COPY;
+    } else {
+        OPENVINO_THROW("Unsupported value for the model serializer version:", str);
+    }
+    return is;
+}
+
 /**
  * @brief [Only for NPU Plugin]
  * Type: string, default is MODEL.
@@ -362,6 +406,21 @@ static constexpr ov::Property<bool> weightless_blob{"NPU_WEIGHTLESS_BLOB"};
  */
 static constexpr ov::Property<bool> use_base_model_serializer{"NPU_USE_BASE_MODEL_SERIALIZER"};
 
+/**
+ * @brief [Only for NPU Plugin]
+ * Type: enum. Default is "AUTO".
+ *
+ * This config option concerns the algorithm used for serializing the "ov::Model" at compilation time in order to be
+ * passed through the driver.
+ *
+ * The value chosen for this option will impact memory usage, since some versions clone the values of the weights in a
+ * separate buffer. If this option is set to "AUTO", the plugin will use the latest version that is compatible with the
+ * current compiler.
+ *
+ * @note This feature is a work-in-progress and may not yet work as intended.
+ */
+static constexpr ov::Property<ModelSerializerVersion> model_serializer_version{"NPU_MODEL_SERIALIZER_VERSION"};
+
 /**
  * @brief [Experimental, only for NPU Plugin]
  * Type: integer.

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

@@ -321,6 +321,7 @@ void Plugin::init_options() {
     REGISTER_OPTION(SEPARATE_WEIGHTS_VERSION);
     REGISTER_OPTION(WS_COMPILE_CALL_NUMBER);
     REGISTER_OPTION(USE_BASE_MODEL_SERIALIZER);
+    REGISTER_OPTION(MODEL_SERIALIZER_VERSION);
 
     if (_backend) {
         if (_backend->isCommandQueueExtSupported()) {
@@ -747,6 +748,18 @@ std::shared_ptr<ov::ICompiledModel> Plugin::compile_model(const std::shared_ptr<
         localConfig.update({{ov::intel_npu::weightless_blob.name(), cacheModeOptimizeSize ? "YES" : "NO"}});
     }
 
+    // There is an on-going migration from "USE_BASE_MODEL_SERIALIZER" to "MODEL_SERIALIZER_VERSION". Until done, make
+    // sure both options have the same value if only one is defined.
+    if (localConfig.has<MODEL_SERIALIZER_VERSION>() && !localConfig.has<USE_BASE_MODEL_SERIALIZER>()) {
+        const bool useBaseModelSerializer =
+            (localConfig.get<MODEL_SERIALIZER_VERSION>() == ov::intel_npu::ModelSerializerVersion::AUTO ||
+             localConfig.get<MODEL_SERIALIZER_VERSION>() == ov::intel_npu::ModelSerializerVersion::ALL_WEIGHTS_COPY);
+        localConfig.update({{ov::intel_npu::use_base_model_serializer.name(), useBaseModelSerializer ? "YES" : "NO"}});
+    } else if (!localConfig.has<MODEL_SERIALIZER_VERSION>() && localConfig.has<USE_BASE_MODEL_SERIALIZER>()) {
+        localConfig.update({{ov::intel_npu::model_serializer_version.name(),
+                             localConfig.get<USE_BASE_MODEL_SERIALIZER>() ? "ALL_WEIGHTS_COPY" : "NO_WEIGHTS_COPY"}});
+    }
+
     std::shared_ptr<intel_npu::IGraph> graph;
 
     auto compileWithConfig = [&](const auto& modelToCompile, const auto& config) {

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

@@ -385,6 +385,7 @@ void Properties::registerPluginProperties() {
     TRY_REGISTER_SIMPLE_PROPERTY(ov::intel_npu::weightless_blob, WEIGHTLESS_BLOB);
     TRY_REGISTER_SIMPLE_PROPERTY(ov::intel_npu::separate_weights_version, SEPARATE_WEIGHTS_VERSION);
     TRY_REGISTER_SIMPLE_PROPERTY(ov::intel_npu::use_base_model_serializer, USE_BASE_MODEL_SERIALIZER);
+    TRY_REGISTER_SIMPLE_PROPERTY(ov::intel_npu::model_serializer_version, MODEL_SERIALIZER_VERSION);
 
     TRY_REGISTER_CUSTOMFUNC_PROPERTY(ov::intel_npu::stepping, STEPPING, [&](const Config& config) {
         if (!config.has<STEPPING>()) {