[NPU] Cvs 169982 weights serialization

cmake/developer_package/ncc_naming_style/openvino.style

@@ -1,6 +1,6 @@
 # custom OpenVINO values
 CppMethod: '^(operator\W+|[a-z_\d]+|signaling_NaN|quiet_NaN|OPENVINO_OP|OPENVINO_RTTI)$'
-ClassName: '^([A-Z][\w]+|b?float16|float8_e4m3|float8_e5m2|float4_e2m1|float8_e8m0|numeric_limits|ngraph_error|stopwatch|unsupported_op)$'
+ClassName: '^([A-Z][\w]+|b?float16|float8_e4m3|float8_e5m2|float4_e2m1|float8_e8m0|numeric_limits|xml_node|stopwatch|unsupported_op)$'
 StructName: '^([A-Z][\w]+|element_type_traits|hash|oi_pair|stat)$'
 FunctionName: '^(operator\W+|[a-z_\d]+)|PrintTo$'
 Namespace: '^([a-z\d_]*)$'

src/common/util/include/openvino/util/common_util.hpp

@@ -7,6 +7,7 @@
 #include <algorithm>
 #include <array>
 #include <cctype>
+#include <cstdint>
 #include <cstring>
 #include <numeric>
 #include <sstream>
@@ -78,6 +79,21 @@ inline size_t hash_combine(std::initializer_list<size_t>&& list) {
     return seed;
 }
 
+constexpr uint64_t u64_hash_combine(uint64_t h, uint64_t k) {
+    // Hash combine formula from boost for uint64_t.
+    constexpr uint64_t m = 0xc6a4a7935bd1e995;
+    constexpr int r = 47;
+
+    k *= m;
+    k ^= k >> r;
+    k *= m;
+
+    h ^= k;
+    h *= m;
+
+    return h + 0xe6546b64;
+}
+
 /**
  * @brief trim from start (in place)
  * @param s - string to trim

src/common/util/src/xml_parse_utils.cpp

@@ -233,4 +233,4 @@ int pugixml::get_int_child(const pugi::xml_node& node, const char* str, int defV
 }
 
 }  // namespace util
-}  // namespace ov
+}  // namespace ov

src/core/CMakeLists.txt

@@ -17,6 +17,7 @@ file(GLOB_RECURSE DEV_HEADERS ${OV_CORE_DEV_API_PATH}/*.hpp)
 
 add_subdirectory(reference)
 add_subdirectory(shape_inference)
+add_subdirectory(xml_util)
 
 set(MIXED_SRC
     "${CMAKE_CURRENT_SOURCE_DIR}/src/runtime/allocator.cpp"

src/core/dev_api/openvino/xml_util/constant_writer.hpp

@@ -0,0 +1,54 @@
+// Copyright (C) 2018-2025 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#pragma once
+
+#include <iostream>
+#include <map>
+
+#include "openvino/core/attribute_visitor.hpp"
+#include "openvino/core/type/element_type.hpp"
+#include "openvino/core/visibility.hpp"
+
+namespace ov::util {
+
+class OPENVINO_API OstreamHashWrapperBin final : public std::streambuf {
+    uint64_t m_res = 0lu;
+
+public:
+    uint64_t get_result() const {
+        return m_res;
+    }
+    std::streamsize xsputn(const char* s, std::streamsize n) override;
+};
+
+class OPENVINO_API ConstantWriter {
+public:
+    using FilePosition = int64_t;
+    using HashValue = size_t;
+    using ConstWritePositions = std::multimap<HashValue, std::pair<FilePosition, const void*>>;
+
+    ConstantWriter(std::ostream& bin_data, bool enable_compression = true);
+    virtual ~ConstantWriter();
+
+    virtual FilePosition write(const char* ptr,
+                               size_t size,
+                               size_t& new_size,
+                               bool compress_to_fp16 = false,
+                               ov::element::Type src_type = ov::element::dynamic,
+                               bool ptr_is_temporary = false);
+
+private:
+    static std::unique_ptr<char[]> compress_data_to_fp16(const char* ptr,
+                                                         size_t size,
+                                                         ov::element::Type src_type,
+                                                         size_t& compressed_size);
+
+    ConstWritePositions m_hash_to_file_positions;
+    std::reference_wrapper<std::ostream> m_binary_output;
+    bool m_enable_compression;
+    bool m_write_hash_value;
+    FilePosition m_blob_offset;  // blob offset inside output stream
+};
+}  // namespace ov::util

src/core/dev_api/openvino/xml_util/xml_serialize_util.hpp

@@ -0,0 +1,105 @@
+// Copyright (C) 2018-2025 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#pragma once
+
+#include <functional>
+#include <map>
+#include <pugixml.hpp>
+#include <string>
+#include <vector>
+
+#include "openvino/core/type/element_type.hpp"
+#include "openvino/core/visibility.hpp"
+#include "openvino/op/loop.hpp"
+#include "openvino/op/util/multi_subgraph_base.hpp"
+#include "openvino/util/common_util.hpp"
+#include "openvino/xml_util/constant_writer.hpp"
+
+namespace ov::util {
+
+OPENVINO_API std::string get_ir_precision_name(const element::Type& precision);
+
+class OPENVINO_API XmlSerializer : public ov::AttributeVisitor {
+    pugi::xml_node& m_xml_node;
+    const std::string& m_node_type_name;
+    std::reference_wrapper<util::ConstantWriter> m_constant_node_write_handler;
+    int64_t m_version;
+    bool m_deterministic;
+    bool m_compress_to_fp16;
+    ov::element::Type m_output_element_type;
+    bool m_data_is_temporary;
+    std::function<bool(pugi::xml_node& node, const ov::RuntimeAttribute& attribute)> m_custom_rt_info_append;
+
+    template <typename T>
+    std::string create_attribute_list(ov::ValueAccessor<std::vector<T>>& adapter) {
+        return util::join(adapter.get());
+    }
+
+    std::vector<std::string> map_type_from_body(const pugi::xml_node& xml_node,
+                                                const std::string& map_type,
+                                                int64_t ir_version,
+                                                const std::string& body_name = "body");
+
+    void input_descriptions_on_adapter(
+        const std::vector<std::shared_ptr<ov::op::util::MultiSubGraphOp::InputDescription>>& input_descriptions,
+        const std::vector<std::string>& parameter_mapping,
+        const std::vector<std::string>& result_mapping,
+        pugi::xml_node& port_map,
+        const std::string& portmap_name);
+
+    void output_descriptions_on_adapter(
+        const std::vector<std::shared_ptr<ov::op::util::MultiSubGraphOp::OutputDescription>>& output_descriptions,
+        const uint32_t& input_count,
+        const std::vector<std::string>& result_mapping,
+        pugi::xml_node& port_map,
+        const std::string& portmap_name);
+
+    void special_body_ports_on_adapter(const ov::op::v5::Loop::SpecialBodyPorts& special_body_ports,
+                                       const std::vector<std::string>& parameter_mapping,
+                                       const std::vector<std::string>& result_mapping,
+                                       pugi::xml_node& port_map);
+
+    virtual std::unique_ptr<XmlSerializer> make_visitor(pugi::xml_node& data,
+                                                        const std::string& node_type_name,
+                                                        ov::util::ConstantWriter& constant_write_handler,
+                                                        int64_t version,
+                                                        bool deterministic = false,
+                                                        bool compress_to_fp16 = false,
+                                                        ov::element::Type output_element_type = ov::element::dynamic,
+                                                        bool data_is_temporary = false) const;
+
+    void serialize(pugi::xml_node& net_xml, const ov::Model& model);
+
+protected:
+    virtual void append_rt_info(pugi::xml_node& node, ov::RTMap& attributes);
+    virtual bool append_rt_attribute(pugi::xml_node& node, const ov::RuntimeAttribute& attribute);
+    virtual bool append_node_attributes(ov::Node& node);
+    virtual util::ConstantWriter& get_constant_write_handler() const {
+        return m_constant_node_write_handler;
+    }
+
+public:
+    XmlSerializer(pugi::xml_node& data,
+                  const std::string& node_type_name,
+                  ov::util::ConstantWriter& constant_write_handler,
+                  int64_t version,
+                  bool deterministic = false,
+                  bool compress_to_fp16 = false,
+                  ov::element::Type output_element_type = ov::element::dynamic,
+                  bool data_is_temporary = false);
+
+    void on_adapter(const std::string& name, ov::ValueAccessor<void>& adapter) override;
+    void on_adapter(const std::string& name, ov::ValueAccessor<bool>& adapter) override;
+    void on_adapter(const std::string& name, ov::ValueAccessor<std::string>& adapter) override;
+    void on_adapter(const std::string& name, ov::ValueAccessor<int64_t>& adapter) override;
+    void on_adapter(const std::string& name, ov::ValueAccessor<double>& adapter) override;
+    void on_adapter(const std::string& name, ov::ValueAccessor<std::vector<int>>& adapter) override;
+    void on_adapter(const std::string& name, ov::ValueAccessor<std::vector<int64_t>>& adapter) override;
+    void on_adapter(const std::string& name, ov::ValueAccessor<std::vector<uint64_t>>& adapter) override;
+    void on_adapter(const std::string& name, ov::ValueAccessor<std::vector<float>>& adapter) override;
+    void on_adapter(const std::string& name, ov::ValueAccessor<std::vector<std::string>>& adapter) override;
+    void on_adapter(const std::string& name, ov::ValueAccessor<std::shared_ptr<ov::Model>>& adapter) override;
+};  // class XmlSerializer
+}  // namespace ov::util

src/core/include/openvino/pass/serialize.hpp

@@ -12,8 +12,16 @@
 #include "openvino/opsets/opset.hpp"
 #include "openvino/pass/pass.hpp"
 
-namespace ov {
-namespace pass {
+namespace pugi {
+class xml_node;  // NCC
+}
+
+namespace ov::util {
+class XmlSerializer;
+class ConstantWriter;
+}  // namespace ov::util
+
+namespace ov::pass {
 
 /**
  * @brief Serialize transformation converts ov::Model into IR files
@@ -76,10 +84,19 @@ class OPENVINO_API StreamSerialize : public ov::pass::ModelPass {
 private:
     virtual bool use_absolute_offset();
 
+    virtual std::unique_ptr<util::XmlSerializer> make_serializer(
+        pugi::xml_node& data,
+        const std::string& node_type_name,
+        util::ConstantWriter& constant_write_handler,
+        int64_t version,
+        bool deterministic = false,
+        bool compress_to_fp16 = false,
+        ov::element::Type output_element_type = ov::element::dynamic,
+        bool data_is_temporary = false) const;
+
     std::ostream& m_stream;
     std::function<void(std::ostream&)> m_custom_data_serializer;
     std::function<std::string(const std::string&)> m_cache_encrypt;
     const Serialize::Version m_version;
 };
-}  // namespace pass
-}  // namespace ov
+}  // namespace ov::pass