Debugging

Author: slyalin

src/core/include/openvino/op/constant.hpp

@@ -439,6 +439,18 @@ class OPENVINO_API Constant : public Op {
     /// @return Constant's strides in bytes.
     const Strides& get_strides() const;
 
+    /// @brief Sets the external name for the constant.
+    /// @param name The external name to set.
+    void set_external_name(const std::string& name) {
+        m_external_name = name;
+    }
+
+    /// @brief Gets the external name of the constant.
+    /// @return The external name.
+    const std::string& get_external_name() const {
+        return m_external_name;
+    }
+
 private:
     Constant(bool memset_allocation, const element::Type& type, const Shape& shape);
 
@@ -796,6 +808,9 @@ class OPENVINO_API Constant : public Op {
     mutable std::atomic_bool m_all_elements_bitwise_identical{false};
     mutable std::atomic_bool m_all_elements_bitwise_identical_checked{false};
     bool m_alloc_buffer_on_visit_attributes{true};
+
+    // TODO: Move to dedicated ExternalConstant op:
+    std::string m_external_name;
 };
 
 template <>

src/core/src/op/constant.cpp

@@ -324,7 +324,8 @@ Constant::Constant(const Constant& other)
       m_data{other.m_data},
       m_all_elements_bitwise_identical{other.m_all_elements_bitwise_identical.load()},
       m_all_elements_bitwise_identical_checked{other.m_all_elements_bitwise_identical_checked.load()},
-      m_alloc_buffer_on_visit_attributes{other.m_alloc_buffer_on_visit_attributes} {
+      m_alloc_buffer_on_visit_attributes{other.m_alloc_buffer_on_visit_attributes},
+      m_external_name{other.m_external_name} {
     constructor_validate_and_infer_types();
 }
 
@@ -591,32 +592,46 @@ bool Constant::visit_attributes(AttributeVisitor& visitor) {
     OV_OP_SCOPE(v0_Constant_visit_attributes);
     const auto prev_shape = m_shape;
     const auto prev_type = m_element_type;
+    const auto prev_external_name = m_external_name;
     visitor.on_attribute("element_type", m_element_type);
     visitor.on_attribute("shape", m_shape);
+    visitor.on_attribute("external_name", m_external_name);
 
-    const auto need_to_reallocate = (m_shape != prev_shape) || (prev_type != m_element_type);
-    const auto is_string_constant = (m_element_type == element::string);
-    if (m_alloc_buffer_on_visit_attributes && need_to_reallocate) {
-        // string objects initialization is required, others filling in a fresh constant
-        allocate_buffer(is_string_constant);
-    }
-
-    if (is_string_constant) {
-        if (auto string_aligned_buffer = std::dynamic_pointer_cast<ov::StringAlignedBuffer>(m_data)) {
-            visitor.on_attribute("value", string_aligned_buffer);
-        } else if (auto shared_string_tensor = std::dynamic_pointer_cast<ov::SharedBuffer<ov::Tensor>>(m_data)) {
-            auto shared_string_buffer =
-                std::make_shared<ov::SharedStringAlignedBuffer>(shared_string_tensor->get_ptr<char>(),
-                                                                shared_string_tensor->size());
-            visitor.on_attribute("value", shared_string_buffer);
+    if(!m_external_name.empty()) {
+        if(prev_external_name != m_external_name) {
+            // If it becomes an external constant or change it's content, it is unlinked
+            std::cerr << "[ DEBUG ] ExternalConstant in Constant::visit_attributes is activated" << std::endl;
+            m_data.reset();
         } else {
-            // deserialization case when buffer does not exist yet
-            std::shared_ptr<ov::StringAlignedBuffer> string_aligned_buffer;
-            visitor.on_attribute("value", string_aligned_buffer);
-            m_data = string_aligned_buffer;
+            std::cerr << "[ DEBUG ] Retriving value from Constant::visit_attributes" << std::endl;
+            std::cerr << "          m_external_name = " << m_external_name << std::endl;
+            std::cerr << "          Skip value retrieving" << std::endl;
         }
     } else {
-        visitor.on_attribute("value", m_data);
+        const auto need_to_reallocate = (m_shape != prev_shape) || (prev_type != m_element_type);
+        const auto is_string_constant = (m_element_type == element::string);
+        if (m_alloc_buffer_on_visit_attributes && need_to_reallocate) {
+            // string objects initialization is required, others filling in a fresh constant
+            allocate_buffer(is_string_constant);
+        }
+
+        if (is_string_constant) {
+            if (auto string_aligned_buffer = std::dynamic_pointer_cast<ov::StringAlignedBuffer>(m_data)) {
+                visitor.on_attribute("value", string_aligned_buffer);
+            } else if (auto shared_string_tensor = std::dynamic_pointer_cast<ov::SharedBuffer<ov::Tensor>>(m_data)) {
+                auto shared_string_buffer =
+                    std::make_shared<ov::SharedStringAlignedBuffer>(shared_string_tensor->get_ptr<char>(),
+                                                                    shared_string_tensor->size());
+                visitor.on_attribute("value", shared_string_buffer);
+            } else {
+                // deserialization case when buffer does not exist yet
+                std::shared_ptr<ov::StringAlignedBuffer> string_aligned_buffer;
+                visitor.on_attribute("value", string_aligned_buffer);
+                m_data = string_aligned_buffer;
+            }
+        } else {
+            visitor.on_attribute("value", m_data);
+        }
     }
     update_identical_flags(false, false);
     return true;

src/core/src/pass/serialize.cpp

@@ -582,6 +582,8 @@ class XmlSerializer : public ov::AttributeVisitor {
         } else if (const auto& a = ov::as_type<ov::AttributeAdapter<std::shared_ptr<ov::AlignedBuffer>>>(&adapter)) {
             if (name == "value" && translate_type_name(m_node_type_name) == "Const") {
                 const int64_t size = a->get()->size();
+                if(size > 100000)
+                    std::cerr << "[ DEBUG ] SERIALIZE value of big size: " << size << std::endl;
                 size_t new_size;
                 int64_t offset = m_constant_write_handler.write(static_cast<const char*>(a->get()->get_ptr()),
                                                                 size,
@@ -1010,6 +1012,9 @@ void ngfunction_2_ir(pugi::xml_node& netXml,
 
     auto sorted_ops = model.get_ordered_ops();
 
+    int iii = 0;
+    std::cerr << "DEBUG " << iii++ << std::endl;
+
     // get_ordered_ops() returns operations after a topological sort. The topological sort reverses order of Parameters
     // and Results. So we need to put them into sorted_ops separately to ensure correct order of inputs and outputs.
     {
@@ -1033,7 +1038,12 @@ void ngfunction_2_ir(pugi::xml_node& netXml,
         sorted_ops = std::move(result);
     }
 
+    std::cerr << "DEBUG " << iii++ << std::endl;
+    int jjj = 0;
+
     for (const auto& n : sorted_ops) {
+
+        std::cerr << jjj++ << std::endl;
         ov::Node* node = n.get();
         int node_id{};
         {
@@ -1214,6 +1224,8 @@ void ngfunction_2_ir(pugi::xml_node& netXml,
             layer.remove_child(data);
         }
     }
+    std::cerr << "DEBUG " << iii++ << std::endl;
+
     // <edges>
     const std::vector<Edge> edge_mapping = create_edge_mapping(layer_ids, model);
     pugi::xml_node edges = netXml.append_child("edges");
@@ -1233,6 +1245,7 @@ void ngfunction_2_ir(pugi::xml_node& netXml,
         edge.append_attribute("to-port").set_value(e.to_port);
     }
 
+    std::cerr << "DEBUG " << iii++ << std::endl;
     // Serialize rt info
     pugi::xml_node rt_info_node = netXml.append_child("rt_info");
     for (const auto& it : model.get_rt_info()) {
@@ -1241,6 +1254,7 @@ void ngfunction_2_ir(pugi::xml_node& netXml,
             continue;
         serialize_rt_info(rt_info_node, it.first, it.second);
     }
+    std::cerr << "DEBUG " << iii++ << std::endl;
 }
 
 std::string valid_xml_path(const std::string& path) {

src/frontends/pytorch/src/op/linear.cpp

@@ -31,11 +31,28 @@ OutputVector translate_linear(const NodeContext& context) {
     return {matmul};
 };
 
+std::string demangle_dict_state_name(const std::string& name) {
+    const std::string prefix = "self.";
+    if (name.rfind(prefix, 0) == 0) {
+        return name.substr(prefix.size());
+    }
+    FRONT_END_OP_CONVERSION_CHECK(false, "Name does not start with 'self.' prefix: " + name);
+}
+
 OutputVector translate_linear_ext(const NodeContext& context) {
     num_inputs_check(context, 2, 3);
+    // std::cerr << "[ DEBUG ] translate_linear_ext" << std::endl;
     auto x = context.get_input(0);
     auto initial_x = x;
     auto weight = context.get_input(1);
+    auto weight_node = weight.get_node_shared_ptr();
+    std::cerr << "[ DEBUG ] Name of weight layer:  " << weight_node->get_friendly_name() << std::endl;
+    // std::cerr << "[ DEBUG ] Name of weight tensor: " << weight.get_any_name() << std::endl;
+    if (auto constant_node = ov::as_type_ptr<v0::Constant>(weight_node)) {
+        auto name = demangle_dict_state_name(weight_node->get_friendly_name());
+        std::cerr << "    [ DEBUG ] Set external constant name: " << name << std::endl;
+        constant_node->set_external_name(name);
+    }
     bool convert_back = false;
     if (weight.get_element_type() != element::f32) {
         // In case of patched linear it can have mixed fp16/bf16 and fp32 input type.
@@ -48,9 +65,15 @@ OutputVector translate_linear_ext(const NodeContext& context) {
         }
     }
     auto matmul = context.mark_node(std::make_shared<v0::MatMul>(x, weight, false, true));
+    // std::cerr << "[ DEBUG ] Name of matmul layer: " << matmul->get_friendly_name() << std::endl;
     if (!context.input_is_none(2)) {
+        std::cerr << "[ DEBUG ] There is bias addon" << std::endl;
         auto bias = context.get_input(2);
 
+        auto bias_node = weight.get_node_shared_ptr();
+        std::cerr << "[ DEBUG ] Name of bias layer:  " << bias_node->get_friendly_name() << std::endl;
+
+
         if (bias.get_element_type() != element::f32) {
             // Same reason as for weight.
             bias = context.mark_node(std::make_shared<v0::Convert>(bias, element::f32));