Starting the one shot implementation & adjusting the code a bit

Author: razvanapetroaie

src/plugins/intel_npu/src/compiler_adapter/include/vcl_api.hpp

@@ -93,8 +93,8 @@ class VCLCompilerImpl final : public intel_npu::ICompiler {
 
     NetworkDescription compile(const std::shared_ptr<const ov::Model>& model, const Config& config) const override;
 
-    // std::vector<std::shared_ptr<NetworkDescription>> compileWsOneShot(const std::shared_ptr<ov::Model>& model,
-    //                                                                   const Config& config) const override;
+    std::vector<std::shared_ptr<NetworkDescription>> compileWsOneShot(const std::shared_ptr<ov::Model>& model,
+                                                                      const Config& config) const override;
 
     NetworkDescription compileWsIterative(const std::shared_ptr<ov::Model>& model,
                                           const Config& config,

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

@@ -165,9 +165,6 @@ std::shared_ptr<IGraph> PluginCompilerAdapter::compileWS(const std::shared_ptr<o
     OV_ITT_TASK_CHAIN(COMPILE_BLOB, itt::domains::NPUPlugin, "PluginCompilerAdapter", "compileWS");
     OPENVINO_ASSERT(_zeGraphExt);
 
-    std::vector<std::shared_ptr<NetworkDescription>> initNetworkDescriptions;
-    std::shared_ptr<NetworkDescription> mainNetworkDescription;
-
     _logger.debug("compile start");
 
     FilteredConfig localConfig = config;
@@ -186,29 +183,23 @@ std::shared_ptr<IGraph> PluginCompilerAdapter::compileWS(const std::shared_ptr<o
     std::vector<GraphDescriptor> initGraphDescriptors;
     std::vector<ov::Tensor> tensorsInits;
     std::vector<NetworkMetadata> initNetworkMetadata;
+    std::vector<std::shared_ptr<NetworkDescription>> initNetworkDescriptions;
 
     ov::Tensor tensorMain;
     GraphDescriptor mainGraphDesc;
     NetworkMetadata mainNetworkMetadata;
+    std::shared_ptr<NetworkDescription> mainNetworkDescription;
 
     switch (localConfig.get<SEPARATE_WEIGHTS_VERSION>()) {
     case ov::intel_npu::WSVersion::ONE_SHOT: {
         std::vector<std::shared_ptr<NetworkDescription>> initMainNetworkDescriptions =
             _compiler->compileWsOneShot(model, localConfig);
 
-#if 0  // TODO: it is not clear whether we should change the name
-            OPENVINO_ASSERT(isMain(initMainNetworkDescriptions.back()->metadata.name),
-                            "Unexpected network name for main:",
-                            initMainNetworkDescriptions.back()->metadata.name);
-#endif
-
         mainNetworkDescription = initMainNetworkDescriptions.back();
         initMainNetworkDescriptions.pop_back();
         initNetworkDescriptions = std::move(initMainNetworkDescriptions);
 
-        ov::Tensor tensorMain = make_tensor_from_vector(mainNetworkDescription->compiledNetwork);
-        GraphDescriptor mainGraphDesc;
-        NetworkMetadata mainNetworkMetadata;
+        tensorMain = make_tensor_from_vector(mainNetworkDescription->compiledNetwork);
         if (_zeGraphExt) {
             // Depending on the config, we may get an error when trying to
             // get the graph handle from the compiled network
@@ -221,9 +212,6 @@ std::shared_ptr<IGraph> PluginCompilerAdapter::compileWS(const std::shared_ptr<o
             }
         }
 
-        std::vector<GraphDescriptor> initGraphDescriptors;
-        std::vector<ov::Tensor> tensorsInits;
-        std::vector<NetworkMetadata> initNetworkMetadata;
         initGraphDescriptors.reserve(initNetworkDescriptions.size());
         tensorsInits.reserve(initNetworkDescriptions.size());
         initNetworkMetadata.reserve(initNetworkDescriptions.size());
@@ -245,6 +233,11 @@ std::shared_ptr<IGraph> PluginCompilerAdapter::compileWS(const std::shared_ptr<o
         }
     } break;
     case ov::intel_npu::WSVersion::ITERATIVE: {
+        OPENVINO_ASSERT(_zeGraphExt,
+                        "The \"iterative\" implementation of the weights separation feature requires a Level Zero "
+                        "graph handle to compile a model.");
+
+        // The state of the model needs to be reset every iteration
         const std::shared_ptr<ov::Model> originalModel = model->clone();
         std::shared_ptr<ov::Model> targetModel = model;
         size_t i = 0;
@@ -256,18 +249,18 @@ std::shared_ptr<IGraph> PluginCompilerAdapter::compileWS(const std::shared_ptr<o
             NetworkMetadata networkMetadata = _zeGraphExt->getNetworkMeta(graphDesc);
 
             if (isInitMetadata(networkDescription->metadata)) {
-                initNetworkDescriptions.push_back(networkDescription);
                 targetModel = originalModel->clone();
                 initGraphDescriptors.push_back(graphDesc);
                 tensorsInits.push_back(std::move(tensor));
                 initNetworkMetadata.push_back(std::move(networkMetadata));
+                initNetworkDescriptions.push_back(networkDescription);
                 continue;
             }
 
-            mainNetworkDescription = std::move(networkDescription);
             tensorMain = std::move(tensor);
             mainGraphDesc = graphDesc;
             mainNetworkMetadata = std::move(networkMetadata);
+            mainNetworkDescription = std::move(networkDescription);
             break;
         }
     } break;

src/plugins/intel_npu/src/compiler_adapter/src/vcl_api.cpp

@@ -359,6 +359,60 @@ NetworkDescription VCLCompilerImpl::compile(const std::shared_ptr<const ov::Mode
     }
 }
 
+std::vector<std::shared_ptr<NetworkDescription>> VCLCompilerImpl::compileWsOneShot(
+    const std::shared_ptr<ov::Model>& model,
+    const Config& config) const {
+    _logger.debug("compileWsOneShot start");
+
+    const auto maxOpsetVersion = _compilerProperties.supportedOpsets;
+    _logger.info("getSupportedOpsetVersion Max supported version of opset in CiD: %d", maxOpsetVersion);
+
+    _logger.debug("serialize IR");
+    ze_graph_compiler_version_info_t compilerVersion;
+    compilerVersion.major = _compilerProperties.version.major;
+    compilerVersion.minor = _compilerProperties.version.minor;
+
+    const FilteredConfig* filteredConfig = dynamic_cast<const FilteredConfig*>(&config);
+    if (filteredConfig == nullptr) {
+        OPENVINO_THROW("config is not FilteredConfig");
+    }
+    FilteredConfig updatedConfig = *filteredConfig;
+    auto serializedIR =
+        driver_compiler_utils::serializeIR(model,
+                                           compilerVersion,
+                                           maxOpsetVersion,
+                                           updatedConfig.isAvailable(ov::intel_npu::use_base_model_serializer.name())
+                                               ? updatedConfig.get<USE_BASE_MODEL_SERIALIZER>()
+                                               : true,
+                                           updatedConfig.get<SERIALIZATION_WEIGHTS_SIZE_THRESHOLD>());
+
+    std::string buildFlags;
+    const bool useIndices = !((compilerVersion.major < 5) || (compilerVersion.major == 5 && compilerVersion.minor < 9));
+
+    _logger.debug("create build flags");
+    buildFlags += driver_compiler_utils::serializeIOInfo(model, useIndices);
+    buildFlags += " ";
+    buildFlags += driver_compiler_utils::serializeConfig(config, compilerVersion);
+    _logger.debug("final build flags to compiler: %s", buildFlags.c_str());
+
+    vcl_executable_desc_t exeDesc = {serializedIR.second.get(),
+                                     serializedIR.first,
+                                     buildFlags.c_str(),
+                                     buildFlags.size()};
+    _logger.debug("compiler vcl version: %d.%d", _vclVersion.major, _vclVersion.minor);
+
+    _logger.debug("Using vclAllocatedExecutableCreateWS");
+    vcl_allocator_vector allocator;
+    uint8_t* blob = nullptr;
+    size_t size = 0;
+
+    // TODO fill the rest. Call "vclAllocatedExecutableCreateWS" and any other remote function required to retrieve the
+    // vector of blobs and use them to construct the vector of "NetworkDescription". The metadata objects can be empty.
+
+    _logger.debug("compile end, blob size:%d", allocator.m_vec.size());
+    return {};
+}
+
 NetworkDescription VCLCompilerImpl::compileWsIterative(const std::shared_ptr<ov::Model>& model,
                                                        const Config& config,
                                                        size_t callNumber) const {