[Transformations][GPU] Constant tensor deduplication pass

src/common/transformations/include/transformations/common_optimizations/constants_reduce.hpp

@@ -0,0 +1,19 @@
+// Copyright (C) 2025 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#pragma once
+
+#include "openvino/pass/matcher_pass.hpp"
+#include "transformations_visibility.hpp"
+
+namespace ov::pass {
+
+class TRANSFORMATIONS_API ConstantsReduce : public ov::pass::ModelPass {
+public:
+    OPENVINO_MODEL_PASS_RTTI("ConstantsReduce");
+    ConstantsReduce() = default;
+    bool run_on_model(const std::shared_ptr<ov::Model>& m) override;
+};
+
+}  // namespace ov::pass

src/common/transformations/src/transformations/common_optimizations/constants_reduce.cpp

@@ -0,0 +1,119 @@
+// Copyright (C) 2025 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#include "transformations/common_optimizations/constants_reduce.hpp"
+
+#include "itt.hpp"
+#include "openvino/op/constant.hpp"
+#include "openvino/util/log.hpp"
+
+#define LARGE_TENSOR_BYTE_SIZE 64
+
+namespace ov::pass {
+
+using BlobCacheKey = std::shared_ptr<ov::Node>;
+
+struct KeyHash {
+    std::size_t operator()(const BlobCacheKey& key) const {
+        std::size_t hash = 0;
+
+        auto node = ov::as_type_ptr<op::v0::Constant>(key);
+
+        auto type = node->get_output_element_type(0);
+        auto shape = node->get_shape();
+        std::size_t size = node->get_byte_size();
+        const char* data = node->get_data_ptr<char>();
+
+        for (auto dim : shape) {
+            hash ^= std::hash<size_t>{}(dim);
+        }
+
+        for (std::size_t i = 0; i < size; i++) {
+            hash ^= ((hash << 5) + hash) + data[i];
+        }
+
+        hash ^= type.hash();
+        hash ^= size;
+
+        return hash;
+    }
+};
+
+struct KeyEqual {
+    bool operator()(const BlobCacheKey& lhs, const BlobCacheKey& rhs) const {
+        auto lhs_node = ov::as_type_ptr<op::v0::Constant>(lhs);
+        auto rhs_node = ov::as_type_ptr<op::v0::Constant>(rhs);
+
+        auto lhs_type = lhs_node->get_output_element_type(0);
+        auto rhs_type = rhs_node->get_output_element_type(0);
+
+        if (lhs_type != rhs_type)
+            return false;
+
+        auto lhs_shape = lhs_node->get_shape();
+        auto rhs_shape = rhs_node->get_shape();
+
+        if (lhs_shape != rhs_shape)
+            return false;
+
+        std::size_t lhs_size = lhs_node->get_byte_size();
+        std::size_t rhs_size = rhs_node->get_byte_size();
+
+        if (lhs_size != rhs_size)
+            return false;
+
+        // Retrieve buffer pointers
+        const char* lhs_data = lhs_node->get_data_ptr<char>();
+        const char* rhs_data = rhs_node->get_data_ptr<char>();
+
+        if (lhs_data == rhs_data)
+            return true;
+
+        return std::memcmp(lhs_data, rhs_data, lhs_size) == 0;
+    }
+};
+
+bool ConstantsReduce::run_on_model(const std::shared_ptr<ov::Model>& m) {
+    MATCHER_SCOPE(ConstantsReduce);
+
+    std::unordered_map<BlobCacheKey, std::shared_ptr<ov::Node>, KeyHash, KeyEqual> blobMemCache;
+
+    const auto& ops = m->get_ops();
+
+    unsigned int copies = 0;
+
+    for (auto& op : ops) {
+        if (!ov::is_type<ov::op::v0::Constant>(op))
+            continue;
+
+        auto const_node = ov::as_type_ptr<op::v0::Constant>(op);
+
+        // Limit size of node reading to avoid reading large tensors
+        if (const_node->get_byte_size() > LARGE_TENSOR_BYTE_SIZE)
+            continue;
+
+        const auto cache_key = op;
+        auto bufIter = blobMemCache.find(cache_key);
+
+        if (bufIter == blobMemCache.end()) {
+            blobMemCache[cache_key] = op;
+        } else {
+            copies++;
+            auto users = const_node->get_users();
+            for (auto user : users) {
+                for (size_t i = 0; i < user->get_input_size(); i++) {
+                    if (user->input_value(i) == op->output(0)) {
+                        user->input(i).replace_source_output(blobMemCache[cache_key]);
+                    }
+                }
+            }
+        }
+    }
+    OPENVINO_DEBUG("Reduced ", copies, " constant node duplications from model");
+
+    // Return true if we have made any replacements
+    return copies > 0;
+}
+
+}  // namespace ov::pass

src/common/transformations/tests/common_optimizations/constants_reduce.cpp

@@ -0,0 +1,111 @@
+// Copyright (C) 2025 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#define _USE_MATH_DEFINES
+
+#include "transformations/common_optimizations/constants_reduce.hpp"
+
+#include <gtest/gtest.h>
+#include <math.h>
+
+#include <memory>
+
+#include "common_test_utils/ov_test_utils.hpp"
+#include "openvino/core/model.hpp"
+#include "openvino/opsets/opset8.hpp"
+#include "openvino/pass/manager.hpp"
+
+using namespace testing;
+using namespace ov;
+
+TEST(TransformationTests, ConstantsReduce) {
+    auto param = std::make_shared<opset8::Parameter>(element::f32, Shape{1, 4});
+
+    // Intentionally equal to each other
+    auto add_constant_1 = opset8::Constant::create(element::f32, Shape{1, 4}, {1.0, 2.0, 3.0, 4.0});
+    auto add_constant_2 = opset8::Constant::create(element::f32, Shape{1, 4}, {1.0, 2.0, 3.0, 4.0});
+    auto add_1 = std::make_shared<opset8::Add>(param, add_constant_1);
+    auto add_2 = std::make_shared<opset8::Add>(add_1, add_constant_2);
+
+    auto f = std::make_shared<Model>(NodeVector{add_2}, ParameterVector{param});
+
+    pass::Manager pass_manager;
+    pass_manager.register_pass<ov::pass::ConstantsReduce>();
+    pass_manager.run_passes(f);
+
+    // One constant should be reduced since they are equal
+    ASSERT_EQ(count_ops_of_type<opset8::Constant>(f), 1);
+}
+
+TEST(TransformationTests, ConstantsReduceChain) {
+    auto param = std::make_shared<opset8::Parameter>(element::f32, Shape{1, 4});
+
+    // Intentionally equal to each other
+    auto add_constant_1 = opset8::Constant::create(element::f32, Shape{1, 4}, {1.0, 2.0, 3.0, 4.0});
+    auto add_constant_2 = opset8::Constant::create(element::f32, Shape{1, 4}, {1.0, 2.0, 3.0, 4.0});
+    auto add_constant_3 = opset8::Constant::create(element::f32, Shape{1, 4}, {1.0, 2.0, 3.0, 4.0});
+    auto add_constant_4 = opset8::Constant::create(element::f32, Shape{1, 4}, {1.0, 2.0, 3.0, 4.0});
+
+    // Intentionally different
+    auto add_constant_5 = opset8::Constant::create(element::f32, Shape{1, 4}, {2.0, 2.0, 3.0, 4.0});
+    auto add_1 = std::make_shared<opset8::Add>(param, add_constant_1);
+    auto add_2 = std::make_shared<opset8::Add>(add_1, add_constant_2);
+    auto add_3 = std::make_shared<opset8::Add>(add_2, add_constant_3);
+    auto add_4 = std::make_shared<opset8::Add>(add_3, add_constant_4);
+    auto add_5 = std::make_shared<opset8::Add>(add_4, add_constant_5);
+
+    auto f = std::make_shared<Model>(NodeVector{add_5}, ParameterVector{param});
+
+    pass::Manager pass_manager;
+    pass_manager.register_pass<ov::pass::ConstantsReduce>();
+    pass_manager.run_passes(f);
+
+    // All constants should be reduced to one except the one that is different
+    ASSERT_EQ(count_ops_of_type<opset8::Constant>(f), 2);
+}
+
+TEST(TransformationTests, ConstantsReduceChain2) {
+    auto param = std::make_shared<opset8::Parameter>(element::f32, Shape{1, 4});
+
+    // Intentionally equal to each other
+    auto add_constant_1 = opset8::Constant::create(element::f32, Shape{1, 4}, {1.0, 2.0, 3.0, 4.0});
+    auto add_constant_2 = opset8::Constant::create(element::f32, Shape{1, 4}, {1.0, 2.0, 3.0, 4.0});
+    auto add_constant_3 = opset8::Constant::create(element::f32, Shape{1, 4}, {1.0, 2.0, 3.0, 4.0});
+    auto add_constant_4 = opset8::Constant::create(element::f32, Shape{1, 4}, {1.0, 2.0, 3.0, 4.0});
+    auto add_constant_5 = opset8::Constant::create(element::f32, Shape{1, 4}, {1.0, 2.0, 3.0, 4.0});
+
+    auto add_1 = std::make_shared<opset8::Add>(param, add_constant_1);
+    auto add_2 = std::make_shared<opset8::Add>(add_1, add_constant_2);
+    auto add_3 = std::make_shared<opset8::Add>(add_2, add_constant_3);
+    auto add_4 = std::make_shared<opset8::Add>(add_3, add_constant_4);
+    auto add_5 = std::make_shared<opset8::Add>(add_4, add_constant_5);
+
+    auto f = std::make_shared<Model>(NodeVector{add_5}, ParameterVector{param});
+
+    pass::Manager pass_manager;
+    pass_manager.register_pass<ov::pass::ConstantsReduce>();
+    pass_manager.run_passes(f);
+
+    // All constants should be reduced to one
+    ASSERT_EQ(count_ops_of_type<opset8::Constant>(f), 1);
+}
+
+TEST(TransformationTests, ConstantsReduceNeg) {
+    auto param = std::make_shared<opset8::Parameter>(element::f32, Shape{1, 4});
+
+    // Intentionally unequal to each other
+    auto add_constant_1 = opset8::Constant::create(element::f32, Shape{1, 4}, {1.0, 2.0, 3.0, 4.0});
+    auto add_constant_2 = opset8::Constant::create(element::f32, Shape{1, 4}, {1.0, 2.0, 3.0, 4.5});
+    auto add_1 = std::make_shared<opset8::Add>(param, add_constant_1);
+    auto add_2 = std::make_shared<opset8::Add>(add_1, add_constant_2);
+
+    auto f = std::make_shared<Model>(NodeVector{add_2}, ParameterVector{param});
+
+    pass::Manager pass_manager;
+    pass_manager.register_pass<ov::pass::ConstantsReduce>();
+    pass_manager.run_passes(f);
+
+    // No reduction here
+    ASSERT_EQ(count_ops_of_type<opset8::Constant>(f), 2);
+}

src/plugins/intel_gpu/include/intel_gpu/plugin/program_builder.hpp

@@ -97,8 +97,6 @@ class ProgramBuilder final {
     std::vector<cldnn::primitive_id> profiling_ids;
 
     std::map<size_t, cldnn::layout> inputLayouts;
-    using BlobCacheKey = std::tuple<const char*, ov::Shape, ov::element::Type>;
-    std::map<BlobCacheKey, cldnn::primitive_id> blobMemCache;
 
     std::shared_ptr<cldnn::program> get_compiled_program() const;
     std::shared_ptr<cldnn::topology> get_topology() const { return m_topology; }

src/plugins/intel_gpu/src/plugin/ops/constant.cpp

@@ -88,38 +88,26 @@ static void create_data(ProgramBuilder& p, const ov::Shape& const_shape, const s
     cldnn::primitive_id constPrimID;
     auto data = op->get_data_ptr<char>();
 
-    const auto cache_key = std::make_tuple(data, const_shape, op->get_output_element_type(0));
-
-    auto bufIter = p.blobMemCache.find(cache_key);
-
-    if (bufIter != p.blobMemCache.end()) {
-        constPrimID = bufIter->second;
-        p.primitive_ids[initialconstPrimID] = constPrimID;
-        p.profiling_ids.push_back(initialconstPrimID);
-    } else {
-        cldnn::memory::ptr mem = nullptr;
-        if (constLayout.bytes_count() > 0) {
+    cldnn::memory::ptr mem = nullptr;
+    if (constLayout.bytes_count() > 0) {
             mem = p.get_engine().allocate_memory(constLayout, false);
-        } else {
-            // In the case of empty const data with {0} shape, it has zero byte.
-            // To avoid zero byte memory allocation issue, reinterpret one dimension memory to zero dimension memory.
-            auto one_dim_layout = cldnn::layout(ov::PartialShape({1}), constLayout.data_type, constLayout.format);
-            auto one_dim_mem = p.get_engine().allocate_memory(one_dim_layout, false);
-            mem = p.get_engine().reinterpret_buffer(*one_dim_mem, constLayout);
-        }
-
-        GPU_DEBUG_LOG << "[" << initialconstPrimID << ": constant] layout: "
-                        << constLayout.to_short_string() << ", mem_ptr(" << mem << ", " << mem->size() << " bytes)"<< std::endl;
-        auto& stream = p.get_engine().get_service_stream();
-        cldnn::mem_lock<char> lock{mem, stream};
-        auto buf = lock.data();
-        auto bufSize = constLayout.bytes_count();
-
-        std::memcpy(&buf[0], &data[0], bufSize);
-        p.add_primitive(*op, cldnn::data(initialconstPrimID, mem));
-        p.blobMemCache[cache_key] = initialconstPrimID;
-        constPrimID = initialconstPrimID;
+    } else {
+        // To avoid zero byte memory allocation issue, reinterpret one dimension memory to zero dimension memory.
+        auto one_dim_layout = cldnn::layout(ov::PartialShape({1}), constLayout.data_type, constLayout.format);
+        auto one_dim_mem = p.get_engine().allocate_memory(one_dim_layout, false);
+        mem = p.get_engine().reinterpret_buffer(*one_dim_mem, constLayout);
     }
+
+    GPU_DEBUG_LOG << "[" << initialconstPrimID << ": constant] layout: "
+                    << constLayout.to_short_string() << ", mem_ptr(" << mem << ", " << mem->size() << " bytes)"<< std::endl;
+    auto& stream = p.get_engine().get_service_stream();
+    cldnn::mem_lock<char> lock{mem, stream};
+    auto buf = lock.data();
+    auto bufSize = constLayout.bytes_count();
+
+    std::memcpy(&buf[0], &data[0], bufSize);
+    p.add_primitive(*op, cldnn::data(initialconstPrimID, mem));
+    constPrimID = initialconstPrimID;
 }
 
 static bool is_btiwise(Node* node) {

src/plugins/intel_gpu/src/plugin/transformations_pipeline.cpp

@@ -109,6 +109,7 @@
 #include "transformations/common_optimizations/transpose_sinking.hpp"
 #include "transformations/common_optimizations/weights_dequantize_to_fake_quantize.hpp"
 #include "transformations/common_optimizations/wrap_interpolate_into_transposes.hpp"
+#include "transformations/common_optimizations/constants_reduce.hpp"
 #include "transformations/control_flow/unroll_tensor_iterator.hpp"
 #include "transformations/convert_pooling_to_reduce.hpp"
 #include "transformations/convert_precision.hpp"
@@ -1227,6 +1228,8 @@ void TransformationsPipeline::apply(std::shared_ptr<ov::Model> func) {
         // Remove Pad in front of MaxPool if both the pads_begin and pads_end are zero.
         manager.register_pass<ov::pass::EliminatePad>();
 
+        manager.register_pass<ov::pass::ConstantsReduce>();
+
         // This is supposed to be the last pass to ensure that we don't have name collisions until
         // GPU plugin stops using friendly names for program creation
         manager.register_pass<ov::pass::ResolveNameCollisions>(true);