code review fixes

Author: evkotov

src/core/dev_api/openvino/core/bound_evaluation_util.hpp

@@ -37,17 +37,19 @@ OPENVINO_API Tensor evaluate_upper_bound(const Output<Node>& output);
 /// \return pair with Tensors for lower and upper value estimation.
 OPENVINO_API std::pair<Tensor, Tensor> evaluate_both_bounds(const Output<Node>& output);
 
-/// \brief Compares two tensors for equality (shape, type, and data).
-/// Used for bounds comparison in replace_source_output.
-/// \param a First tensor to compare.
-/// \param b Second tensor to compare.
-/// \return True if tensors are equal (or both empty), false otherwise.
-OPENVINO_API bool tensors_equal(const Tensor& a, const Tensor& b);
-
-/// \brief Force invalidates bounds on a tensor, bypassing SkipInvalidation attribute.
+/// \brief Checks if two outputs have the same bounds (lower and upper values).
+/// Returns true if both have no bounds, or if both have bounds with equal values.
+/// \note Unlike internal are_equal(), returns true when BOTH outputs have no bounds
+///       (semantically: "no bounds == no bounds").
+/// \param lhs First output to compare bounds from.
+/// \param rhs Second output to compare bounds to.
+/// \return True if bounds are equivalent, false otherwise.
+OPENVINO_API bool have_same_bounds(const Output<Node>& lhs, const Output<Node>& rhs);
+
+/// \brief Sets force invalidation on tensor bounds, bypassing SkipInvalidation attribute.
 /// Temporarily removes SkipInvalidation, calls invalidate_values(), then restores it.
 /// \param tensor Tensor descriptor to invalidate bounds on.
-OPENVINO_API void force_invalidate_bounds(descriptor::Tensor& tensor);
+OPENVINO_API void set_bounds_to_invalidate(descriptor::Tensor& tensor);
 
 }  // namespace util
 }  // namespace ov

src/core/src/bound_evaluate.cpp

@@ -739,7 +739,9 @@ bool ov::default_symbol_evaluator(const Node* node,
     return false;
 }
 
-bool ov::util::tensors_equal(const Tensor& a, const Tensor& b) {
+namespace {
+// Internal helper - compares tensor data, returns true if both empty
+bool bounds_data_equal(const ov::Tensor& a, const ov::Tensor& b) {
     // Both empty = equal
     if (!a && !b) {
         return true;
@@ -759,8 +761,16 @@ bool ov::util::tensors_equal(const Tensor& a, const Tensor& b) {
     // Compare data
     return std::memcmp(a.data(), b.data(), a.get_byte_size()) == 0;
 }
+}  // namespace
+
+bool ov::util::have_same_bounds(const Output<Node>& lhs, const Output<Node>& rhs) {
+    const auto& lhs_tensor = lhs.get_tensor();
+    const auto& rhs_tensor = rhs.get_tensor();
+    return bounds_data_equal(lhs_tensor.get_lower_value(), rhs_tensor.get_lower_value()) &&
+           bounds_data_equal(lhs_tensor.get_upper_value(), rhs_tensor.get_upper_value());
+}
 
-void ov::util::force_invalidate_bounds(descriptor::Tensor& tensor) {
+void ov::util::set_bounds_to_invalidate(descriptor::Tensor& tensor) {
     const auto& skip_type = ov::SkipInvalidation::get_type_info_static();
     auto& rt_info = tensor.get_rt_info();
     bool had_skip = rt_info.count(skip_type) > 0;

src/core/src/descriptor/input.cpp

@@ -33,9 +33,13 @@ ov::descriptor::Input::~Input() {
 }
 
 void ov::descriptor::Input::replace_output(Output& new_output) {
-    Output* old_output = m_output;
-
+    // Save old bounds BEFORE remove_input() because the old output's node may be destroyed
+    // after we disconnect (if this was the last reference to it)
+    ov::Tensor old_lower, old_upper;
     if (m_output != nullptr) {
+        const auto& old_tensor = m_output->get_tensor();
+        old_lower = old_tensor.get_lower_value();
+        old_upper = old_tensor.get_upper_value();
         m_output->remove_input(this);
     }
     new_output.add_input(this);
@@ -54,35 +58,32 @@ void ov::descriptor::Input::replace_output(Output& new_output) {
     // This ensures:
     // - OptimizeSymbolsUsedAsValues: Same bounds → no invalidation → optimization works
     // - AbsSinking: New Abs node has no bounds yet → invalidation → correct recalculation
-    if (old_output != nullptr && m_node != nullptr) {
-        const auto& old_tensor = old_output->get_tensor();
-        const auto& new_tensor = new_output.get_tensor();
-
-        const auto& old_lower = old_tensor.get_lower_value();
-        const auto& old_upper = old_tensor.get_upper_value();
-        const auto& new_lower = new_tensor.get_lower_value();
-        const auto& new_upper = new_tensor.get_upper_value();
-
+    if (m_node != nullptr) {
         bool old_has_bounds = old_lower && old_upper;
-        bool new_has_bounds = new_lower && new_upper;
-
-        // Invalidate if:
-        // 1. Old had bounds but new doesn't have bounds (node was replaced with newly created one)
-        // 2. Both have bounds but they differ
-        bool should_invalidate = false;
-        if (old_has_bounds && !new_has_bounds) {
-            // New source doesn't have bounds yet (e.g., newly created Abs in AbsSinking)
-            should_invalidate = true;
-        } else if (old_has_bounds && new_has_bounds) {
-            // Both have bounds - check if they differ
-            bool bounds_differ =
-                !ov::util::tensors_equal(old_lower, new_lower) || !ov::util::tensors_equal(old_upper, new_upper);
-            should_invalidate = bounds_differ;
-        }
-
-        if (should_invalidate) {
-            for (size_t port = 0; port < m_node->get_output_size(); ++port) {
-                ov::util::force_invalidate_bounds(m_node->get_output_tensor(port));
+        if (old_has_bounds) {
+            const auto& new_tensor = new_output.get_tensor();
+            const auto& new_lower = new_tensor.get_lower_value();
+            const auto& new_upper = new_tensor.get_upper_value();
+
+            // Internal comparison lambda (can't use have_same_bounds since old output is already gone)
+            auto tensors_match = [](const ov::Tensor& a, const ov::Tensor& b) {
+                if (!a && !b)
+                    return true;
+                if (!a || !b)
+                    return false;
+                if (a.get_shape() != b.get_shape())
+                    return false;
+                if (a.get_element_type() != b.get_element_type())
+                    return false;
+                return std::memcmp(a.data(), b.data(), a.get_byte_size()) == 0;
+            };
+
+            bool same_bounds = tensors_match(old_lower, new_lower) && tensors_match(old_upper, new_upper);
+
+            if (!same_bounds) {
+                for (size_t port = 0; port < m_node->get_output_size(); ++port) {
+                    ov::util::set_bounds_to_invalidate(m_node->get_output_tensor(port));
+                }
             }
         }
     }