[NPU] Update the format of the blob (where the compiled model resides)

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

@@ -0,0 +1,56 @@
+// Copyright (C) 2018-2025 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#pragma once
+
+#include <cinttypes>
+#include <functional>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+#include "intel_npu/common/cre.hpp"
+
+namespace intel_npu {
+
+class BlobReader {
+public:
+    BlobReader(const ov::Tensor& source);
+
+    void read(const std::unordered_set<CRE::Token>& plugin_capabilities_ids);
+
+    void register_reader(const SectionID section_id,
+                         std::function<std::shared_ptr<ISection>(BlobReader*, const size_t)> reader);
+
+    std::shared_ptr<ISection> retrieve_section(const SectionID section_id);
+
+    void copy_data_from_source(char* destination, const size_t size);
+
+    const void* interpret_data_from_source(const size_t size);
+
+    ov::Tensor get_roi_tensor(const size_t size);
+
+    std::optional<uint64_t> get_section_offset(const SectionID section_id) const;
+
+    size_t get_cursor_relative_position();
+
+    void move_cursor_to_relative_position(const size_t offset);
+
+    static size_t get_npu_region_size(std::istream& stream);
+
+    static size_t get_npu_region_size(const ov::Tensor& tensor);
+
+private:
+    friend class BlobWriter;
+
+    std::reference_wrapper<const ov::Tensor> m_source;
+    size_t m_npu_region_size;
+    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>(BlobReader*, const size_t)>> m_readers;
+
+    size_t m_cursor;
+};
+
+}  // namespace intel_npu

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

@@ -0,0 +1,52 @@
+// Copyright (C) 2018-2025 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#pragma once
+
+#include <cinttypes>
+#include <memory>
+#include <queue>
+#include <unordered_map>
+#include <unordered_set>
+
+#include "cre.hpp"
+#include "intel_npu/utils/logger/logger.hpp"
+
+namespace intel_npu {
+
+class BlobWriter {
+public:
+    BlobWriter();
+
+    BlobWriter(const std::shared_ptr<BlobReader>& blob_reader);
+
+    void register_section(const std::shared_ptr<ISection>& section);
+
+    void register_offset_in_table(const SectionID id, const uint64_t offset);
+
+    void write(std::ostream& stream);
+
+    void append_compatibility_requirement(const CRE::Token requirement_token);
+
+    void append_compatibility_requirement(const std::vector<CRE::Token>& requirement_tokens);
+
+    std::streamoff get_stream_relative_position(std::ostream& stream) const;
+
+private:
+    void write_section(std::ostream& stream, const std::shared_ptr<ISection>& section);
+
+    std::unordered_set<SectionID> m_registered_sections_ids;
+    std::queue<std::shared_ptr<ISection>> m_registered_sections;
+    CRE m_cre;
+    std::unordered_map<SectionID, uint64_t> m_offsets_table;
+
+    /**
+     * @brief TODO
+     */
+    std::optional<std::streampos> m_stream_base = std::nullopt;
+
+    Logger m_logger;
+};
+
+}  // namespace intel_npu

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

@@ -0,0 +1,87 @@
+// Copyright (C) 2018-2025 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#pragma once
+
+#include "intel_npu/common/isection.hpp"
+#include "openvino/core/except.hpp"
+
+namespace intel_npu {
+
+class InvalidCRE : public ov::Exception {};
+
+class CRE final {
+public:
+    using Token = uint16_t;
+
+    // TODO should we also add "NOT"?
+    enum ReservedToken : Token { AND = 50000, OR = 50001, OPEN = 50002, CLOSE = 50003 };
+
+    static inline const std::unordered_set<Token> RESERVED_TOKENS{ReservedToken::AND,
+                                                                  ReservedToken::OR,
+                                                                  ReservedToken::OPEN,
+                                                                  ReservedToken::CLOSE};
+
+    /**
+     * @brief All capability codes known in advance. Past codes should be recorded here as well, this helps avoid code
+     * collision.
+     */
+    enum PredefinedCapabilityToken : Token {
+        CRE_EVALUATION = 100,
+        ELF_SCHEDULE = 101,
+        BATCHING = 102,
+        WEIGHTS_SEPARATION = 103
+    };
+
+    static inline const std::unordered_set<Token> DEFAULT_PLUGIN_CAPABILITIES_TOKENS{
+        PredefinedCapabilityToken::CRE_EVALUATION,
+        PredefinedCapabilityToken::ELF_SCHEDULE,
+        PredefinedCapabilityToken::BATCHING,
+        PredefinedCapabilityToken::WEIGHTS_SEPARATION};
+
+    CRE();
+
+    CRE(const std::vector<Token>& expression);
+
+    void append_to_expression(const CRE::Token requirement_token);
+
+    void append_to_expression(const std::vector<CRE::Token>& requirement_tokens);
+
+    size_t get_expression_length() const;
+
+    std::vector<Token> get_expression() const;
+
+    bool check_compatibility(const std::unordered_set<CRE::Token>& plugin_capabilities);
+
+private:
+    enum class Delimiter { PARRENTHESIS, SIZE, NOT_CAPABILITY_ID };
+
+    void advance_iterator(std::vector<Token>::const_iterator& expression_iterator);
+
+    bool end_condition(const std::vector<Token>::const_iterator& expression_iterator, const Delimiter end_delimiter);
+
+    bool evaluate(std::vector<Token>::const_iterator& expression_iterator,
+                  const std::unordered_set<CRE::Token>& plugin_capabilities,
+                  const Delimiter end_delimiter);
+
+    std::vector<Token> m_expression;
+};
+
+class CRESection final : public ISection {
+public:
+    CRESection(const CRE& cre);
+
+    void write(std::ostream& stream, BlobWriter* writer) override;
+
+    std::optional<uint64_t> get_length() const override;
+
+    CRE get_cre() const;
+
+    static std::shared_ptr<ISection> read(BlobReader* blob_reader, const size_t section_length);
+
+private:
+    CRE m_cre;
+};
+
+}  // namespace intel_npu

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

@@ -4,6 +4,7 @@
 
 #pragma once
 
+#include "intel_npu/common/blob_writer.hpp"
 #include "intel_npu/common/filtered_config.hpp"
 #include "intel_npu/common/igraph.hpp"
 
@@ -12,7 +13,8 @@ namespace intel_npu {
 class ICompilerAdapter {
 public:
     virtual std::shared_ptr<IGraph> compile(const std::shared_ptr<const ov::Model>& model,
-                                            const FilteredConfig& config) const = 0;
+                                            const FilteredConfig& config,
+                                            const std::shared_ptr<BlobWriter>& blobWriter) const = 0;
 
     /**
      * @brief Compiles the model, weights separation enabled.
@@ -26,10 +28,12 @@ class ICompilerAdapter {
      * @param config Will be passed to the compiler. Additionally, the "SEPARATE_WEIGHTS_VERSION" option will determine
      * which weights separation implementation will be used. See the weights separation specific methods within
      * "icompiler.hpp".
+     * @param blobWriter TODO
      * @return A "WeightlessGraph" type of object.
      */
     virtual std::shared_ptr<IGraph> compileWS(const std::shared_ptr<ov::Model>& model,
-                                              const FilteredConfig& config) const = 0;
+                                              const FilteredConfig& config,
+                                              const std::shared_ptr<BlobWriter>& blobWriter) const = 0;
 
     /**
      * @brief Parses the provided binary objects and returns a wrapper over the resulted L0 handles. The model may also

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

@@ -25,10 +25,9 @@ class IGraph : public std::enable_shared_from_this<IGraph> {
      * later be used for importing the model.
      *
      * @param stream Where the content is placed
-     * @return A pair made of the size of the main binary object and an optional variable. The optional variable
-     * constitues the size of each init binary object if weights separation is enabled.
+     * @return TODO
      */
-    virtual std::pair<uint64_t, std::optional<std::vector<uint64_t>>> export_blob(std::ostream& stream) const = 0;
+    virtual uint64_t export_main_blob(std::ostream& stream) const = 0;
 
     virtual std::vector<ov::ProfilingInfo> process_profiling_output(const std::vector<uint8_t>& profData,
                                                                     const Config& config) const = 0;

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

@@ -0,0 +1,55 @@
+// Copyright (C) 2018-2025 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#pragma once
+
+#include <cinttypes>
+#include <iostream>
+#include <optional>
+#include <unordered_map>
+#include <unordered_set>
+#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;
+
+class BlobWriter;
+class BlobReader;
+
+namespace PredefinedSectionID {
+enum {
+    CRE = 100,
+    OFFSETS_TABLE = 101,
+    ELF_MAIN_SCHEDULE = 102,
+    ELF_INIT_SCHEDULES = 103,
+    IO_LAYOUTS = 104,
+    BATCH_SIZE = 105,
+};
+};
+
+class ISection {
+public:
+    ISection(const SectionID section_id);
+
+    virtual ~ISection() = default;
+
+    virtual void write(std::ostream& stream, BlobWriter* writer) = 0;
+
+    // note necessary, saves some performance if provided
+    virtual std::optional<uint64_t> get_length() const;
+
+    SectionID get_section_id() const;
+
+private:
+    SectionID m_section_id;
+};
+
+}  // namespace intel_npu

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

@@ -0,0 +1,29 @@
+// Copyright (C) 2018-2025 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#pragma once
+
+#include <functional>
+
+#include "intel_npu/common/isection.hpp"
+
+namespace intel_npu {
+
+class OffsetsTableSection final : public ISection {
+public:
+    OffsetsTableSection(const std::unordered_map<SectionID, uint64_t>& offsets_table);
+
+    void write(std::ostream& stream, BlobWriter* writer) override;
+
+    std::optional<uint64_t> get_length() const override;
+
+    std::unordered_map<SectionID, uint64_t> get_table() const;
+
+    static std::shared_ptr<ISection> read(BlobReader* blob_reader, const size_t section_length);
+
+private:
+    std::unordered_map<SectionID, uint64_t> m_offsets_table;
+};
+
+}  // namespace intel_npu