Starting the blobreader

Author: razvanapetroaie

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

@@ -5,15 +5,43 @@
 #pragma once
 
 #include <cinttypes>
+#include <functional>
 #include <unordered_map>
 #include <unordered_set>
 #include <vector>
 
+#include "cre.hpp"
+
 namespace intel_npu {
 
 class BlobReader {
 public:
-    BlobReader();
+    BlobReader(std::istream& source);
+
+    BlobReader(const ov::Tensor& source);
+
+    void read();
+
+    void register_reader(
+        const SectionID section_id,
+        std::function<std::shared_ptr<ISection>(const BlobSource&, const std::unordered_map<SectionID, uint64_t>&)>
+            reader);
+
+    std::shared_ptr<ISection> retrieve_section(const SectionID section_id);
+
+private:
+    friend class BlobWriter;
+
+    void read_data_from_source(char* destination, const size_t size);
+
+    BlobSource m_source;
+    std::unordered_map<SectionID, uint64_t> m_offsets_table;
+    std::unordered_map<SectionID, std::shared_ptr<ISection>> m_parsed_sections;
+    std::unordered_map<
+        SectionID,
+        std::function<std::shared_ptr<ISection>(const BlobSource&, const std::unordered_map<SectionID, uint64_t>&)>>
+        m_readers;
+    size_t m_cursor_offset;
 };
 
 }  // namespace intel_npu

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

@@ -18,6 +18,8 @@ class BlobWriter {
 public:
     BlobWriter();
 
+    BlobWriter(BlobReader blob_reader);
+
     void register_section(const std::shared_ptr<ISection>& section);
 
     void register_offset_in_table(const SectionID id, const uint64_t offset);
@@ -35,7 +37,10 @@ class BlobWriter {
     std::vector<std::shared_ptr<ISection>> m_registered_sections;
     std::unordered_map<SectionID, uint64_t> m_offsets_table;
     std::shared_ptr<CRESection> m_cre;
-    // TODO
+
+    /**
+     * @brief TODO
+     */
     std::optional<std::streampos> m_stream_base = std::nullopt;
 };
 

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

@@ -71,12 +71,13 @@ class CRESection final : public ISection {
 
     std::optional<uint64_t> get_length() const override;
 
-    // void read(BlobReader* reader) override;
-
     void append_to_expression(const CRE::Token requirement_token);
 
     void append_to_expression(const std::vector<CRE::Token>& requirement_tokens);
 
+    static std::shared_ptr<ISection> read(const BlobSource& source,
+                                          const std::unordered_map<SectionID, uint64_t>& offsets_table);
+
 private:
     CRE m_cre;
 };

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

@@ -9,15 +9,20 @@
 #include <optional>
 #include <unordered_map>
 #include <unordered_set>
+#include <variant>
 #include <vector>
 
+#include "openvino/runtime/tensor.hpp"
+
 namespace intel_npu {
 
 // TODOs: fix the circular dependencies
 // Move sections in directory
 // Unique SID - how do we reinforce this without compromising modularity? Description matching?
 
 using SectionID = uint16_t;
+using BlobSource = std::variant<std::reference_wrapper<std::istream>,
+                                std::reference_wrapper<const ov::Tensor>>;  // TODO find a better place
 
 class BlobWriter;
 class BlobReader;
@@ -44,8 +49,6 @@ class ISection {
     // note necessary, saves some performance if provided
     virtual std::optional<uint64_t> get_length() const;
 
-    // virtual void read(BlobReader* reader) = 0;
-
     SectionID get_section_id() const;
 
 private:

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

@@ -4,4 +4,39 @@
 
 #include "intel_npu/common/blob_reader.hpp"
 
-namespace intel_npu {}  // namespace intel_npu
+namespace intel_npu {
+
+BlobReader::BlobReader(std::istream& source) : m_source(source) {}
+
+BlobReader::BlobReader(const ov::Tensor& source) : m_source(source), m_cursor_offset(0) {}
+
+void BlobReader::register_reader(
+    const SectionID section_id,
+    std::function<std::shared_ptr<ISection>(const BlobSource&, const std::unordered_map<SectionID, uint64_t>&)>
+        reader) {
+    m_readers[section_id] = reader;
+}
+
+std::shared_ptr<ISection> BlobReader::retrieve_section(const SectionID section_id) {
+    auto search_result = m_parsed_sections.find(section_id);
+    if (search_result != m_parsed_sections.end()) {
+        return search_result->second;
+    }
+    return nullptr;
+}
+
+// TODO test the windows debug build works properly if using the "better" implementation
+void BlobReader::read_data_from_source(char* destination, const size_t size) {
+    if (const std::reference_wrapper<std::istream>* stream =
+            std::get_if<std::reference_wrapper<std::istream>>(&m_source)) {
+        stream->get().read(destination, size);
+    } else if (const std::reference_wrapper<const ov::Tensor>* tensor =
+                   std::get_if<std::reference_wrapper<const ov::Tensor>>(&m_source)) {
+        std::memcpy(destination, tensor->get().data<const char>() + m_cursor_offset, size);
+        m_cursor_offset += size;
+    }
+}
+
+void BlobReader::read() {}
+
+}  // namespace intel_npu

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

@@ -4,6 +4,7 @@
 
 #include "intel_npu/common/blob_writer.hpp"
 
+#include "intel_npu/common/blob_reader.hpp"
 #include "intel_npu/common/offsets_table.hpp"
 
 namespace {
@@ -20,6 +21,10 @@ BlobWriter::BlobWriter() : m_cre(std::make_shared<CRESection>()) {
     register_section(m_cre);
 }
 
+BlobWriter::BlobWriter(BlobReader blob_reader) {
+    // TODO after reader is done, while constructing the compiledModel
+}
+
 void BlobWriter::register_section(const std::shared_ptr<ISection>& section) {
     m_registered_sections.push_back(section);
     OPENVINO_ASSERT(!m_registered_sections_ids.count(section->get_section_id()));