Reduce IR Constant Memory Retention

src/core/tests/xml_util/custom_ir.cpp

@@ -99,13 +99,18 @@ class CustomIRTest : public testing::Test {
         }();
 
         std::unordered_map<std::string, std::shared_ptr<ov::op::util::Variable>> variables;
+        std::shared_ptr<ov::util::WeightsProvider> weights_provider;
+        if (org_weights) {
+            weights_provider = std::make_shared<ov::util::BufferWeightsProvider>(org_weights);
+        }
         // deserialize model
         std::shared_ptr<ov::Model> model;
         if constexpr (std::is_same_v<Deserializer, ov::util::XmlDeserializer>) {
-            Deserializer visitor(root, org_weights, opsets, create_extensions_map, variables, version);
+            Deserializer visitor(root, weights_provider, opsets, create_extensions_map, variables, version);
             visitor.on_attribute("net", model);
         } else {
-            Deserializer visitor(root, org_weights, weights_map, opsets, create_extensions_map, variables, version);
+            Deserializer
+                visitor(root, weights_provider, weights_map, opsets, create_extensions_map, variables, version);
             visitor.on_attribute("net", model);
         }
 
@@ -251,14 +256,14 @@ class XmlDeserializer : public ov::util::XmlDeserializer {
 
 public:
     explicit XmlDeserializer(const pugi::xml_node& node,
-                             const std::shared_ptr<ov::AlignedBuffer>& origin_weights,
+                             const std::shared_ptr<ov::util::WeightsProvider>& weights_provider,
                              const WeightsMap& weights_map,
                              const std::unordered_map<std::string, ov::OpSet>& opsets,
                              const std::unordered_map<ov::DiscreteTypeInfo, ov::BaseOpExtension::Ptr>& extensions,
                              std::unordered_map<std::string, std::shared_ptr<ov::op::util::Variable>>& variables,
                              size_t version)
-        : ov::util::XmlDeserializer(node, origin_weights, opsets, extensions, variables, version),
-          m_origin_weights{origin_weights},
+        : ov::util::XmlDeserializer(node, weights_provider, opsets, extensions, variables, version),
+          m_weights_provider{weights_provider},
           m_weights_map{std::ref(weights_map)} {}
 
 protected:
@@ -313,9 +318,7 @@ class XmlDeserializer : public ov::util::XmlDeserializer {
                 actual_size = wl.original_size;
                 offset = wl.bin_offset;
                 auto original_dtype = wl.original_dtype;
-                char* data = m_origin_weights->get_ptr<char>() + offset;
-                auto w_size = m_origin_weights->size();
-                auto w_so = m_origin_weights;
+                auto w_size = m_weights_provider->size();
 
                 OPENVINO_ASSERT(w_size >= offset + actual_size, "Incorrect weights in bin file!");
                 if (original_dtype != el_type) {
@@ -335,9 +338,7 @@ class XmlDeserializer : public ov::util::XmlDeserializer {
                                        ov::util::get_memory_size(el_type, ov::shape_size(shape)));
                     }
 
-                    auto buffer =
-                        std::make_shared<ov::SharedBuffer<std::shared_ptr<ov::AlignedBuffer>>>(data, actual_size, w_so);
-                    adapter.set(buffer);
+                    adapter.set(m_weights_provider->make_region(offset, actual_size));
                 }
             } else {
                 auto& buff = m_weights_map.get().at(offset);
@@ -349,21 +350,21 @@ class XmlDeserializer : public ov::util::XmlDeserializer {
 private:
     std::unique_ptr<ov::util::XmlDeserializer> make_visitor(
         const pugi::xml_node& node,
-        const std::shared_ptr<ov::AlignedBuffer>& origin_weights,
+        const std::shared_ptr<ov::util::WeightsProvider>& weights_provider,
         const std::unordered_map<std::string, ov::OpSet>& opsets,
         const std::unordered_map<ov::DiscreteTypeInfo, ov::BaseOpExtension::Ptr>& extensions,
         std::unordered_map<std::string, std::shared_ptr<ov::op::util::Variable>>& variables,
         size_t version) const override {
         return std::make_unique<XmlDeserializer>(node,
-                                                 origin_weights,
+                                                 weights_provider,
                                                  m_weights_map,
                                                  opsets,
                                                  extensions,
                                                  variables,
                                                  version);
     }
 
-    std::shared_ptr<ov::AlignedBuffer> m_origin_weights;
+    std::shared_ptr<ov::util::WeightsProvider> m_weights_provider;
     std::reference_wrapper<const WeightsMap> m_weights_map;
 };
 

src/core/xml_util/CMakeLists.txt

@@ -7,9 +7,11 @@ set(TARGET_NAME "openvino_xml_util")
 set(TARGET_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/include")
 
 set(LIBRARY_SRC
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/weights_provider.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/src/xml_deserialize_util.cpp
 )
 set(PUBLIC_HEADERS
+    ${TARGET_INCLUDE_DIR}/openvino/xml_util/weights_provider.hpp
     ${TARGET_INCLUDE_DIR}/openvino/xml_util/xml_deserialize_util.hpp
 )
 

src/core/xml_util/include/openvino/xml_util/weights_provider.hpp

@@ -0,0 +1,128 @@
+// Copyright (C) 2018-2026 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#pragma once
+
+#include <filesystem>
+#include <map>
+#include <memory>
+
+namespace ov {
+class AlignedBuffer;
+}  // namespace ov
+
+namespace ov::util {
+
+/**
+ * @brief Interface for loading weight data regions from an underlying storage.
+ *
+ * Implementations may serve weights either from an in-memory buffer or from a
+ * file-backed source.
+ */
+class WeightsProvider {
+public:
+    virtual ~WeightsProvider() = default;
+
+    /**
+     * @brief Make a contiguous region of weights.
+     *
+     * @param offset Byte offset from the beginning of the weights source.
+     * @param size Number of bytes to load.
+     * @return Buffer containing the requested weights region.
+     */
+    virtual std::shared_ptr<ov::AlignedBuffer> make_region(size_t offset, size_t size) = 0;
+
+    /**
+     * @brief Returns the total size of the weights source in bytes.
+     *
+     * @return Size of the underlying weights source.
+     */
+    virtual size_t size() const = 0;
+
+    /**
+     * @brief Returns the path to the weights source when the provider is file-backed.
+     *
+     * @return Path to the weights source, or an empty path if the provider is not file-backed.
+     */
+    virtual std::filesystem::path path() const;
+};
+
+/**
+ * @brief Weights provider implementation backed by an already allocated buffer.
+ */
+class BufferWeightsProvider : public WeightsProvider {
+public:
+    /**
+     * @brief Constructs a weights provider over an existing buffer.
+     *
+     * @param weights Buffer containing the full weights blob.
+     */
+    explicit BufferWeightsProvider(std::shared_ptr<ov::AlignedBuffer> weights);
+
+    /**
+     * @brief Returns a view of the requested region from the backing buffer.
+     *
+     * @param offset Byte offset from the beginning of the weights buffer.
+     * @param size Number of bytes to expose.
+     * @return Buffer referencing the requested region.
+     */
+    std::shared_ptr<ov::AlignedBuffer> make_region(size_t offset, size_t size) override;
+
+    /**
+     * @brief Returns the total size of the backing weights buffer in bytes.
+     *
+     * @return Size of the underlying buffer.
+     */
+    size_t size() const override;
+
+private:
+    std::shared_ptr<ov::AlignedBuffer> m_weights;
+};
+
+/**
+ * @brief Weights provider implementation backed by a weights file on disk.
+ */
+class FileWeightsProvider : public WeightsProvider {
+public:
+    /**
+     * @brief Constructs a weights provider for the specified file.
+     *
+     * @param weights_path Path to the weights file.
+     */
+    explicit FileWeightsProvider(std::filesystem::path weights_path);
+
+    /**
+     * @brief Loads the requested region from the weights file.
+     *
+     * Implementations may cache previously loaded regions.
+     *
+     * @param offset Byte offset from the beginning of the weights file.
+     * @param size Number of bytes to load.
+     * @return Buffer containing the requested file region.
+     */
+    std::shared_ptr<ov::AlignedBuffer> make_region(size_t offset, size_t size) override;
+
+    /**
+     * @brief Returns the total size of the weights file in bytes.
+     *
+     * @return Size of the file-backed weights source.
+     */
+    size_t size() const override;
+
+    /**
+     * @brief Returns the path to the backing weights file.
+     *
+     * @return Path to the backing weights file.
+     */
+    std::filesystem::path path() const override;
+
+private:
+    using WeightsRegionKey = std::pair<size_t, size_t>;
+
+    std::filesystem::path m_weights_path{};
+    size_t m_weights_size{};
+    // Cache of previously loaded weights regions, keyed by (offset, size) of the region in the weights file.
+    std::map<WeightsRegionKey, std::weak_ptr<ov::AlignedBuffer>> m_loaded_weights_regions;
+};
+}  // namespace ov::util

src/core/xml_util/include/openvino/xml_util/xml_deserialize_util.hpp

@@ -19,6 +19,7 @@
 #include "openvino/runtime/aligned_buffer.hpp"
 #include "openvino/util/common_util.hpp"
 #include "openvino/util/string_view_streambuf.hpp"
+#include "openvino/xml_util/weights_provider.hpp"
 
 namespace ov::util {
 struct GenericLayerParams;
@@ -49,7 +50,7 @@ void str_to_container<std::vector<std::string>>(const std::string& value, std::v
 class XmlDeserializer : public ov::AttributeVisitor {
 public:
     explicit XmlDeserializer(const pugi::xml_node& node,
-                             const std::shared_ptr<ov::AlignedBuffer>& weights,
+                             const std::shared_ptr<WeightsProvider>& weights_provider,
                              const std::unordered_map<std::string, ov::OpSet>& opsets,
                              const std::unordered_map<ov::DiscreteTypeInfo, ov::BaseOpExtension::Ptr>& extensions,
                              std::unordered_map<std::string, std::shared_ptr<ov::op::util::Variable>>& variables,
@@ -78,8 +79,8 @@ class XmlDeserializer : public ov::AttributeVisitor {
     virtual void set_constant_num_buffer(ov::AttributeAdapter<std::shared_ptr<ov::AlignedBuffer>>& adapter);
 
     const pugi::xml_node& get_node() const;
-    const std::shared_ptr<ov::AlignedBuffer>& get_weights() const {
-        return m_weights;
+    const std::shared_ptr<WeightsProvider>& get_weights_provider() const {
+        return m_weights_provider;
     }
 
 private:
@@ -107,10 +108,8 @@ class XmlDeserializer : public ov::AttributeVisitor {
 
     /// \brief Traverses xml node representation in order to create ov function for it.
     /// \param node xml node representation
-    /// \param weights weights attached to current node
     /// \return shared pointer to function representing input node
-    std::shared_ptr<ov::Model> parse_function(const pugi::xml_node& root,
-                                              const std::shared_ptr<ov::AlignedBuffer>& weights);
+    std::shared_ptr<ov::Model> parse_function(const pugi::xml_node& root);
     /// \brief Traverses xml node representation in order to get the purpose attribute of
     /// inputs/outputs in the body of Loop op. \param node xml node representation \return struct
     /// with value of purpuse attribute
@@ -120,7 +119,7 @@ class XmlDeserializer : public ov::AttributeVisitor {
 
     std::shared_ptr<ov::Node> create_node(const ov::OutputVector& inputs,
                                           const pugi::xml_node& node,
-                                          const std::shared_ptr<ov::AlignedBuffer>& weights,
+                                          const std::shared_ptr<ov::util::WeightsProvider>& weights_provider,
                                           const GenericLayerParams& params);
 
     void read_meta_data(const std::shared_ptr<ov::Model>& model, const pugi::xml_node& meta_section);
@@ -131,17 +130,17 @@ class XmlDeserializer : public ov::AttributeVisitor {
 
     virtual std::unique_ptr<XmlDeserializer> make_visitor(
         const pugi::xml_node& node,
-        const std::shared_ptr<ov::AlignedBuffer>& weights,
+        const std::shared_ptr<WeightsProvider>& weights_provider,
         const std::unordered_map<std::string, ov::OpSet>& opsets,
         const std::unordered_map<ov::DiscreteTypeInfo, ov::BaseOpExtension::Ptr>& extensions,
         std::unordered_map<std::string, std::shared_ptr<ov::op::util::Variable>>& variables,
         size_t version) const {
-        return std::make_unique<XmlDeserializer>(node, weights, opsets, extensions, variables, version);
+        return std::make_unique<XmlDeserializer>(node, weights_provider, opsets, extensions, variables, version);
     }
 
     // -- DATA --
     const pugi::xml_node m_node;
-    const std::shared_ptr<ov::AlignedBuffer>& m_weights;
+    const std::shared_ptr<WeightsProvider> m_weights_provider;
     const std::unordered_map<std::string, ov::OpSet>& m_opsets;
     const std::unordered_map<ov::DiscreteTypeInfo, ov::BaseOpExtension::Ptr>& m_extensions;
     std::unordered_map<std::string, std::shared_ptr<ov::op::util::Variable>>& m_variables;
@@ -151,7 +150,6 @@ class XmlDeserializer : public ov::AttributeVisitor {
     /// it will be used during Inputs/Outputs Description creation in SubGraph processing
     ///
     IoMap io_map;
-
     int64_t m_version;
 };