Compilable and exportable

Author: razvanapetroaie

src/plugins/intel_npu/src/common/include/intel_npu/common/blob_reader.hpp

@@ -28,7 +28,7 @@ class BlobReader {
     void copy_data_from_source(char* destination, const size_t size);
 
     template <class T>
-    void interpret_data_from_source(T& destination);
+    void interpret_data_from_source(T*& destination);
 
     ov::Tensor get_roi_tensor(const size_t size);
 

src/plugins/intel_npu/src/common/include/intel_npu/common/blob_writer.hpp

@@ -34,8 +34,8 @@ class BlobWriter {
 private:
     std::unordered_set<SectionID> m_registered_sections_ids;
     std::queue<std::shared_ptr<ISection>> m_registered_sections;
-    std::shared_ptr<std::unordered_map<SectionID, uint64_t>> m_offsets_table;
     std::shared_ptr<CRESection> m_cre;
+    std::shared_ptr<std::unordered_map<SectionID, uint64_t>> m_offsets_table;
 
     /**
      * @brief TODO

src/plugins/intel_npu/src/common/src/blob_reader.cpp

@@ -41,9 +41,9 @@ void BlobReader::copy_data_from_source(char* destination, const size_t size) {
 }
 
 template <class T>
-void BlobReader::interpret_data_from_source(T& destination) {
-    destination = reinterpret_cast<T>(m_source.get().data<const char>());
-    m_cursor += sizeof(&T);
+void BlobReader::interpret_data_from_source(T*& destination) {
+    destination = reinterpret_cast<T*>(m_source.get().data<const char>());
+    m_cursor += sizeof(T);
 }
 
 ov::Tensor BlobReader::get_roi_tensor(const size_t size) {

src/plugins/intel_npu/src/common/src/blob_writer.cpp

@@ -22,10 +22,23 @@ BlobWriter::BlobWriter()
       m_offsets_table(std::make_shared<std::unordered_map<SectionID, uint64_t>>()),
       m_logger("BlobWriter", Logger::global().level()) {
     register_section(m_cre);
+    append_compatibility_requirement(CRE::PredefinedCapabilityToken::CRE_EVALUATION);
 }
 
-BlobWriter::BlobWriter(const std::shared_ptr<BlobReader>& blob_reader) {
-    // TODO after reader is done, while constructing the compiledModel
+BlobWriter::BlobWriter(const std::shared_ptr<BlobReader>& blob_reader)
+    : m_cre(std::dynamic_pointer_cast<CRESection>(blob_reader->retrieve_section(PredefinedSectionID::CRE))),
+      m_offsets_table(blob_reader->m_offsets_table),
+      m_logger("BlobWriter", Logger::global().level()) {
+    // TODO review the class const qualifiers
+    // TODO handle offsets table section properly, multiple exports
+    std::unordered_map<SectionID, std::shared_ptr<ISection>> m_parsed_sections;
+    for (const auto& [section_id, section] : m_parsed_sections) {
+        // The offsets table section is added by the write() method after writing all registered sections (jic the
+        // registered sections will alter the table). Therefore, this section should be omitted here.
+        if (section_id != PredefinedSectionID::OFFSETS_TABLE) {
+            register_section(section);
+        }
+    }
 }
 
 void BlobWriter::register_section(const std::shared_ptr<ISection>& section) {
@@ -82,15 +95,14 @@ void BlobWriter::write(std::ostream& stream) {
         std::optional<uint64_t> length = section->get_length();
 
         if (length.has_value()) {
-            auto position_before_write = stream.tellp();
             stream.write(reinterpret_cast<const char*>(&length.value()), sizeof(length.value()));
+            auto position_before_write = stream.tellp();
             section->write(stream, this);
 
-            std::cout << typeid(*section.get()).name() << std::endl;
-            OPENVINO_ASSERT(length.value() == stream.tellp() - position_before_write,
+            OPENVINO_ASSERT(length.value() == static_cast<uint64_t>(stream.tellp() - position_before_write),
                             "Mismatch between the length provided by the section class and the size written in the "
-                            "blob. Section type: ",
-                            typeid(*section.get()).name());
+                            "blob. Section ID: ",
+                            section_id);  // TODO name via macro maybe
         } else {
             // Use the cursor to deduce the length
             uint64_t length = 0;  // placeholder

src/plugins/intel_npu/src/common/src/cre.cpp

@@ -25,10 +25,10 @@ inline bool or_function(bool a, bool b) {
 
 namespace intel_npu {
 
-CRE::CRE() : m_expression({CRE::AND}) {}
+CRE::CRE() : m_expression({CRE::AND}) {}  // TODO can lead to expression with 0 or 1 operands, fix that
 
 void CRE::write(std::ostream& stream) {
-    stream.write(reinterpret_cast<const char*>(m_expression.data()), m_expression.size());
+    stream.write(reinterpret_cast<const char*>(m_expression.data()), m_expression.size() * sizeof(Token));
 }
 
 void CRE::append_to_expression(const CRE::Token requirement_token) {
@@ -135,7 +135,7 @@ void CRESection::write(std::ostream& stream, BlobWriter* writer) {
 }
 
 std::optional<uint64_t> CRESection::get_length() const {
-    return m_cre.get_expression_length();
+    return m_cre.get_expression_length() * sizeof(CRE::Token);
 }
 
 bool CRESection::check_compatibility(const std::unordered_set<CRE::Token>& plugin_capabilities) {

src/plugins/intel_npu/src/common/src/offsets_table.cpp

@@ -15,8 +15,8 @@ OffsetsTableSection::OffsetsTableSection(const std::shared_ptr<std::unordered_ma
 
 void OffsetsTableSection::write(std::ostream& stream, BlobWriter* writer) {
     for (const auto& [key, value] : *m_offsets_table) {
-        stream.write(reinterpret_cast<const char*>(key), sizeof(key));
-        stream.write(reinterpret_cast<const char*>(value), sizeof(value));
+        stream.write(reinterpret_cast<const char*>(&key), sizeof(key));
+        stream.write(reinterpret_cast<const char*>(&value), sizeof(value));
     }
 }
 

src/plugins/intel_npu/src/compiler_adapter/src/compiler_schedules_sections.cpp

@@ -101,7 +101,7 @@ std::shared_ptr<ISection> ELFInitSchedulesSection::read(BlobReader* blob_reader,
 
     std::vector<ov::Tensor> init_schedules;
     for (const auto& init_size : init_sizes) {
-        init_schedules.push_back(blob_reader->get_roi_tensor(section_length));
+        init_schedules.push_back(blob_reader->get_roi_tensor(init_size));
     }
 
     return std::make_shared<ELFInitSchedulesSection>(init_schedules);

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

@@ -92,11 +92,11 @@ std::shared_ptr<ISection> IOLayoutsSection::read(BlobReader* blob_reader, const
             try {
                 layouts.push_back(ov::Layout(std::move(layoutString)));
             } catch (const ov::Exception&) {
-                _logger.warning("Error encountered while constructing an ov::Layout object. %s index: %d. Value "
-                                "read from blob: %s. A default value will be used instead.",
-                                logger_addition,
-                                layout_index,
-                                layoutString.c_str());
+                logger.warning("Error encountered while constructing an ov::Layout object. %s index: %d. Value "
+                               "read from blob: %s. A default value will be used instead.",
+                               logger_addition,
+                               layout_index,
+                               layoutString.c_str());
                 layouts.push_back(ov::Layout());
             }
         }

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

@@ -9,7 +9,7 @@
 #include "batch_size_section.hpp"
 #include "compiled_model.hpp"
 #include "compiler_adapter_factory.hpp"
-#include "compiler_schedules_section.hpp"
+#include "compiler_schedules_sections.hpp"
 #include "driver_compiler_adapter.hpp"
 #include "intel_npu/common/blob_reader.hpp"
 #include "intel_npu/common/blob_writer.hpp"
@@ -1155,18 +1155,18 @@ std::shared_ptr<ov::ICompiledModel> Plugin::parse(const ov::Tensor& tensorBig, c
     }
 
     auto graph = compiler->parse(
-        mainScheduleSection->get_main_schedule(),
+        mainScheduleSection->get_schedule(),
         localConfig,
-        weightsSeparationEnabled ? std::make_optional(initSchedulesSection->get_init_schedules()) : std::nullopt,
+        weightsSeparationEnabled ? std::make_optional(initSchedulesSection->get_schedules()) : std::nullopt,
         weightsSeparationEnabled ? std::make_optional(originalModel) : std::nullopt);
 
     graph->update_network_name("net" + std::to_string(_compiledModelLoadCounter++));
-    const std::shared_ptr<ov::Model> modelDummy =
-        create_dummy_model(graph->get_metadata().inputs,
-                           graph->get_metadata().outputs,
-                           batchSize,
-                           ioLayoutsSection != nullptr ? ioLayoutsSection->get_input_layouts() : std::nullopt,
-                           ioLayoutsSection != nullptr ? ioLayoutsSection->get_output_layouts() : std::nullopt);
+    const std::shared_ptr<ov::Model> modelDummy = create_dummy_model(
+        graph->get_metadata().inputs,
+        graph->get_metadata().outputs,
+        batchSize,
+        ioLayoutsSection != nullptr ? std::make_optional<>(ioLayoutsSection->get_input_layouts()) : std::nullopt,
+        ioLayoutsSection != nullptr ? std::make_optional<>(ioLayoutsSection->get_output_layouts()) : std::nullopt);
 
     if (batchSize.has_value()) {
         if (batchSize.value() > 0) {