diff --git a/src/plugins/intel_gpu/include/intel_gpu/graph/kernel_impl_params.hpp b/src/plugins/intel_gpu/include/intel_gpu/graph/kernel_impl_params.hpp
index 75ecf821b5e..01acdac9168 100644
--- a/src/plugins/intel_gpu/include/intel_gpu/graph/kernel_impl_params.hpp
+++ b/src/plugins/intel_gpu/include/intel_gpu/graph/kernel_impl_params.hpp
@@ -142,8 +142,6 @@ struct kernel_impl_params {
 
     virtual primitive_type_id type() const { return desc->type; }
 
-    void save(BinaryOutputBuffer& ob) const;
-    void load(BinaryInputBuffer& ib);
     const program& get_program() const {
         OPENVINO_ASSERT(prog != nullptr, "[GPU] Program pointer in kernel_impl_params is not initialized");
         return *prog;
diff --git a/src/plugins/intel_gpu/include/intel_gpu/graph/network.hpp b/src/plugins/intel_gpu/include/intel_gpu/graph/network.hpp
index 79891ec13f5..595fc3ff533 100644
--- a/src/plugins/intel_gpu/include/intel_gpu/graph/network.hpp
+++ b/src/plugins/intel_gpu/include/intel_gpu/graph/network.hpp
@@ -84,13 +84,8 @@ public:
 
     network(program::ptr program, stream::ptr stream, uint16_t stream_id);
 
-    network(cldnn::BinaryInputBuffer& ifs, stream::ptr stream, engine& engine, bool is_primary_stream, uint32_t local_net_id);
-    network(cldnn::BinaryInputBuffer& ifs, const ExecutionConfig& config, stream::ptr stream, engine& engine, bool is_primary_stream, uint32_t local_net_id);
-
     ~network();
 
-    void save(cldnn::BinaryOutputBuffer& ob);
-
     static ptr build_network(engine& engine,
                              const topology& topology,
                              const ExecutionConfig& config = {},
diff --git a/src/plugins/intel_gpu/include/intel_gpu/graph/program.hpp b/src/plugins/intel_gpu/include/intel_gpu/graph/program.hpp
index 671add01303..d4b30edbfd9 100644
--- a/src/plugins/intel_gpu/include/intel_gpu/graph/program.hpp
+++ b/src/plugins/intel_gpu/include/intel_gpu/graph/program.hpp
@@ -98,6 +98,9 @@ public:
             _processing_order.erase(i);
         }
 
+        void save(cldnn::BinaryOutputBuffer& ob) const;
+        void load(cldnn::BinaryInputBuffer& ib, program& p);
+
     private:
         list_of_nodes _processing_order;
         std::map<program_node*, node_iterator> processing_order_iterators;
@@ -282,6 +285,9 @@ public:
     static std::shared_ptr<ov::threading::IStreamsExecutor> make_task_executor(const ExecutionConfig& config);
     static std::shared_ptr<ICompilationContext> make_compilation_context(const ExecutionConfig& config);
 
+    void save(cldnn::BinaryOutputBuffer& ob) const;
+    void load(cldnn::BinaryInputBuffer& ib);
+
 private:
     uint32_t prog_id = 0;
     engine& _engine;
diff --git a/src/plugins/intel_gpu/include/intel_gpu/graph/serialization/binary_buffer.hpp b/src/plugins/intel_gpu/include/intel_gpu/graph/serialization/binary_buffer.hpp
index 05972d7a972..0608511014a 100644
--- a/src/plugins/intel_gpu/include/intel_gpu/graph/serialization/binary_buffer.hpp
+++ b/src/plugins/intel_gpu/include/intel_gpu/graph/serialization/binary_buffer.hpp
@@ -18,7 +18,7 @@ struct memory;
 class BinaryOutputBuffer : public OutputBuffer<BinaryOutputBuffer> {
 public:
     BinaryOutputBuffer(std::ostream& stream)
-    : OutputBuffer<BinaryOutputBuffer>(this), stream(stream), _impl_params(nullptr) {}
+    : OutputBuffer<BinaryOutputBuffer>(this), stream(stream), _impl_params(nullptr), _strm(nullptr) {}
 
     void write(void const * data, std::streamsize size) {
         auto const written_size = stream.rdbuf()->sputn(reinterpret_cast<const char*>(data), size);
@@ -28,16 +28,19 @@ public:
 
     void setKernelImplParams(void* impl_params) { _impl_params = impl_params; }
     void* getKernelImplParams() const { return _impl_params; }
+    void set_stream(void* strm) { _strm = strm; }
+    void* get_stream() const { return _strm; }
 
 private:
     std::ostream& stream;
     void* _impl_params;
+    void* _strm;
 };
 
 class BinaryInputBuffer : public InputBuffer<BinaryInputBuffer> {
 public:
     BinaryInputBuffer(std::istream& stream, engine& engine)
-    : InputBuffer(this, engine), _stream(stream), _impl_params(nullptr) {}
+    : InputBuffer<BinaryInputBuffer>(this, engine), _stream(stream), _impl_params(nullptr) {}
 
     void read(void* const data, std::streamsize size) {
         auto const read_size = _stream.rdbuf()->sgetn(reinterpret_cast<char*>(data), size);
@@ -47,17 +50,6 @@ public:
 
     void setKernelImplParams(void* impl_params) { _impl_params = impl_params; }
     void* getKernelImplParams() const { return _impl_params; }
-    void addConstData(const uint32_t net_id, const std::string& prim_id, const std::shared_ptr<memory> mem_ptr) {
-        while (_const_data_map.size() <= net_id) {
-            _const_data_map.emplace_back(std::unordered_map<std::string, std::shared_ptr<memory>>());
-        }
-        OPENVINO_ASSERT(_const_data_map[net_id].find(prim_id) == _const_data_map[net_id].end(), "[GPU] duplicated primitive id " + prim_id);
-        _const_data_map[net_id][prim_id] = mem_ptr;
-    }
-    std::shared_ptr<memory> getConstData(const uint32_t net_id, const std::string& prim_id) {
-        OPENVINO_ASSERT(_const_data_map[net_id].find(prim_id) != _const_data_map[net_id].end(), "[GPU] Not found primitive id " + prim_id);
-        return _const_data_map[net_id][prim_id];
-    }
 
     std::streampos tellg() { return _stream.tellg(); }
     void seekg(std::streampos pos) { _stream.seekg(pos); }
@@ -65,7 +57,6 @@ public:
 private:
     std::istream& _stream;
     void* _impl_params;
-    std::vector<std::unordered_map<std::string, std::shared_ptr<memory>>> _const_data_map;
 };
 
 template <typename T>
diff --git a/src/plugins/intel_gpu/include/intel_gpu/graph/serialization/layout_serializer.hpp b/src/plugins/intel_gpu/include/intel_gpu/graph/serialization/layout_serializer.hpp
index 77e0754d300..96479b7826c 100644
--- a/src/plugins/intel_gpu/include/intel_gpu/graph/serialization/layout_serializer.hpp
+++ b/src/plugins/intel_gpu/include/intel_gpu/graph/serialization/layout_serializer.hpp
@@ -44,9 +44,7 @@ public:
     static void save(BufferType& buffer, const cldnn::layout& _layout) {
         buffer << make_data(&_layout.data_type, sizeof(cldnn::data_types));
         buffer << make_data(&_layout.format, sizeof(cldnn::format));
-        buffer << _layout.data_padding.filling_value();
-        buffer << _layout.data_padding.lower_size().sizes();
-        buffer << _layout.data_padding.upper_size().sizes();
+        buffer << _layout.data_padding;
         buffer << _layout.get_partial_shape();
     }
 };
@@ -57,16 +55,7 @@ public:
     static void load(BufferType& buffer, cldnn::layout& _layout) {
         buffer >> make_data(&_layout.data_type, sizeof(cldnn::data_types));
         buffer >> make_data(&_layout.format, sizeof(cldnn::format));
-
-        {
-            float _filling_value;
-            buffer >> _filling_value;
-            std::vector<cldnn::tensor::value_type> _lower_size;
-            buffer >> _lower_size;
-            std::vector<cldnn::tensor::value_type> _upper_size;
-            buffer >> _upper_size;
-            _layout.data_padding = cldnn::padding(_lower_size, _upper_size, _filling_value);
-        }
+        buffer >> _layout.data_padding;
 
         ov::PartialShape partial_shape;
         buffer >> partial_shape;
diff --git a/src/plugins/intel_gpu/include/intel_gpu/graph/serialization/vector_serializer.hpp b/src/plugins/intel_gpu/include/intel_gpu/graph/serialization/vector_serializer.hpp
index e4abe0b47b4..cb3560ff589 100644
--- a/src/plugins/intel_gpu/include/intel_gpu/graph/serialization/vector_serializer.hpp
+++ b/src/plugins/intel_gpu/include/intel_gpu/graph/serialization/vector_serializer.hpp
@@ -37,6 +37,32 @@ public:
     }
 };
 
+template <typename BufferType>
+class Serializer<BufferType, std::vector<bool>, typename std::enable_if<std::is_base_of<OutputBuffer<BufferType>, BufferType>::value>::type> {
+public:
+    static void save(BufferType& buffer, const std::vector<bool>& vector) {
+        buffer << vector.size();
+        for (const bool el : vector) {
+            buffer << el;
+        }
+    }
+};
+
+template <typename BufferType>
+class Serializer<BufferType, std::vector<bool>, typename std::enable_if<std::is_base_of<InputBuffer<BufferType>, BufferType>::value>::type> {
+public:
+    static void load(BufferType& buffer, std::vector<bool>& vector) {
+        typename std::vector<bool>::size_type vector_size = 0UL;
+        buffer >> vector_size;
+        bool el;
+        vector.clear();
+        for (size_t i = 0; i < vector_size; ++i) {
+            buffer >> el;
+            vector.push_back(el);
+        }
+    }
+};
+
 template <typename BufferType, typename T>
 class Serializer<BufferType, std::vector<T>, typename std::enable_if<std::is_base_of<OutputBuffer<BufferType>, BufferType>::value &&
                                                                     !std::is_arithmetic<T>::value>::type> {
diff --git a/src/plugins/intel_gpu/include/intel_gpu/plugin/compiled_model.hpp b/src/plugins/intel_gpu/include/intel_gpu/plugin/compiled_model.hpp
index 2c9eec02acc..3f89ced4147 100644
--- a/src/plugins/intel_gpu/include/intel_gpu/plugin/compiled_model.hpp
+++ b/src/plugins/intel_gpu/include/intel_gpu/plugin/compiled_model.hpp
@@ -28,7 +28,7 @@ public:
                   const std::shared_ptr<const ov::IPlugin>& plugin,
                   RemoteContextImpl::Ptr context,
                   const ExecutionConfig& config);
-    CompiledModel(cldnn::BinaryInputBuffer ib,
+    CompiledModel(cldnn::BinaryInputBuffer& ib,
                   const std::shared_ptr<const ov::IPlugin>& plugin,
                   RemoteContextImpl::Ptr context,
                   const ExecutionConfig& config);
@@ -58,7 +58,6 @@ private:
     RemoteContextImpl::Ptr m_context;
     ExecutionConfig m_config;
     std::shared_ptr<ov::threading::ITaskExecutor> m_wait_executor;
-    std::shared_ptr<ov::Model> m_model;
     std::string m_model_name;
     std::vector<ov::Output<const ov::Node>> m_inputs;
     std::vector<ov::Output<const ov::Node>> m_outputs;
diff --git a/src/plugins/intel_gpu/include/intel_gpu/primitives/arg_max_min.hpp b/src/plugins/intel_gpu/include/intel_gpu/primitives/arg_max_min.hpp
index 418f8df90db..2354a58ef01 100644
--- a/src/plugins/intel_gpu/include/intel_gpu/primitives/arg_max_min.hpp
+++ b/src/plugins/intel_gpu/include/intel_gpu/primitives/arg_max_min.hpp
@@ -121,8 +121,6 @@ struct arg_max_min : public primitive_base<arg_max_min> {
 
     void save(BinaryOutputBuffer& ob) const override {
         primitive_base<arg_max_min>::save(ob);
-        ob << input;
-        ob << num_outputs;
         ob << make_data(&mode, sizeof(ov::op::TopKMode));
         ob << top_k;
         ob << axis;
@@ -133,8 +131,6 @@ struct arg_max_min : public primitive_base<arg_max_min> {
 
     void load(BinaryInputBuffer& ib) override {
         primitive_base<arg_max_min>::load(ib);
-        ib >> input;
-        ib >> num_outputs;
         ib >> make_data(&mode, sizeof(ov::op::TopKMode));
         ib >> top_k;
         ib >> axis;
diff --git a/src/plugins/intel_gpu/include/intel_gpu/primitives/condition.hpp b/src/plugins/intel_gpu/include/intel_gpu/primitives/condition.hpp
index 4301f7cc10d..3886bf31856 100644
--- a/src/plugins/intel_gpu/include/intel_gpu/primitives/condition.hpp
+++ b/src/plugins/intel_gpu/include/intel_gpu/primitives/condition.hpp
@@ -17,6 +17,8 @@ namespace cldnn {
 struct condition : public primitive_base<condition> {
     CLDNN_DECLARE_PRIMITIVE(condition)
 
+    condition() : primitive_base("", {}) {}
+
     /// @brief branch has compiled program, input_map and output_map
     ///
     struct branch {
@@ -39,6 +41,43 @@ struct condition : public primitive_base<condition> {
             ss << "]}";
             return ss.str();
         }
+
+        void save(BinaryOutputBuffer& ob) const {
+            ob << input_map.size();
+            for (auto& input_pair : input_map) {
+                ob << input_pair.first;
+                ob << input_pair.second;
+            }
+            ob << output_map.size();
+            for (auto& output_pair : output_map) {
+                ob << output_pair.first;
+                ob << output_pair.second;
+            }
+            inner_program->save(ob);
+        }
+
+        void load(BinaryInputBuffer& ib) {
+            size_t map_size;
+            ib >> map_size;
+            input_map.clear();
+            for (size_t i = 0; i < map_size; ++i) {
+                primitive_id input_first, input_second;
+                ib >> input_first;
+                ib >> input_second;
+                input_map.insert({input_first, input_second});
+            }
+            ib >> map_size;
+            output_map.clear();
+            for (size_t i = 0; i < map_size; ++i) {
+                size_t output_index;
+                primitive_id output_second;
+                ib >> output_index;
+                ib >> output_second;
+                output_map.insert({output_index, output_second});
+            }
+            inner_program = std::make_shared<cldnn::program>(ib.get_engine());
+            inner_program->load(ib);
+        }
     };
 
     /// @brief Constructs condition primitive / layer.
@@ -62,6 +101,18 @@ struct condition : public primitive_base<condition> {
     branch branch_true;
     branch branch_false;
 
+    void save(BinaryOutputBuffer& ob) const override {
+        primitive_base<condition>::save(ob);
+        ob << branch_true;
+        ob << branch_false;
+    }
+
+    void load(BinaryInputBuffer& ib) override {
+        primitive_base<condition>::load(ib);
+        ib >> branch_true;
+        ib >> branch_false;
+    }
+
 protected:
     std::vector<std::reference_wrapper<const primitive_id>> get_dependencies() const override { return {}; }
 };
diff --git a/src/plugins/intel_gpu/include/intel_gpu/primitives/data.hpp b/src/plugins/intel_gpu/include/intel_gpu/primitives/data.hpp
index 177fbf99b70..764d3dc319f 100644
--- a/src/plugins/intel_gpu/include/intel_gpu/primitives/data.hpp
+++ b/src/plugins/intel_gpu/include/intel_gpu/primitives/data.hpp
@@ -5,6 +5,7 @@
 #pragma once
 #include "primitive.hpp"
 #include "intel_gpu/runtime/memory.hpp"
+#include "intel_gpu/runtime/engine.hpp"
 
 namespace cldnn {
 
@@ -33,5 +34,53 @@ struct data : public primitive_base<data> {
         seed = hash_combine(seed, id);
         return seed;
     }
+
+    void save(BinaryOutputBuffer& ob) const override {
+        primitive_base<data>::save(ob);
+
+        ob << mem->get_layout();
+
+        const auto _allocation_type = mem->get_allocation_type();
+        ob << make_data(&_allocation_type, sizeof(_allocation_type));
+
+        size_t data_size = mem->size();
+        ob << make_data(&data_size, sizeof(size_t));
+
+        if (_allocation_type == allocation_type::usm_host || _allocation_type == allocation_type::usm_shared) {
+            ob << make_data(mem->buffer_ptr(), data_size);
+        } else {
+            std::vector<uint8_t> _buf;
+            _buf.resize(data_size);
+            stream* strm = reinterpret_cast<stream*>(ob.get_stream());
+            mem->copy_to(*strm, _buf.data());
+            ob << make_data(_buf.data(), data_size);
+        }
+    }
+
+    void load(BinaryInputBuffer& ib) override {
+        primitive_base<data>::load(ib);
+
+        layout output_layout = layout();
+        ib >> output_layout;
+
+        allocation_type _allocation_type = allocation_type::unknown;
+        ib >> make_data(&_allocation_type, sizeof(_allocation_type));
+
+        size_t data_size = 0;
+        ib >> make_data(&data_size, sizeof(size_t));
+
+        mem = ib.get_engine().allocate_memory(output_layout, _allocation_type, false);
+
+        if (_allocation_type == allocation_type::usm_host || _allocation_type == allocation_type::usm_shared) {
+            ib >> make_data(mem->buffer_ptr(), data_size);
+        } else {
+            std::vector<uint8_t> _buf;
+            _buf.resize(data_size);
+            ib >> make_data(_buf.data(), data_size);
+            // stream* strm = reinterpret_cast<stream*>(ib.get_stream());
+            auto& strm = ib.get_engine().get_service_stream();
+            mem->copy_from(strm, _buf.data());
+        }
+    }
 };
 }  // namespace cldnn
diff --git a/src/plugins/intel_gpu/include/intel_gpu/primitives/loop.hpp b/src/plugins/intel_gpu/include/intel_gpu/primitives/loop.hpp
index e41577bbe80..0ea990b61b5 100644
--- a/src/plugins/intel_gpu/include/intel_gpu/primitives/loop.hpp
+++ b/src/plugins/intel_gpu/include/intel_gpu/primitives/loop.hpp
@@ -246,6 +246,7 @@ struct loop : public primitive_base<loop> {
 
     void save(BinaryOutputBuffer& ob) const override {
         primitive_base<loop>::save(ob);
+        body_program->save(ob);
         ob << trip_count_id;
         ob << first_execution_condition_id;
         ob << num_iteration_id;
@@ -259,6 +260,8 @@ struct loop : public primitive_base<loop> {
 
     void load(BinaryInputBuffer& ib) override {
         primitive_base<loop>::load(ib);
+        body_program = std::make_shared<cldnn::program>(ib.get_engine());
+        body_program->load(ib);
         ib >> trip_count_id;
         ib >> first_execution_condition_id;
         ib >> num_iteration_id;
diff --git a/src/plugins/intel_gpu/include/intel_gpu/primitives/lstm.hpp b/src/plugins/intel_gpu/include/intel_gpu/primitives/lstm.hpp
index 71922acd217..ae979d17fb3 100644
--- a/src/plugins/intel_gpu/include/intel_gpu/primitives/lstm.hpp
+++ b/src/plugins/intel_gpu/include/intel_gpu/primitives/lstm.hpp
@@ -282,6 +282,7 @@ struct lstm_gemm : public primitive_base<lstm_gemm> {
     }
 
     void save(BinaryOutputBuffer& ob) const override {
+        primitive_base<lstm_gemm>::save(ob);
         ob << weights;
         ob << recurrent;
         ob << bias;
@@ -290,6 +291,7 @@ struct lstm_gemm : public primitive_base<lstm_gemm> {
     }
 
     void load(BinaryInputBuffer& ib) override {
+        primitive_base<lstm_gemm>::load(ib);
         ib >> weights;
         ib >> recurrent;
         ib >> bias;
@@ -401,6 +403,7 @@ struct lstm_elt : public primitive_base<lstm_elt> {
     }
 
     void save(BinaryOutputBuffer& ob) const override {
+        primitive_base<lstm_elt>::save(ob);
         ob << cell;
         ob << clip;
         ob << input_forget;
@@ -411,6 +414,7 @@ struct lstm_elt : public primitive_base<lstm_elt> {
     }
 
     void load(BinaryInputBuffer& ib) override {
+        primitive_base<lstm_elt>::load(ib);
         ib >> cell;
         ib >> clip;
         ib >> input_forget;
diff --git a/src/plugins/intel_gpu/include/intel_gpu/primitives/mutable_data.hpp b/src/plugins/intel_gpu/include/intel_gpu/primitives/mutable_data.hpp
index 105711b58dd..3d0443ec005 100644
--- a/src/plugins/intel_gpu/include/intel_gpu/primitives/mutable_data.hpp
+++ b/src/plugins/intel_gpu/include/intel_gpu/primitives/mutable_data.hpp
@@ -5,6 +5,7 @@
 #pragma once
 #include "primitive.hpp"
 #include "intel_gpu/runtime/memory.hpp"
+#include "intel_gpu/runtime/engine.hpp"
 #include <vector>
 
 namespace cldnn {
@@ -59,11 +60,51 @@ struct mutable_data : public primitive_base<mutable_data> {
     void save(BinaryOutputBuffer& ob) const override {
         primitive_base<mutable_data>::save(ob);
         ob << make_data(&fill_type, sizeof(filler_type));
+
+        ob << mem->get_layout();
+
+        const auto _allocation_type = mem->get_allocation_type();
+        ob << make_data(&_allocation_type, sizeof(_allocation_type));
+
+        size_t data_size = mem->size();
+        ob << make_data(&data_size, sizeof(size_t));
+
+        if (_allocation_type == allocation_type::usm_host || _allocation_type == allocation_type::usm_shared) {
+            ob << make_data(mem->buffer_ptr(), data_size);
+        } else {
+            std::vector<uint8_t> _buf;
+            _buf.resize(data_size);
+            stream* strm = reinterpret_cast<stream*>(ob.get_stream());
+            mem->copy_to(*strm, _buf.data());
+            ob << make_data(_buf.data(), data_size);
+        }
     }
 
     void load(BinaryInputBuffer& ib) override {
         primitive_base<mutable_data>::load(ib);
         ib >> make_data(&fill_type, sizeof(filler_type));
+
+        layout output_layout = layout();
+        ib >> output_layout;
+
+        allocation_type _allocation_type = allocation_type::unknown;
+        ib >> make_data(&_allocation_type, sizeof(_allocation_type));
+
+        size_t data_size = 0;
+        ib >> make_data(&data_size, sizeof(size_t));
+
+        mem = ib.get_engine().allocate_memory(output_layout, _allocation_type, false);
+
+        if (_allocation_type == allocation_type::usm_host || _allocation_type == allocation_type::usm_shared) {
+            ib >> make_data(mem->buffer_ptr(), data_size);
+        } else {
+            std::vector<uint8_t> _buf;
+            _buf.resize(data_size);
+            ib >> make_data(_buf.data(), data_size);
+            // stream* strm = reinterpret_cast<stream*>(ib.get_stream());
+            auto& strm = ib.get_engine().get_service_stream();
+            mem->copy_from(strm, _buf.data());
+        }
     }
 };
 }  // namespace cldnn
diff --git a/src/plugins/intel_gpu/include/intel_gpu/primitives/primitive.hpp b/src/plugins/intel_gpu/include/intel_gpu/primitives/primitive.hpp
index bb97725eeac..360258c13d9 100644
--- a/src/plugins/intel_gpu/include/intel_gpu/primitives/primitive.hpp
+++ b/src/plugins/intel_gpu/include/intel_gpu/primitives/primitive.hpp
@@ -98,12 +98,17 @@ struct prim_map_storage {
         return map.at(type_string);
     }
 
+    const cldnn::primitive_id get_type_string(const cldnn::primitive_type_id type_id) const {
+        return inverse_map.at(type_id);
+    }
+
     bool set_type_id(const std::string& type_string, const cldnn::primitive_type_id type_id) {
-        return map.insert({type_string, type_id}).second;
+        return map.insert({type_string, type_id}).second && inverse_map.insert({type_id, type_string}).second;
     }
 
 private:
     std::unordered_map<std::string, cldnn::primitive_type_id> map;
+    std::unordered_map<cldnn::primitive_type_id, std::string> inverse_map;
 };
 
 /// @brief Base class of network primitive description.
@@ -249,6 +254,7 @@ public:
         ib >> output_paddings;
         size_t output_data_types_size;
         ib >> output_data_types_size;
+        output_data_types.clear();
         for (size_t i = 0; i < output_data_types_size; i++) {
             bool has_value;
             ib >> has_value;
diff --git a/src/plugins/intel_gpu/include/intel_gpu/primitives/reorder.hpp b/src/plugins/intel_gpu/include/intel_gpu/primitives/reorder.hpp
index b9c86b7391a..a5185330ad4 100644
--- a/src/plugins/intel_gpu/include/intel_gpu/primitives/reorder.hpp
+++ b/src/plugins/intel_gpu/include/intel_gpu/primitives/reorder.hpp
@@ -20,6 +20,8 @@ enum class reorder_mean_mode {
 };
 
 struct WeightsReorderParams {
+    WeightsReorderParams() {}
+
     WeightsReorderParams(const layout& in_layout, const layout& out_layout, bool transposed = false, bool grouped = false)
         : _in_layout(in_layout),
           _out_layout(out_layout),
@@ -51,6 +53,19 @@ struct WeightsReorderParams {
     void set_input_layout(const layout& layout) { _in_layout = layout; }
     void set_output_layout(const layout& layout) { _out_layout = layout; }
 
+    void save(cldnn::BinaryOutputBuffer& ob) const {
+        ob << _in_layout;
+        ob << _out_layout;
+        ob << _transposed;
+        ob << _grouped;
+    }
+    void load(cldnn::BinaryInputBuffer& ib) {
+        ib >> _in_layout;
+        ib >> _out_layout;
+        ib >> _transposed;
+        ib >> _grouped;
+    }
+
 protected:
     layout _in_layout;
     layout _out_layout;
@@ -257,6 +272,12 @@ struct reorder : public primitive_base<reorder> {
         ob << subtract_per_feature;
         ob << make_data(&mean_mode, sizeof(reorder_mean_mode));
         ob << make_data(&input_mem_type, sizeof(memory_type));
+        if (weights_reorder_params == nullptr) {
+            ob << false;
+        } else {
+            ob << true;
+            weights_reorder_params->save(ob);
+        }
         ob << truncate;
     }
 
@@ -267,6 +288,12 @@ struct reorder : public primitive_base<reorder> {
         ib >> subtract_per_feature;
         ib >> make_data(&mean_mode, sizeof(reorder_mean_mode));
         ib >> make_data(&input_mem_type, sizeof(memory_type));
+        bool has_weights_reorder_params;
+        ib >> has_weights_reorder_params;
+        if (has_weights_reorder_params) {
+            weights_reorder_params = std::make_shared<WeightsReorderParams>();
+            weights_reorder_params->load(ib);
+        }
         ib >> truncate;
     }
 
diff --git a/src/plugins/intel_gpu/src/graph/assign.cpp b/src/plugins/intel_gpu/src/graph/assign.cpp
index 692b6e80339..6bf55efc1fa 100644
--- a/src/plugins/intel_gpu/src/graph/assign.cpp
+++ b/src/plugins/intel_gpu/src/graph/assign.cpp
@@ -30,20 +30,6 @@ std::string assign_inst::to_string(const assign_node& node) {
     return primitive_description.str();
 }
 
-void assign_inst::save(cldnn::BinaryOutputBuffer& ob) const {
-    parent::save(ob);
-
-    ob << variable_id();
-}
-
-void assign_inst::load(cldnn::BinaryInputBuffer& ib) {
-    parent::load(ib);
-
-    std::string variable_id;
-    ib >> variable_id;
-    set_variable_id(variable_id);
-}
-
 void assign_inst::on_execute() {
     _outputs[0] = input_memory_ptr(0);
 }
diff --git a/src/plugins/intel_gpu/src/graph/convolution.cpp b/src/plugins/intel_gpu/src/graph/convolution.cpp
index 1590e68fefe..2886284da5b 100644
--- a/src/plugins/intel_gpu/src/graph/convolution.cpp
+++ b/src/plugins/intel_gpu/src/graph/convolution.cpp
@@ -266,16 +266,4 @@ convolution_inst::typed_primitive_inst(network& network, convolution_node const&
                             input_layout.feature(),
                             "Weights/ifm mismatch");
 }
-
-void convolution_inst::save(cldnn::BinaryOutputBuffer& ob) const {
-    parent::save(ob);
-
-    ob << _deform_conv_dep_offset;
-}
-
-void convolution_inst::load(cldnn::BinaryInputBuffer& ib) {
-    parent::load(ib);
-
-    ib >> _deform_conv_dep_offset;
-}
 }  // namespace cldnn
diff --git a/src/plugins/intel_gpu/src/graph/data.cpp b/src/plugins/intel_gpu/src/graph/data.cpp
index 00cd00bf90a..2cd7d87038f 100644
--- a/src/plugins/intel_gpu/src/graph/data.cpp
+++ b/src/plugins/intel_gpu/src/graph/data.cpp
@@ -51,60 +51,4 @@ std::string data_inst::to_string(data_node const& node) {
 data_inst::typed_primitive_inst(network& network, data_node const& node)
     : parent(network, node, attach_or_copy_data(network, node.get_attached_memory_ptr())) {}
 
-// Cache blob format:
-//     [ kernel_impl_params ]
-//     [ output memory information ]
-//     [ data stored in memory ]
-void data_inst::save(cldnn::BinaryOutputBuffer& ob) const {
-    parent::save(ob);
-    ob << _outputs[0]->get_layout();
-
-    const auto _allocation_type = _outputs[0]->get_allocation_type();
-    ob << make_data(&_allocation_type, sizeof(_allocation_type));
-
-    size_t data_size = _outputs[0]->size();
-    ob << make_data(&data_size, sizeof(size_t));
-
-    if (_allocation_type == allocation_type::usm_host || _allocation_type == allocation_type::usm_shared) {
-        ob << make_data(_outputs[0]->buffer_ptr(), data_size);
-    } else {
-        std::vector<uint8_t> _buf;
-        _buf.resize(data_size);
-        _outputs[0]->copy_to(get_network().get_stream(), _buf.data());
-        ob << make_data(_buf.data(), data_size);
-    }
-}
-
-void data_inst::load(BinaryInputBuffer& ib) {
-    parent::load(ib);
-    layout output_layout = layout();
-    ib >> output_layout;
-
-    allocation_type _allocation_type = allocation_type::unknown;
-    ib >> make_data(&_allocation_type, sizeof(_allocation_type));
-
-    size_t data_size = 0;
-    ib >> make_data(&data_size, sizeof(size_t));
-
-    if (!get_network().is_primary_stream()) {
-        _outputs[0] = ib.getConstData(_network.get_local_id(), id());
-        auto pos = ib.tellg();
-        pos += data_size;
-        ib.seekg(pos);
-    } else {
-        _outputs[0] = get_network().get_engine().allocate_memory(output_layout, _allocation_type, false);
-
-        if (_allocation_type == allocation_type::usm_host || _allocation_type == allocation_type::usm_shared) {
-            ib >> make_data(_outputs[0]->buffer_ptr(), data_size);
-        } else {
-            std::vector<uint8_t> _buf;
-            _buf.resize(data_size);
-            ib >> make_data(_buf.data(), data_size);
-            _outputs[0]->copy_from(get_network().get_stream(), _buf.data());
-        }
-
-        ib.addConstData(_network.get_local_id(), id(), _outputs[0]);
-    }
-}
-
 }  // namespace cldnn
diff --git a/src/plugins/intel_gpu/src/graph/detection_output.cpp b/src/plugins/intel_gpu/src/graph/detection_output.cpp
index 3dbcef84438..2cbf731ae9d 100644
--- a/src/plugins/intel_gpu/src/graph/detection_output.cpp
+++ b/src/plugins/intel_gpu/src/graph/detection_output.cpp
@@ -234,88 +234,4 @@ detection_output_inst::typed_primitive_inst(network& network, detection_output_n
                      node.get_dependency(2).is_padded(),
                      "Detection output layer doesn't support input padding in Prior-Box input");
 }
-
-void detection_output_inst::save(cldnn::BinaryOutputBuffer& ob) const {
-    parent::save(ob);
-
-    // argument (struct detection_output)
-    ob << argument->id;
-    ob << argument->input;
-    ob << make_data(&argument->output_paddings[0], sizeof(argument->output_paddings[0]));
-    ob << argument->num_classes;
-    ob << argument->keep_top_k;
-    ob << argument->share_location;
-    ob << argument->background_label_id;
-    ob << argument->nms_threshold;
-    ob << argument->top_k;
-    ob << argument->eta;
-    ob << make_data(&argument->code_type, sizeof(argument->code_type));
-    ob << argument->variance_encoded_in_target;
-    ob << argument->confidence_threshold;
-    ob << argument->prior_info_size;
-    ob << argument->prior_coordinates_offset;
-    ob << argument->prior_is_normalized;
-    ob << argument->input_width;
-    ob << argument->input_height;
-    ob << argument->decrease_label_id;
-    ob << argument->clip_before_nms;
-    ob << argument->clip_after_nms;
-    ob << argument->objectness_score;
-}
-
-void detection_output_inst::load(cldnn::BinaryInputBuffer& ib) {
-    parent::load(ib);
-
-    primitive_id id;
-    std::vector<input_info> input;
-    uint32_t num_classes;
-    uint32_t keep_top_k;
-    bool share_location;
-    int background_label_id;
-    float nms_threshold;
-    int top_k;
-    float eta;
-    prior_box_code_type code_type = prior_box_code_type::corner;
-    bool variance_encoded_in_target;
-    float confidence_threshold;
-    int32_t prior_info_size;
-    int32_t prior_coordinates_offset;
-    bool prior_is_normalized;
-    int32_t input_width;
-    int32_t input_height;
-    bool decrease_label_id;
-    bool clip_before_nms;
-    bool clip_after_nms;
-    float objectness_score;
-    padding output_padding;
-
-    ib >> id;
-    ib >> input;
-    ib >> make_data(&output_padding, sizeof(output_padding));
-    ib >> num_classes;
-    ib >> keep_top_k;
-    ib >> share_location;
-    ib >> background_label_id;
-    ib >> nms_threshold;
-    ib >> top_k;
-    ib >> eta;
-    ib >> make_data(&code_type, sizeof(code_type));
-    ib >> variance_encoded_in_target;
-    ib >> confidence_threshold;
-    ib >> prior_info_size;
-    ib >> prior_coordinates_offset;
-    ib >> prior_is_normalized;
-    ib >> input_width;
-    ib >> input_height;
-    ib >> decrease_label_id;
-    ib >> clip_before_nms;
-    ib >> clip_after_nms;
-    ib >> objectness_score;
-
-    argument = std::make_shared<detection_output>(
-        id, input, num_classes, keep_top_k, share_location, background_label_id, nms_threshold, top_k,
-        eta, code_type, variance_encoded_in_target, confidence_threshold, prior_info_size,
-        prior_coordinates_offset, prior_is_normalized, input_width, input_height, decrease_label_id,
-        clip_before_nms, clip_after_nms, objectness_score, output_padding);
-}
 }  // namespace cldnn
diff --git a/src/plugins/intel_gpu/src/graph/impls/common/condition.cpp b/src/plugins/intel_gpu/src/graph/impls/common/condition.cpp
index ffc607c4370..14a904c6297 100644
--- a/src/plugins/intel_gpu/src/graph/impls/common/condition.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/common/condition.cpp
@@ -13,12 +13,17 @@ namespace cldnn {
 namespace common {
 
 struct condition_impl : typed_primitive_impl<condition> {
+    using parent = typed_primitive_impl<condition>;
+    using parent::parent;
+
     DECLARE_OBJECT_TYPE_SERIALIZATION(cldnn::common::condition_impl)
 
     std::unique_ptr<primitive_impl> clone() const override {
         return make_unique<condition_impl>(*this);
     }
 
+    condition_impl() : parent() {}
+
     explicit condition_impl(const condition_node& outer) {
         set_node_params(outer);
     }
@@ -131,6 +136,16 @@ struct condition_impl : typed_primitive_impl<condition> {
 
     void init_kernels(const kernels_cache& , const kernel_impl_params&) override {}
 
+    void save(BinaryOutputBuffer& ob) const override {
+        parent::save(ob);
+        ob << _node_id;
+    }
+
+    void load(BinaryInputBuffer& ib) override {
+        parent::load(ib);
+        ib >> _node_id;
+    }
+
 private:
     primitive_id _node_id;
 };
@@ -150,5 +165,5 @@ attach_condition_common::attach_condition_common() {
 }  // namespace common
 }  // namespace cldnn
 
-// TODO: Change code like cldnn::loop
-ASSIGN_TYPE_NAME(cldnn::common::condition_impl)
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::common::condition_impl)
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::condition)
diff --git a/src/plugins/intel_gpu/src/graph/impls/cpu/activation.cpp b/src/plugins/intel_gpu/src/graph/impls/cpu/activation.cpp
index 7f1e7abcb9b..69224ffddf9 100644
--- a/src/plugins/intel_gpu/src/graph/impls/cpu/activation.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/cpu/activation.cpp
@@ -79,11 +79,13 @@ struct activation_impl : public typed_primitive_impl<activation> {
     }
 
     void save(BinaryOutputBuffer& ob) const override {
+        parent::save(ob);
         ob << make_data(&activation_function, sizeof(activation_func));
         ob << make_data(&additional_params, sizeof(activation_additional_params));
     }
 
     void load(BinaryInputBuffer& ib) override {
+        parent::load(ib);
         ib >> make_data(&activation_function, sizeof(activation_func));
         ib >> make_data(&additional_params, sizeof(activation_additional_params));
     }
diff --git a/src/plugins/intel_gpu/src/graph/impls/cpu/assign.cpp b/src/plugins/intel_gpu/src/graph/impls/cpu/assign.cpp
index 9d1ef36a003..7d11374f178 100644
--- a/src/plugins/intel_gpu/src/graph/impls/cpu/assign.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/cpu/assign.cpp
@@ -35,10 +35,12 @@ struct assign_impl : public typed_primitive_impl<assign> {
     }
 
     void save(BinaryOutputBuffer& ob) const override {
+        parent::save(ob);
         ob << variable_id;
     }
 
     void load(BinaryInputBuffer& ib) override {
+        parent::load(ib);
         ib >> variable_id;
     }
 
diff --git a/src/plugins/intel_gpu/src/graph/impls/cpu/broadcast.cpp b/src/plugins/intel_gpu/src/graph/impls/cpu/broadcast.cpp
index fe8c30f3cd5..b3fda1193d7 100644
--- a/src/plugins/intel_gpu/src/graph/impls/cpu/broadcast.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/cpu/broadcast.cpp
@@ -45,12 +45,14 @@ struct broadcast_impl : public typed_primitive_impl<broadcast> {
     }
 
     void save(BinaryOutputBuffer& ob) const override {
+        parent::save(ob);
         ob << make_data(&broadcast_mode, sizeof(ov::op::BroadcastModeSpec));
         ob << make_data(&target_shape, sizeof(ov::Shape));
         ob << axes_mapping;
     }
 
     void load(BinaryInputBuffer& ib) override {
+        parent::load(ib);
         ib >> make_data(&broadcast_mode, sizeof(ov::op::BroadcastModeSpec));
         ib >> make_data(&target_shape, sizeof(ov::Shape));
         ib >> axes_mapping;
diff --git a/src/plugins/intel_gpu/src/graph/impls/cpu/concat.cpp b/src/plugins/intel_gpu/src/graph/impls/cpu/concat.cpp
index 0d2e68c7b94..6bdde7bff2f 100644
--- a/src/plugins/intel_gpu/src/graph/impls/cpu/concat.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/cpu/concat.cpp
@@ -40,10 +40,12 @@ struct concatenation_impl : public typed_primitive_impl<concatenation> {
     }
 
     void save(BinaryOutputBuffer& ob) const override {
+        parent::save(ob);
         ob << axis;
     }
 
     void load(BinaryInputBuffer& ib) override {
+        parent::load(ib);
         ib >> axis;
     }
 
diff --git a/src/plugins/intel_gpu/src/graph/impls/cpu/detection_output.cpp b/src/plugins/intel_gpu/src/graph/impls/cpu/detection_output.cpp
index f15d143e285..083d1774614 100644
--- a/src/plugins/intel_gpu/src/graph/impls/cpu/detection_output.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/cpu/detection_output.cpp
@@ -62,10 +62,12 @@ public:
     }
 
     void save(BinaryOutputBuffer& ob) const override {
+        parent::save(ob);
         ob << make_data(&nms_type, sizeof(NMSType));
     }
 
     void load(BinaryInputBuffer& ib) override {
+        parent::load(ib);
         ib >> make_data(&nms_type, sizeof(NMSType));
     }
 
diff --git a/src/plugins/intel_gpu/src/graph/impls/cpu/eltwise.cpp b/src/plugins/intel_gpu/src/graph/impls/cpu/eltwise.cpp
index ef336d81e6b..b261404b75e 100644
--- a/src/plugins/intel_gpu/src/graph/impls/cpu/eltwise.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/cpu/eltwise.cpp
@@ -64,11 +64,13 @@ struct eltwise_impl : public typed_primitive_impl<eltwise> {
     }
 
     void save(BinaryOutputBuffer& ob) const override {
+        parent::save(ob);
         ob << make_data(&mode, sizeof(eltwise_mode));
         ob << coefficients;
     }
 
     void load(BinaryInputBuffer& ib) override {
+        parent::load(ib);
         ib >> make_data(&mode, sizeof(eltwise_mode));
         ib >> coefficients;
     }
diff --git a/src/plugins/intel_gpu/src/graph/impls/cpu/gather.cpp b/src/plugins/intel_gpu/src/graph/impls/cpu/gather.cpp
index 8daef9d220b..a7437af3022 100644
--- a/src/plugins/intel_gpu/src/graph/impls/cpu/gather.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/cpu/gather.cpp
@@ -42,11 +42,13 @@ struct gather_impl : public typed_primitive_impl<gather> {
     }
 
     void save(BinaryOutputBuffer& ob) const override {
+        parent::save(ob);
         ob << axis;
         ob << batch_dims;
     }
 
     void load(BinaryInputBuffer& ib) override {
+        parent::load(ib);
         ib >> axis;
         ib >> batch_dims;
     }
diff --git a/src/plugins/intel_gpu/src/graph/impls/cpu/read_value.cpp b/src/plugins/intel_gpu/src/graph/impls/cpu/read_value.cpp
index c11522c0c8d..20a8a4afa0e 100644
--- a/src/plugins/intel_gpu/src/graph/impls/cpu/read_value.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/cpu/read_value.cpp
@@ -35,10 +35,12 @@ struct read_value_impl : public typed_primitive_impl<read_value> {
     }
 
     void save(BinaryOutputBuffer& ob) const override {
+        parent::save(ob);
         ob << variable_id;
     }
 
     void load(BinaryInputBuffer& ib) override {
+        parent::load(ib);
         ib >> variable_id;
     }
 
diff --git a/src/plugins/intel_gpu/src/graph/impls/cpu/scatter_update.cpp b/src/plugins/intel_gpu/src/graph/impls/cpu/scatter_update.cpp
index e30c172402d..0719c03a2be 100644
--- a/src/plugins/intel_gpu/src/graph/impls/cpu/scatter_update.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/cpu/scatter_update.cpp
@@ -40,10 +40,12 @@ struct scatter_update_impl : public typed_primitive_impl<scatter_update> {
     }
 
     void save(BinaryOutputBuffer& ob) const override {
+        parent::save(ob);
         ob << axis;
     }
 
     void load(BinaryInputBuffer& ib) override {
+        parent::load(ib);
         ib >> axis;
     }
 
diff --git a/src/plugins/intel_gpu/src/graph/impls/cpu/strided_slice.cpp b/src/plugins/intel_gpu/src/graph/impls/cpu/strided_slice.cpp
index 50babdecc99..1103cb10dc7 100644
--- a/src/plugins/intel_gpu/src/graph/impls/cpu/strided_slice.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/cpu/strided_slice.cpp
@@ -56,6 +56,7 @@ struct strided_slice_impl : public typed_primitive_impl<strided_slice> {
     }
 
     void save(BinaryOutputBuffer& ob) const override {
+        parent::save(ob);
         ob << begin_data;
         ob << end_data;
         ob << strides_data;
@@ -68,6 +69,7 @@ struct strided_slice_impl : public typed_primitive_impl<strided_slice> {
     }
 
     void load(BinaryInputBuffer& ib) override {
+        parent::load(ib);
         ib >> begin_data;
         ib >> end_data;
         ib >> strides_data;
diff --git a/src/plugins/intel_gpu/src/graph/impls/cpu/tile.cpp b/src/plugins/intel_gpu/src/graph/impls/cpu/tile.cpp
index bfc982aaa63..17adf746a35 100644
--- a/src/plugins/intel_gpu/src/graph/impls/cpu/tile.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/cpu/tile.cpp
@@ -39,10 +39,12 @@ struct tile_impl : public typed_primitive_impl<tile> {
     }
 
     void save(BinaryOutputBuffer& ob) const override {
+        parent::save(ob);
         ob << repeats;
     }
 
     void load(BinaryInputBuffer& ib) override {
+        parent::load(ib);
         ib >> repeats;
     }
 
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/activation.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/activation.cpp
index cd56a28b5c7..93d1768cf14 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/activation.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/activation.cpp
@@ -31,6 +31,15 @@ struct activation_impl : typed_primitive_impl_ocl<activation> {
         return make_unique<activation_impl>(*this);
     }
 
+    void load(BinaryInputBuffer& ib) override {
+        parent::load(ib);
+        if (is_dynamic()) {
+            auto& kernel_selector = kernel_selector_t::Instance();
+            auto kernel_impl = kernel_selector.GetImplementation(_kernel_data.kernelName);
+            kernel_impl->GetUpdateDispatchDataFunc(_kernel_data);
+        }
+    }
+
     kernel_arguments_data get_arguments(const typed_primitive_inst<activation>& instance) const override {
         kernel_arguments_data args = parent::get_arguments(instance);
 
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/arg_max_min.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/arg_max_min.cpp
index 1816aa8f9ec..ca832edbefc 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/arg_max_min.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/arg_max_min.cpp
@@ -45,6 +45,15 @@ struct arg_max_min_impl : typed_primitive_impl_ocl<arg_max_min> {
         return make_unique<arg_max_min_impl>(*this);
     }
 
+    void load(BinaryInputBuffer& ib) override {
+        parent::load(ib);
+        if (is_dynamic()) {
+            auto& kernel_selector = kernel_selector_t::Instance();
+            auto kernel_impl = kernel_selector.GetImplementation(_kernel_data.kernelName);
+            kernel_impl->GetUpdateDispatchDataFunc(_kernel_data);
+        }
+    }
+
 protected:
     kernel_arguments_data get_arguments(const typed_primitive_inst<arg_max_min>& instance) const override {
         kernel_arguments_data args = parent::get_arguments(instance);
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/border.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/border.cpp
index c3d84f6269f..94c6aa9eabf 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/border.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/border.cpp
@@ -110,7 +110,30 @@ struct border_impl : typed_primitive_impl_ocl<border> {
         (_kernel_data.update_dispatch_data_func)(kernel_params.first, _kernel_data);
     }
 
+    void save(BinaryOutputBuffer& ob) const override {
+        parent::save(ob);
+        const auto& prim_params = static_cast<const kernel_selector::border_params&>(*_kernel_data.params);
+        if (prim_params.inputs[0].LogicalSize() == 0) {
+            ob << true;
+        } else {
+            ob << false;
+        }
+    }
+
+    void load(BinaryInputBuffer& ib) override {
+        parent::load(ib);
+        ib >> zero_input;
+        if (is_dynamic()) {
+            auto& kernel_selector = kernel_selector_t::Instance();
+            auto kernel_impl = kernel_selector.GetImplementation(_kernel_data.kernelName);
+            kernel_impl->GetUpdateDispatchDataFunc(_kernel_data);
+        }
+    }
+
 protected:
+    // WA for static impl deserialization
+    bool zero_input = false;
+
     kernel_arguments_data get_arguments(const typed_primitive_inst<border>& instance) const override {
         kernel_arguments_data args = parent::get_arguments(instance);
 
@@ -127,7 +150,8 @@ protected:
         const auto& prim_params = static_cast<const kernel_selector::border_params&>(*_kernel_data.params);
         std::vector<layout> layouts;
 
-        if (prim_params.inputs[0].LogicalSize() == 0) {
+        if ((_kernel_data.params == nullptr && zero_input) ||
+            (_kernel_data.params != nullptr && prim_params.inputs[0].LogicalSize() == 0)) {
             layout any_layout = {data_types::u8, format::bfyx, {1, 1, 1, 1}};
             layouts.push_back(any_layout);
         }
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/broadcast.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/broadcast.cpp
index 03dc67176fd..2ec9330db33 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/broadcast.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/broadcast.cpp
@@ -23,6 +23,15 @@ struct broadcast_impl : typed_primitive_impl_ocl<broadcast> {
         return make_unique<broadcast_impl>(*this);
     }
 
+    void load(BinaryInputBuffer& ib) override {
+        parent::load(ib);
+        if (is_dynamic()) {
+            auto& kernel_selector = kernel_selector_t::Instance();
+            auto kernel_impl = kernel_selector.GetImplementation(_kernel_data.kernelName);
+            kernel_impl->GetUpdateDispatchDataFunc(_kernel_data);
+        }
+    }
+
     static kernel_params_t get_kernel_params(const kernel_impl_params& impl_param, bool is_shape_agnostic = false) {
         const auto& primitive = impl_param.typed_desc<broadcast>();
         auto params = get_default_params<kernel_selector::broadcast_params>(impl_param, is_shape_agnostic);
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/concatenation.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/concatenation.cpp
index 539c6b83040..7031db449a6 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/concatenation.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/concatenation.cpp
@@ -53,6 +53,15 @@ struct concatenation_impl : typed_primitive_impl_ocl<concatenation> {
         return make_unique<concatenation_impl>(*this);
     }
 
+    void load(BinaryInputBuffer& ib) override {
+        parent::load(ib);
+        if (is_dynamic()) {
+            auto& kernel_selector = kernel_selector_t::Instance();
+            auto kernel_impl = kernel_selector.GetImplementation(_kernel_data.kernelName);
+            kernel_impl->GetUpdateDispatchDataFunc(_kernel_data);
+        }
+    }
+
 public:
     static kernel_params_t get_kernel_params(const kernel_impl_params& impl_param, bool is_shape_agnostic = false) {
         const auto& primitive = impl_param.typed_desc<concatenation>();
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/convolution.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/convolution.cpp
index 5ca29b7a4f9..51adecf9464 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/convolution.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/convolution.cpp
@@ -3,7 +3,7 @@
 //
 
 #include "primitive_base.hpp"
-
+#include "kernel_base.h"
 #include "convolution_inst.h"
 #include "convolution/convolution_kernel_selector.h"
 #include "convolution/convolution_params.h"
@@ -25,6 +25,15 @@ struct convolution_impl : typed_primitive_impl_ocl<convolution> {
         return make_unique<convolution_impl>(*this);
     }
 
+    void load(BinaryInputBuffer& ib) override {
+        parent::load(ib);
+        if (is_dynamic()) {
+            auto& kernel_selector = kernel_selector_t::Instance();
+            auto kernel_impl = kernel_selector.GetImplementation(_kernel_data.kernelName);
+            kernel_impl->GetUpdateDispatchDataFunc(_kernel_data);
+        }
+    }
+
 protected:
     kernel_arguments_data get_arguments(const typed_primitive_inst<convolution>& instance) const override {
         kernel_arguments_data args = parent::get_arguments(instance);
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/crop.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/crop.cpp
index 7e71b214e61..8bb10e1da6e 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/crop.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/crop.cpp
@@ -23,6 +23,15 @@ struct crop_impl : typed_primitive_impl_ocl<crop> {
         return make_unique<crop_impl>(*this);
     }
 
+    void load(BinaryInputBuffer& ib) override {
+        parent::load(ib);
+        if (is_dynamic()) {
+            auto& kernel_selector = kernel_selector_t::Instance();
+            auto kernel_impl = kernel_selector.GetImplementation(_kernel_data.kernelName);
+            kernel_impl->GetUpdateDispatchDataFunc(_kernel_data);
+        }
+    }
+
 public:
     static kernel_params_t get_kernel_params(const kernel_impl_params& impl_param, bool is_shape_agnostic = false) {
         auto params = get_default_params<kernel_selector::eltwise_params>(impl_param, is_shape_agnostic);
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/cum_sum.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/cum_sum.cpp
index b17b52cba18..1afaead914a 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/cum_sum.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/cum_sum.cpp
@@ -56,6 +56,15 @@ struct cum_sum_impl : typed_primitive_impl_ocl<cum_sum> {
         return make_unique<cum_sum_impl>(*this);
     }
 
+    void load(BinaryInputBuffer& ib) override {
+        parent::load(ib);
+        if (is_dynamic()) {
+            auto& kernel_selector = kernel_selector_t::Instance();
+            auto kernel_impl = kernel_selector.GetImplementation(_kernel_data.kernelName);
+            kernel_impl->GetUpdateDispatchDataFunc(_kernel_data);
+        }
+    }
+
 public:
     static kernel_params_t get_kernel_params(const kernel_impl_params& impl_param, bool is_shape_agnostic = false) {
         const auto& primitive = impl_param.typed_desc<cum_sum>();
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/custom_primitive.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/custom_primitive.cpp
index 5b0cc7e5b6f..6a3f0a00a29 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/custom_primitive.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/custom_primitive.cpp
@@ -28,7 +28,6 @@ struct custom_gpu_primitive_impl : typed_primitive_impl<custom_gpu_primitive> {
 
     std::shared_ptr<kernel_selector::cl_kernel_data> cl_kernel;
     std::vector<kernel::ptr> _kernels;
-    std::string _cached_kernel_id;
 
     std::unique_ptr<primitive_impl> clone() const override {
         return make_unique<custom_gpu_primitive_impl>(*this);
@@ -39,8 +38,7 @@ struct custom_gpu_primitive_impl : typed_primitive_impl<custom_gpu_primitive> {
 
     custom_gpu_primitive_impl(const custom_gpu_primitive_impl& other)
     : cl_kernel(other.cl_kernel)
-    , _kernels({})
-    , _cached_kernel_id(other._cached_kernel_id) {
+    , _kernels({}) {
         for (const auto& kernel : other._kernels) {
             _kernels.emplace_back(kernel->clone());
         }
@@ -49,8 +47,7 @@ struct custom_gpu_primitive_impl : typed_primitive_impl<custom_gpu_primitive> {
     custom_gpu_primitive_impl(const custom_gpu_primitive_node& arg,
                              std::shared_ptr<kernel_selector::cl_kernel_data>& cl_kernel)
         : cl_kernel(cl_kernel)
-        , _kernels()
-        , _cached_kernel_id() { }
+        , _kernels() { }
 
     std::vector<std::shared_ptr<cldnn::kernel_string>> get_kernels_source() override {
         std::vector<std::shared_ptr<cldnn::kernel_string>> kernel_strings;
@@ -64,12 +61,12 @@ struct custom_gpu_primitive_impl : typed_primitive_impl<custom_gpu_primitive> {
         _kernels.insert(_kernels.begin(), compiled_kernels.begin(), compiled_kernels.end());
     }
 
-    void init_by_cached_kernels(const kernels_cache& kernels_cache) override {
-        _kernels.emplace_back(kernels_cache.get_kernel_from_cached_kernels(_cached_kernel_id));
+    void init_by_cached_kernels(const kernels_cache& kernels_cache, std::vector<std::string>& cached_kernel_ids) override {
+        _kernels.emplace_back(kernels_cache.get_kernel_from_cached_kernels(cached_kernel_ids[0]));
     }
 
-    void set_cached_kernel_ids(const kernels_cache& kernels_cache) override {
-        _cached_kernel_id = kernels_cache.get_cached_kernel_id(_kernels[0]);
+    std::vector<std::string> get_cached_kernel_ids(const kernels_cache& kernels_cache) override {
+        return {kernels_cache.get_cached_kernel_id(_kernels[0])};
     }
 
     void set_arguments_impl(custom_gpu_primitive_inst& instance) override {
@@ -93,19 +90,23 @@ struct custom_gpu_primitive_impl : typed_primitive_impl<custom_gpu_primitive> {
         return stream.enqueue_kernel(*_kernels.front(), cl_kernel.get()->params, args, events, instance.is_output());
     }
 
+    std::vector<kernel::ptr> get_kernels() override {
+        return _kernels;
+    }
+
     std::vector<kernel::ptr> get_kernels() const override {
         return _kernels;
     }
 
     void save(BinaryOutputBuffer& ob) const override {
+        parent::save(ob);
         ob << *cl_kernel;
-        ob << _cached_kernel_id;
     }
 
     void load(BinaryInputBuffer& ib) override {
+        parent::load(ib);
         cl_kernel = std::make_shared<kernel_selector::cl_kernel_data>();
         ib >> *cl_kernel;
-        ib >> _cached_kernel_id;
     }
 };
 
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/eltwise.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/eltwise.cpp
index 08ebd9351ec..b254a3bac97 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/eltwise.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/eltwise.cpp
@@ -23,6 +23,15 @@ struct eltwise_impl : typed_primitive_impl_ocl<eltwise> {
         return make_unique<eltwise_impl>(*this);
     }
 
+    void load(BinaryInputBuffer& ib) override {
+        parent::load(ib);
+        if (is_dynamic()) {
+            auto& kernel_selector = kernel_selector_t::Instance();
+            auto kernel_impl = kernel_selector.GetImplementation(_kernel_data.kernelName);
+            kernel_impl->GetUpdateDispatchDataFunc(_kernel_data);
+        }
+    }
+
 protected:
     kernel_arguments_data get_arguments(const typed_primitive_inst<eltwise>& instance) const override {
         kernel_arguments_data args = parent::get_arguments(instance);
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/fully_connected.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/fully_connected.cpp
index e3ac31cccc7..fde99f2c07b 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/fully_connected.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/fully_connected.cpp
@@ -3,7 +3,7 @@
 //
 
 #include "primitive_base.hpp"
-
+#include "kernel_base.h"
 #include "fully_connected_inst.h"
 #include "fully_connected/fully_connected_kernel_selector.h"
 #include "fully_connected/fully_connected_params.h"
@@ -48,6 +48,15 @@ struct fully_connected_impl : typed_primitive_impl_ocl<fully_connected> {
         return make_unique<fully_connected_impl>(*this);
     }
 
+    void load(BinaryInputBuffer& ib) override {
+        parent::load(ib);
+        if (is_dynamic()) {
+            auto& kernel_selector = kernel_selector_t::Instance();
+            auto kernel_impl = kernel_selector.GetImplementation(_kernel_data.kernelName);
+            kernel_impl->GetUpdateDispatchDataFunc(_kernel_data);
+        }
+    }
+
 protected:
     kernel_arguments_data get_arguments(const typed_primitive_inst<fully_connected>& instance) const override {
         kernel_arguments_data args = parent::get_arguments(instance);
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/gather.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/gather.cpp
index e1631161420..0be99f35f48 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/gather.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/gather.cpp
@@ -67,6 +67,15 @@ struct gather_impl : typed_primitive_impl_ocl<gather> {
         return make_unique<gather_impl>(*this);
     }
 
+    void load(BinaryInputBuffer& ib) override {
+        parent::load(ib);
+        if (is_dynamic()) {
+            auto& kernel_selector = kernel_selector_t::Instance();
+            auto kernel_impl = kernel_selector.GetImplementation(_kernel_data.kernelName);
+            kernel_impl->GetUpdateDispatchDataFunc(_kernel_data);
+        }
+    }
+
 public:
     static kernel_params_t get_kernel_params(const kernel_impl_params& impl_param, bool is_shape_agnostic = false) {
         const auto& primitive = impl_param.typed_desc<gather>();
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/gather_elements.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/gather_elements.cpp
index 94a528bb49f..ccefe90da1d 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/gather_elements.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/gather_elements.cpp
@@ -54,6 +54,15 @@ struct gather_elements_impl : typed_primitive_impl_ocl<gather_elements> {
         return make_unique<gather_elements_impl>(*this);
     }
 
+    void load(BinaryInputBuffer& ib) override {
+        parent::load(ib);
+        if (is_dynamic()) {
+            auto& kernel_selector = kernel_selector_t::Instance();
+            auto kernel_impl = kernel_selector.GetImplementation(_kernel_data.kernelName);
+            kernel_impl->GetUpdateDispatchDataFunc(_kernel_data);
+        }
+    }
+
     static kernel_params_t get_kernel_params(const kernel_impl_params& impl_param, bool is_shape_agnostic = false) {
         const auto& primitive = impl_param.typed_desc<gather_elements>();
         auto params = get_default_params<kernel_selector::gather_elements_params>(impl_param, is_shape_agnostic);
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/gather_nd.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/gather_nd.cpp
index c3461c3c226..a226c099e27 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/gather_nd.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/gather_nd.cpp
@@ -23,6 +23,15 @@ struct gather_nd_impl : typed_primitive_impl_ocl<gather_nd> {
         return make_unique<gather_nd_impl>(*this);
     }
 
+    void load(BinaryInputBuffer& ib) override {
+        parent::load(ib);
+        if (is_dynamic()) {
+            auto& kernel_selector = kernel_selector_t::Instance();
+            auto kernel_impl = kernel_selector.GetImplementation(_kernel_data.kernelName);
+            kernel_impl->GetUpdateDispatchDataFunc(_kernel_data);
+        }
+    }
+
     static kernel_params_t get_kernel_params(const kernel_impl_params& impl_param) {
         const auto& primitive = impl_param.typed_desc<gather_nd>();
         auto params = get_default_params<kernel_selector::gather_nd_params>(impl_param);
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/gemm.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/gemm.cpp
index 1b61437cb12..9989316c7f3 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/gemm.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/gemm.cpp
@@ -23,6 +23,15 @@ struct gemm_impl : typed_primitive_impl_ocl<gemm> {
         return make_unique<gemm_impl>(*this);
     }
 
+    void load(BinaryInputBuffer& ib) override {
+        parent::load(ib);
+        if (is_dynamic()) {
+            auto& kernel_selector = kernel_selector_t::Instance();
+            auto kernel_impl = kernel_selector.GetImplementation(_kernel_data.kernelName);
+            kernel_impl->GetUpdateDispatchDataFunc(_kernel_data);
+        }
+    }
+
 public:
     static kernel_params_t get_kernel_params(const kernel_impl_params& impl_param, bool is_shape_agnostic = false) {
         const auto& primitive = impl_param.typed_desc<gemm>();
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/mvn.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/mvn.cpp
index 48e2b68e911..7cd0f250f74 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/mvn.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/mvn.cpp
@@ -23,6 +23,15 @@ struct mvn_impl : typed_primitive_impl_ocl<mvn> {
         return make_unique<mvn_impl>(*this);
     }
 
+    void load(BinaryInputBuffer& ib) override {
+        parent::load(ib);
+        if (is_dynamic()) {
+            auto& kernel_selector = kernel_selector_t::Instance();
+            auto kernel_impl = kernel_selector.GetImplementation(_kernel_data.kernelName);
+            kernel_impl->GetUpdateDispatchDataFunc(_kernel_data);
+        }
+    }
+
     static kernel_params_t get_kernel_params(const kernel_impl_params& impl_param, bool is_shape_agnostic = false) {
         const auto& primitive = impl_param.typed_desc<mvn>();
         auto params = get_default_params<kernel_selector::mvn_params>(impl_param, is_shape_agnostic);
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/non_zero.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/non_zero.cpp
index 7adc4bae0f5..7198d0a2302 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/non_zero.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/non_zero.cpp
@@ -25,6 +25,15 @@ struct count_nonzero_impl : typed_primitive_impl_ocl<count_nonzero> {
         return make_unique<count_nonzero_impl>(*this);
     }
 
+    void load(BinaryInputBuffer& ib) override {
+        parent::load(ib);
+        if (is_dynamic()) {
+            auto& kernel_selector = kernel_selector_t::Instance();
+            auto kernel_impl = kernel_selector.GetImplementation(_kernel_data.kernelName);
+            kernel_impl->GetUpdateDispatchDataFunc(_kernel_data);
+        }
+    }
+
     static kernel_params_t get_kernel_params(const kernel_impl_params& impl_param, bool is_shape_agnostic = false) {
         auto params = get_default_params<kernel_selector::count_nonzero_params>(impl_param, is_shape_agnostic);
         auto optional_params = get_default_optional_params<kernel_selector::count_nonzero_optional_params>(impl_param.get_program());
@@ -49,6 +58,15 @@ struct gather_nonzero_impl : typed_primitive_impl_ocl<gather_nonzero> {
         return make_unique<gather_nonzero_impl>(*this);
     }
 
+    void load(BinaryInputBuffer& ib) override {
+        parent::load(ib);
+        if (is_dynamic()) {
+            auto& kernel_selector = kernel_selector_t::Instance();
+            auto kernel_impl = kernel_selector.GetImplementation(_kernel_data.kernelName);
+            kernel_impl->GetUpdateDispatchDataFunc(_kernel_data);
+        }
+    }
+
     static kernel_params_t get_kernel_params(const kernel_impl_params& impl_param, bool is_shape_agnostic = false) {
         auto params = get_default_params<kernel_selector::gather_nonzero_params>(impl_param, is_shape_agnostic);
         auto optional_params = get_default_optional_params<kernel_selector::gather_nonzero_optional_params>(impl_param.get_program());
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/permute.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/permute.cpp
index c18f7f33fa2..71cb534200a 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/permute.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/permute.cpp
@@ -50,6 +50,15 @@ struct permute_impl : typed_primitive_impl_ocl<permute> {
         return make_unique<permute_impl>(*this);
     }
 
+    void load(BinaryInputBuffer& ib) override {
+        parent::load(ib);
+        if (is_dynamic()) {
+            auto& kernel_selector = kernel_selector_t::Instance();
+            auto kernel_impl = kernel_selector.GetImplementation(_kernel_data.kernelName);
+            kernel_impl->GetUpdateDispatchDataFunc(_kernel_data);
+        }
+    }
+
     static kernel_params_t get_kernel_params(const kernel_impl_params& impl_param, bool is_shape_agnostic = false) {
         const auto& primitive = impl_param.typed_desc<permute>();
         auto params = get_default_params<kernel_selector::permute_params>(impl_param, is_shape_agnostic);
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/primitive_base.hpp b/src/plugins/intel_gpu/src/graph/impls/ocl/primitive_base.hpp
index 429aa535121..98d65e63ab9 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/primitive_base.hpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/primitive_base.hpp
@@ -33,18 +33,16 @@ For example, all gpu convolution implementations should derive from typed_primit
 template <class PType>
 struct typed_primitive_impl_ocl : public typed_primitive_impl<PType> {
     kernel_selector::kernel_data _kernel_data;
-    std::vector<std::string> _cached_kernel_ids;
     std::vector<kernel::ptr> _kernels;
 
     // a pair of batch program hash and kernel entry hash of each ocl impl.
     std::pair<std::string, std::string> kernel_dump_info;
 
-    typed_primitive_impl_ocl() : _kernel_data({}), _cached_kernel_ids({}), _kernels({}) {}
+    typed_primitive_impl_ocl() : _kernel_data({}), _kernels({}) {}
 
     typed_primitive_impl_ocl(const typed_primitive_impl_ocl<PType>& other)
     : typed_primitive_impl<PType>(other._weights_reorder_params, other._kernel_name, other._is_dynamic)
     , _kernel_data(other._kernel_data)
-    , _cached_kernel_ids(other._cached_kernel_ids)
     , _kernels({}) {
         _kernels.reserve(other._kernels.size());
         for (size_t k = 0; k < other._kernels.size(); ++k) {
@@ -65,17 +63,19 @@ struct typed_primitive_impl_ocl : public typed_primitive_impl<PType> {
     //     [ kernel_selector::kernel_data ]
     //     [ kernel_ids ]
     void save(BinaryOutputBuffer& ob) const override {
+        primitive_impl::save(ob);
         ob << make_data(&_kernel_data.internalBufferDataType, sizeof(kernel_selector::Datatype));
         ob << _kernel_data.internalBufferSizes;
         ob << _kernel_data.kernels;
-        ob << _cached_kernel_ids;
+        ob << _kernel_data.kernelName;
     }
 
     void load(BinaryInputBuffer& ib) override {
+        primitive_impl::load(ib);
         ib >> make_data(&_kernel_data.internalBufferDataType, sizeof(kernel_selector::Datatype));
         ib >> _kernel_data.internalBufferSizes;
         ib >> _kernel_data.kernels;
-        ib >> _cached_kernel_ids;
+        ib >> _kernel_data.kernelName;
     }
 
     template<typename ImplType>
@@ -144,22 +144,22 @@ protected:
             kernel_dump_info = std::make_pair(std::to_string(kernels_cache.get_kernel_batch_hash(params)),
                                           _kernel_data.kernels[0].code.kernelString->entry_point);
         }
-   }
+    }
 
-    void init_by_cached_kernels(const kernels_cache& kernels_cache) override {
+    void init_by_cached_kernels(const kernels_cache& kernels_cache, std::vector<std::string>& cached_kernel_ids) override {
         if (is_cpu()) {
             return;
         }
         _kernels.clear();
 
-        _kernels.reserve(_cached_kernel_ids.size());
-        for (size_t k = 0; k < _cached_kernel_ids.size(); ++k) {
-            _kernels.emplace_back(kernels_cache.get_kernel_from_cached_kernels(_cached_kernel_ids[k]));
+        _kernels.reserve(cached_kernel_ids.size());
+        for (size_t k = 0; k < cached_kernel_ids.size(); ++k) {
+            _kernels.emplace_back(kernels_cache.get_kernel_from_cached_kernels(cached_kernel_ids[k]));
         }
     }
 
-    void set_cached_kernel_ids(const kernels_cache& kernels_cache) override {
-        _cached_kernel_ids = kernels_cache.get_cached_kernel_ids(_kernels);
+    std::vector<std::string> get_cached_kernel_ids(const kernels_cache& kernels_cache) override {
+        return {kernels_cache.get_cached_kernel_ids(_kernels)};
     }
 
     std::vector<kernel::ptr> get_kernels() const override {
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/quantize.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/quantize.cpp
index 2164c922a2a..7fb7aa08d5d 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/quantize.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/quantize.cpp
@@ -23,6 +23,15 @@ struct quantize_impl : typed_primitive_impl_ocl<quantize> {
         return make_unique<quantize_impl>(*this);
     }
 
+    void load(BinaryInputBuffer& ib) override {
+        parent::load(ib);
+        if (is_dynamic()) {
+            auto& kernel_selector = kernel_selector_t::Instance();
+            auto kernel_impl = kernel_selector.GetImplementation(_kernel_data.kernelName);
+            kernel_impl->GetUpdateDispatchDataFunc(_kernel_data);
+        }
+    }
+
 protected:
     kernel_arguments_data get_arguments(const typed_primitive_inst<quantize>& instance) const override {
         kernel_arguments_data args;
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/range.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/range.cpp
index e1ef0c4d22f..58cedb83db9 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/range.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/range.cpp
@@ -23,6 +23,15 @@ struct range_impl : typed_primitive_impl_ocl<range> {
         return make_unique<range_impl>(*this);
     }
 
+    void load(BinaryInputBuffer& ib) override {
+        parent::load(ib);
+        if (is_dynamic()) {
+            auto& kernel_selector = kernel_selector_t::Instance();
+            auto kernel_impl = kernel_selector.GetImplementation(_kernel_data.kernelName);
+            kernel_impl->GetUpdateDispatchDataFunc(_kernel_data);
+        }
+    }
+
     static kernel_params_t get_kernel_params(const kernel_impl_params& impl_param, bool is_shape_agnostic = false) {
         auto params = get_default_params<kernel_selector::range_params>(impl_param, is_shape_agnostic);
         for (int i : {1, 2})
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/reduce.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/reduce.cpp
index 715d88b26d4..58125a50dd4 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/reduce.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/reduce.cpp
@@ -72,6 +72,13 @@ struct reduce_impl : typed_primitive_impl_ocl<reduce> {
         return make_unique<reduce_impl>(*this);
     }
 
+    void load(BinaryInputBuffer& ib) override {
+        parent::load(ib);
+        auto& kernel_selector = kernel_selector_t::Instance();
+        auto kernel_impl = kernel_selector.GetImplementation(_kernel_data.kernelName);
+        kernel_impl->GetUpdateDispatchDataFunc(_kernel_data);
+    }
+
     static kernel_params_t get_kernel_params(const kernel_impl_params& impl_param, bool is_shape_agnostic = false) {
         const auto& primitive = impl_param.typed_desc<reduce>();
         auto params = get_default_params<kernel_selector::reduce_params>(impl_param, is_shape_agnostic);
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/reorder.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/reorder.cpp
index 976d6e38a58..77cdf621e9f 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/reorder.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/reorder.cpp
@@ -24,6 +24,15 @@ struct reorder_impl : typed_primitive_impl_ocl<reorder> {
         return make_unique<reorder_impl>(*this);
     }
 
+    void load(BinaryInputBuffer& ib) override {
+        parent::load(ib);
+        if (is_dynamic()) {
+            auto& kernel_selector = kernel_selector_t::Instance();
+            auto kernel_impl = kernel_selector.GetImplementation(_kernel_data.kernelName);
+            kernel_impl->GetUpdateDispatchDataFunc(_kernel_data);
+        }
+    }
+
 protected:
     kernel_arguments_data get_arguments(const reorder_inst& instance) const override {
         kernel_arguments_data args = parent::get_arguments(instance);
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/rms.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/rms.cpp
index 71f44e68515..0d193ecb88b 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/rms.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/rms.cpp
@@ -23,6 +23,15 @@ struct rms_impl : typed_primitive_impl_ocl<rms> {
         return make_unique<rms_impl>(*this);
     }
 
+    void load(BinaryInputBuffer& ib) override {
+        parent::load(ib);
+        if (is_dynamic()) {
+            auto& kernel_selector = kernel_selector_t::Instance();
+            auto kernel_impl = kernel_selector.GetImplementation(_kernel_data.kernelName);
+            kernel_impl->GetUpdateDispatchDataFunc(_kernel_data);
+        }
+    }
+
     static kernel_params_t get_kernel_params(const kernel_impl_params& impl_param, bool is_shape_agnostic = false) {
         const auto& primitive = impl_param.typed_desc<rms>();
         auto params = get_default_params<kernel_selector::rms_params>(impl_param, is_shape_agnostic);
@@ -63,3 +72,6 @@ attach_rms_impl::attach_rms_impl() {
 }  // namespace detail
 }  // namespace ocl
 }  // namespace cldnn
+
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::rms_impl)
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::rms)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/scatter_nd_update.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/scatter_nd_update.cpp
index 729237f6fa4..4576e763f20 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/scatter_nd_update.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/scatter_nd_update.cpp
@@ -23,6 +23,15 @@ struct scatter_nd_update_impl : typed_primitive_impl_ocl<scatter_nd_update> {
         return make_unique<scatter_nd_update_impl>(*this);
     }
 
+    void load(BinaryInputBuffer& ib) override {
+        parent::load(ib);
+        if (is_dynamic()) {
+            auto& kernel_selector = kernel_selector_t::Instance();
+            auto kernel_impl = kernel_selector.GetImplementation(_kernel_data.kernelName);
+            kernel_impl->GetUpdateDispatchDataFunc(_kernel_data);
+        }
+    }
+
     static kernel_params_t get_kernel_params(const kernel_impl_params& impl_param, bool is_shape_agnostic = false) {
         const auto& primitive = impl_param.typed_desc<scatter_nd_update>();
         auto params = get_default_params<kernel_selector::scatter_nd_update_params>(impl_param, is_shape_agnostic);
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/scatter_update.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/scatter_update.cpp
index aa5d3dbe337..09941c2a673 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/scatter_update.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/scatter_update.cpp
@@ -48,6 +48,15 @@ struct scatter_update_impl : typed_primitive_impl_ocl<scatter_update> {
         return make_unique<scatter_update_impl>(*this);
     }
 
+    void load(BinaryInputBuffer& ib) override {
+        parent::load(ib);
+        if (is_dynamic()) {
+            auto& kernel_selector = kernel_selector_t::Instance();
+            auto kernel_impl = kernel_selector.GetImplementation(_kernel_data.kernelName);
+            kernel_impl->GetUpdateDispatchDataFunc(_kernel_data);
+        }
+    }
+
 public:
     static kernel_params_t get_kernel_params(const kernel_impl_params& impl_param, bool is_shape_agnostic = false) {
         const auto& primitive = impl_param.typed_desc<scatter_update>();
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/select.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/select.cpp
index f4996cba0ea..6c4eba43b56 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/select.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/select.cpp
@@ -23,6 +23,15 @@ struct select_impl : typed_primitive_impl_ocl<select> {
         return make_unique<select_impl>(*this);
     }
 
+    void load(BinaryInputBuffer& ib) override {
+        parent::load(ib);
+        if (is_dynamic()) {
+            auto& kernel_selector = kernel_selector_t::Instance();
+            auto kernel_impl = kernel_selector.GetImplementation(_kernel_data.kernelName);
+            kernel_impl->GetUpdateDispatchDataFunc(_kernel_data);
+        }
+    }
+
     static kernel_params_t get_kernel_params(const kernel_impl_params& impl_param, bool is_shape_agnostic = false) {
         auto params = get_default_params<kernel_selector::select_params>(impl_param, is_shape_agnostic);
         auto optional_params = get_default_optional_params<kernel_selector::select_optional_params>(impl_param.get_program());
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/shape_of.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/shape_of.cpp
index b2efd25f67e..9b436876fcc 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/shape_of.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/shape_of.cpp
@@ -23,6 +23,15 @@ struct shape_of_impl : typed_primitive_impl_ocl<shape_of> {
         return make_unique<shape_of_impl>(*this);
     }
 
+    void load(BinaryInputBuffer& ib) override {
+        parent::load(ib);
+        if (is_dynamic()) {
+            auto& kernel_selector = kernel_selector_t::Instance();
+            auto kernel_impl = kernel_selector.GetImplementation(_kernel_data.kernelName);
+            kernel_impl->GetUpdateDispatchDataFunc(_kernel_data);
+        }
+    }
+
     static kernel_params_t get_kernel_params(const kernel_impl_params& impl_param, bool is_shape_agnostic = false) {
         auto params = get_default_params<kernel_selector::shape_of_params>(impl_param, is_shape_agnostic);
         auto optional_params = get_default_optional_params<kernel_selector::shape_of_optional_params>(impl_param.get_program());
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/softmax.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/softmax.cpp
index 6ad4e1d087c..d4c20e44f7a 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/softmax.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/softmax.cpp
@@ -45,6 +45,15 @@ struct softmax_impl : typed_primitive_impl_ocl<softmax> {
         return make_unique<softmax_impl>(*this);
     }
 
+    void load(BinaryInputBuffer& ib) override {
+        parent::load(ib);
+        if (is_dynamic()) {
+            auto& kernel_selector = kernel_selector_t::Instance();
+            auto kernel_impl = kernel_selector.GetImplementation(_kernel_data.kernelName);
+            kernel_impl->GetUpdateDispatchDataFunc(_kernel_data);
+        }
+    }
+
     static kernel_params_t get_kernel_params(const kernel_impl_params& impl_param, bool is_shape_agnostic = false) {
         const auto& primitive = impl_param.typed_desc<softmax>();
         auto params = get_default_params<kernel_selector::softmax_params>(impl_param, is_shape_agnostic);
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/strided_slice.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/strided_slice.cpp
index ab10c1ff106..df46aa9799f 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/strided_slice.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/strided_slice.cpp
@@ -52,6 +52,15 @@ struct strided_slice_impl : typed_primitive_impl_ocl<strided_slice> {
         return make_unique<strided_slice_impl>(*this);
     }
 
+    void load(BinaryInputBuffer& ib) override {
+        parent::load(ib);
+        if (is_dynamic()) {
+            auto& kernel_selector = kernel_selector_t::Instance();
+            auto kernel_impl = kernel_selector.GetImplementation(_kernel_data.kernelName);
+            kernel_impl->GetUpdateDispatchDataFunc(_kernel_data);
+        }
+    }
+
 public:
     static kernel_params_t get_kernel_params(const kernel_impl_params& impl_param, bool is_shape_agnostic = false) {
         const auto& prim = impl_param.typed_desc<strided_slice>();
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/tile.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/tile.cpp
index bc95a18f545..972a04d5b33 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/tile.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/tile.cpp
@@ -23,6 +23,15 @@ struct tile_impl : typed_primitive_impl_ocl<tile> {
         return make_unique<tile_impl>(*this);
     }
 
+    void load(BinaryInputBuffer& ib) override {
+        parent::load(ib);
+        if (is_dynamic()) {
+            auto& kernel_selector = kernel_selector_t::Instance();
+            auto kernel_impl = kernel_selector.GetImplementation(_kernel_data.kernelName);
+            kernel_impl->GetUpdateDispatchDataFunc(_kernel_data);
+        }
+    }
+
 public:
     static kernel_params_t get_kernel_params(const kernel_impl_params& impl_param, bool is_shape_agnostic = false) {
         const auto& primitive = impl_param.typed_desc<tile>();
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/unique.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/unique.cpp
index 604619c30b2..35cdb2ab007 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/unique.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/unique.cpp
@@ -23,6 +23,15 @@ struct unique_count_impl : typed_primitive_impl_ocl<unique_count> {
         return make_unique<unique_count_impl>(*this);
     }
 
+    void load(BinaryInputBuffer& ib) override {
+        parent::load(ib);
+        if (is_dynamic()) {
+            auto& kernel_selector = kernel_selector_t::Instance();
+            auto kernel_impl = kernel_selector.GetImplementation(_kernel_data.kernelName);
+            kernel_impl->GetUpdateDispatchDataFunc(_kernel_data);
+        }
+    }
+
     static kernel_params_t get_kernel_params(const kernel_impl_params& impl_param, bool is_shape_agnostic = false) {
         const auto& primitive = impl_param.typed_desc<unique_count>();
         auto params = get_default_params<kernel_selector::unique_count_params>(impl_param, is_shape_agnostic);
@@ -94,6 +103,15 @@ struct unique_gather_impl : typed_primitive_impl_ocl<unique_gather> {
         return make_unique<unique_gather_impl>(*this);
     }
 
+    void load(BinaryInputBuffer& ib) override {
+        parent::load(ib);
+        if (is_dynamic()) {
+            auto& kernel_selector = kernel_selector_t::Instance();
+            auto kernel_impl = kernel_selector.GetImplementation(_kernel_data.kernelName);
+            kernel_impl->GetUpdateDispatchDataFunc(_kernel_data);
+        }
+    }
+
     static kernel_params_t get_kernel_params(const kernel_impl_params& impl_param, bool is_shape_agnostic = false) {
         const auto& primitive = impl_param.typed_desc<unique_gather>();
         auto params = get_default_params<kernel_selector::unique_gather_params>(impl_param, is_shape_agnostic);
diff --git a/src/plugins/intel_gpu/src/graph/impls/onednn/primitive_onednn_base.h b/src/plugins/intel_gpu/src/graph/impls/onednn/primitive_onednn_base.h
index 37d4fc5e67d..53657e2ee93 100644
--- a/src/plugins/intel_gpu/src/graph/impls/onednn/primitive_onednn_base.h
+++ b/src/plugins/intel_gpu/src/graph/impls/onednn/primitive_onednn_base.h
@@ -95,12 +95,14 @@ struct typed_primitive_onednn_impl : public typed_primitive_impl<PType> {
     }
 
     bool is_cpu() const override { return false; }
+    bool is_onednn() const { return true; }
 
     // Cache blob format:
     //     [ dnnl::primitive_attr ]
     //     [ dnnl::primitive_desc ]
     //     [ dnnl::cache_blob ]
     void save(BinaryOutputBuffer& ob) const override {
+        primitive_impl::save(ob);
 #ifdef ONEDNN_PRIMITIVE_SERIALIZATION
         if (_attrs->get() == nullptr) {
             ob << false;
@@ -203,6 +205,7 @@ struct typed_primitive_onednn_impl : public typed_primitive_impl<PType> {
     }
 
     void load(BinaryInputBuffer& ib) override {
+        primitive_impl::load(ib);
 #ifdef ONEDNN_PRIMITIVE_SERIALIZATION
         bool has_attrs;
         ib >> has_attrs;
diff --git a/src/plugins/intel_gpu/src/graph/include/assign_inst.h b/src/plugins/intel_gpu/src/graph/include/assign_inst.h
index 62d45473dc5..6e6df50a89f 100644
--- a/src/plugins/intel_gpu/src/graph/include/assign_inst.h
+++ b/src/plugins/intel_gpu/src/graph/include/assign_inst.h
@@ -55,9 +55,6 @@ public:
     typed_primitive_inst(network& network, const assign_node& desc);
     typed_primitive_inst(network& network) : parent(network), memory_state::variable("") {}
 
-    void save(cldnn::BinaryOutputBuffer& ob) const override;
-    void load(cldnn::BinaryInputBuffer& ib) override;
-
     void on_execute() override;
 };
 
diff --git a/src/plugins/intel_gpu/src/graph/include/convolution_inst.h b/src/plugins/intel_gpu/src/graph/include/convolution_inst.h
index 7033df0905a..6d5f33d7ab7 100644
--- a/src/plugins/intel_gpu/src/graph/include/convolution_inst.h
+++ b/src/plugins/intel_gpu/src/graph/include/convolution_inst.h
@@ -189,9 +189,6 @@ public:
     bool compensation_term() const { return _impl_params->compensation_layout.has_value(); }
     bool activations_zero_points_term() const { return _impl_params->activations_zero_points_layout.has_value(); }
 
-    void save(cldnn::BinaryOutputBuffer& ob) const override;
-    void load(cldnn::BinaryInputBuffer& ib) override;
-
 private:
     int32_t _deform_conv_dep_offset = 0;
 };
diff --git a/src/plugins/intel_gpu/src/graph/include/data_inst.h b/src/plugins/intel_gpu/src/graph/include/data_inst.h
index d4742d29bd3..fc52fbac275 100644
--- a/src/plugins/intel_gpu/src/graph/include/data_inst.h
+++ b/src/plugins/intel_gpu/src/graph/include/data_inst.h
@@ -40,8 +40,6 @@ public:
     static std::string to_string(data_node const& node);
 
     typed_primitive_inst(network& network, data_node const& node);
-    void save(BinaryOutputBuffer& ob) const override;
-    void load(BinaryInputBuffer& ib) override;
 };
 
 using data_inst = typed_primitive_inst<data>;
diff --git a/src/plugins/intel_gpu/src/graph/include/detection_output_inst.h b/src/plugins/intel_gpu/src/graph/include/detection_output_inst.h
index 43ebffc8839..33596e2b07d 100644
--- a/src/plugins/intel_gpu/src/graph/include/detection_output_inst.h
+++ b/src/plugins/intel_gpu/src/graph/include/detection_output_inst.h
@@ -46,9 +46,6 @@ public:
     memory::ptr location_memory() const { return dep_memory_ptr(0); }
     memory::ptr confidence_memory() const { return dep_memory_ptr(1); }
     memory::ptr prior_box_memory() const { return dep_memory_ptr(2); }
-
-    void save(cldnn::BinaryOutputBuffer& ob) const override;
-    void load(cldnn::BinaryInputBuffer& ib) override;
 };
 
 using detection_output_inst = typed_primitive_inst<detection_output>;
diff --git a/src/plugins/intel_gpu/src/graph/include/loop_inst.h b/src/plugins/intel_gpu/src/graph/include/loop_inst.h
index 3cc916e0975..7779ffa9d6e 100644
--- a/src/plugins/intel_gpu/src/graph/include/loop_inst.h
+++ b/src/plugins/intel_gpu/src/graph/include/loop_inst.h
@@ -318,8 +318,6 @@ public:
     event::ptr set_output_memory(memory::ptr mem, bool check = true, size_t idx = 0) override;
     void reset_memory();
 
-    void save(BinaryOutputBuffer& ob) const override;
-    void load(BinaryInputBuffer& ib) override;
     void validate_backedges(loop_node const & node) const;
 
     void update_shape() override { primitive_inst::update_shape(); }
diff --git a/src/plugins/intel_gpu/src/graph/include/mutable_data_inst.h b/src/plugins/intel_gpu/src/graph/include/mutable_data_inst.h
index 0dc1993b8e5..236a6442075 100644
--- a/src/plugins/intel_gpu/src/graph/include/mutable_data_inst.h
+++ b/src/plugins/intel_gpu/src/graph/include/mutable_data_inst.h
@@ -20,6 +20,7 @@ struct typed_program_node<mutable_data> : public typed_program_node_base<mutable
     memory& get_attached_memory() const { return *mem; }
     memory::ptr get_attached_memory_ptr() const { return mem; }
     void attach_memory(memory::ptr new_mem, bool invalidate_users_if_changed = true);
+    void replace_memory(memory::ptr new_mem, bool invalidate_users_if_changed = false);
 
     program_node& input(size_t idx = 0) const { return get_dependency(idx); }
 
@@ -44,8 +45,6 @@ public:
     typed_primitive_inst(network& network, mutable_data_node const& node);
     event::ptr set_output_memory(memory::ptr mem, bool check = true, size_t idx = 0) override;
     const std::list<primitive_id>& get_user_ids() const { return _user_ids; }
-    void save(BinaryOutputBuffer& ob) const override;
-    void load(BinaryInputBuffer& ib) override;
 
 private:
     std::list<primitive_id> _user_ids;
diff --git a/src/plugins/intel_gpu/src/graph/include/primitive_inst.h b/src/plugins/intel_gpu/src/graph/include/primitive_inst.h
index e51a06e4338..bd7e57fa75d 100644
--- a/src/plugins/intel_gpu/src/graph/include/primitive_inst.h
+++ b/src/plugins/intel_gpu/src/graph/include/primitive_inst.h
@@ -63,15 +63,36 @@ struct primitive_impl {
 
     // class typed_primitive_gpu_impl override this with return false;
     virtual bool is_cpu() const { return true; }
+    virtual bool is_onednn() const { return false; }
     virtual void init_kernels(const kernels_cache& kernels_cache, const kernel_impl_params& params) = 0;
-    virtual void init_by_cached_kernels(const kernels_cache&) {}
-    virtual void set_cached_kernel_ids(const kernels_cache&) {}
+    virtual void init_by_cached_kernels(const kernels_cache&, std::vector<std::string>& cached_kernel_ids) {}
+    virtual std::vector<std::string> get_cached_kernel_ids(const kernels_cache&) { return {}; }
     virtual std::unique_ptr<primitive_impl> clone() const = 0;
     virtual std::vector<std::shared_ptr<cldnn::kernel_string>> get_kernels_source() { return {}; }
     virtual void reset_kernels_source() {}
     virtual std::vector<kernel::ptr> get_kernels() const { return {}; }
-    virtual void save(cldnn::BinaryOutputBuffer& ob) const {}
-    virtual void load(cldnn::BinaryInputBuffer& ib) {}
+    virtual void save(cldnn::BinaryOutputBuffer& ob) const {
+        ob << can_reuse_memory;
+        ob << _kernel_name;
+        ob << _is_dynamic;
+        if (_weights_reorder_params == nullptr) {
+            ob << false;
+        } else {
+            ob << true;
+            _weights_reorder_params->save(ob);
+        }
+    }
+    virtual void load(cldnn::BinaryInputBuffer& ib) {
+        ib >> can_reuse_memory;
+        ib >> _kernel_name;
+        ib >> _is_dynamic;
+        bool has_weights_reorder_params;
+        ib >> has_weights_reorder_params;
+        if (has_weights_reorder_params) {
+            _weights_reorder_params = std::make_shared<WeightsReorderParams>();
+            _weights_reorder_params->load(ib);
+        }
+    }
     // returns a pair of batch program hash and kernel entry of each ocl impl. Returns "" for other impl types.
     virtual std::pair<std::string, std::string> get_kernels_dump_info() const {
         return std::make_pair("", "");
@@ -195,10 +216,6 @@ public:
         _impl->init_kernels(kernels_cache, *_impl_params);
     }
 
-    void init_by_cached_kernels(const kernels_cache& kernels_cache) {
-        _impl->init_by_cached_kernels(kernels_cache);
-    }
-
     void set_arguments();
 
     void validate() const {
@@ -252,8 +269,6 @@ public:
 
     std::vector<memory::ptr> get_intermediates_memories() const { return _intermediates_memory; }
 
-    virtual void save(cldnn::BinaryOutputBuffer& ob) const;
-    virtual void load(cldnn::BinaryInputBuffer& ib);
     void rebuild_deps(
         std::unordered_map<primitive_id, std::shared_ptr<primitive_inst>> const& primitives);
     void rebuild_exec_deps(
diff --git a/src/plugins/intel_gpu/src/graph/include/program_node.h b/src/plugins/intel_gpu/src/graph/include/program_node.h
index 4443ca0b209..2fd25540080 100644
--- a/src/plugins/intel_gpu/src/graph/include/program_node.h
+++ b/src/plugins/intel_gpu/src/graph/include/program_node.h
@@ -386,6 +386,9 @@ public:
     const std::vector<fused_primitive_desc>& get_fused_primitives() const { return fused_prims; }
     std::vector<fused_primitive_desc>& get_fused_primitives() { return fused_prims; }
 
+    void save(cldnn::BinaryOutputBuffer& ob) const;
+    void load(cldnn::BinaryInputBuffer& ib);
+
 #ifdef ENABLE_ONEDNN_FOR_GPU
     const std::shared_ptr<dnnl::primitive_attr>& get_onednn_primitive_attributes() const {
         if (onednn_attrs == nullptr)
diff --git a/src/plugins/intel_gpu/src/graph/include/proposal_inst.h b/src/plugins/intel_gpu/src/graph/include/proposal_inst.h
index 9c92e253d22..684690ee96f 100644
--- a/src/plugins/intel_gpu/src/graph/include/proposal_inst.h
+++ b/src/plugins/intel_gpu/src/graph/include/proposal_inst.h
@@ -45,14 +45,6 @@ public:
             end_x = e_x;
             end_y = e_y;
         }
-
-        void save(BinaryOutputBuffer& ob) const {
-            ob << start_x << start_y << end_x << end_y;
-        }
-
-        void load(BinaryInputBuffer& ib) {
-            ib >> start_x >> start_y >> end_x >> end_y;
-        }
     };
 
     // indices of the memory objects used by the layer
@@ -81,8 +73,6 @@ public:
     typed_primitive_inst(network& network, proposal_node const& desc);
 
     const std::vector<anchor>& get_anchors() const { return _anchors; }
-    void save(BinaryOutputBuffer& ob) const override;
-    void load(BinaryInputBuffer& ib) override;
 
 private:
     std::vector<anchor> _anchors;
diff --git a/src/plugins/intel_gpu/src/graph/include/read_value_inst.h b/src/plugins/intel_gpu/src/graph/include/read_value_inst.h
index 919624e5db3..a84be19aae2 100644
--- a/src/plugins/intel_gpu/src/graph/include/read_value_inst.h
+++ b/src/plugins/intel_gpu/src/graph/include/read_value_inst.h
@@ -48,9 +48,6 @@ public:
     typed_primitive_inst(network& network, const read_value_node& desc);
     typed_primitive_inst(network& network) : parent(network), memory_state::variable("") {}
 
-    void save(cldnn::BinaryOutputBuffer& ob) const override;
-    void load(cldnn::BinaryInputBuffer& ib) override;
-
     void update_output_memory() override;
 
 protected:
diff --git a/src/plugins/intel_gpu/src/graph/include/reorder_inst.h b/src/plugins/intel_gpu/src/graph/include/reorder_inst.h
index 75020ad070b..af8e7cfe0e7 100644
--- a/src/plugins/intel_gpu/src/graph/include/reorder_inst.h
+++ b/src/plugins/intel_gpu/src/graph/include/reorder_inst.h
@@ -103,9 +103,6 @@ public:
         return req_reinterpr;
     }
 
-    void save(cldnn::BinaryOutputBuffer& ob) const override;
-    void load(cldnn::BinaryInputBuffer& ib) override;
-
 private:
     void on_execute() override;
 
diff --git a/src/plugins/intel_gpu/src/graph/kernel_impl_params.cpp b/src/plugins/intel_gpu/src/graph/kernel_impl_params.cpp
index 2258c970776..8e695780c28 100644
--- a/src/plugins/intel_gpu/src/graph/kernel_impl_params.cpp
+++ b/src/plugins/intel_gpu/src/graph/kernel_impl_params.cpp
@@ -70,146 +70,4 @@ bool kernel_impl_params::operator==(const kernel_impl_params& rhs) const {
     return true;
 }
 
-void kernel_impl_params::save(BinaryOutputBuffer& ob) const {
-    ob << desc;
-    ob << static_cast<uint64_t>(dev_type);
-    ob << has_runtime_layouts;
-    ob << unique_id;
-    ob << input_layouts;
-    ob << output_layouts;
-    ob << input_offsets.size();
-    for (size_t i = 0; i < input_offsets.size(); i++) {
-        ob << input_offsets[i].sizes();
-    }
-
-    if (weights_layout.has_value()) {
-        ob << true;
-        ob << weights_layout.value();
-    } else {
-        ob << false;
-    }
-
-    if (bias_layout.has_value()) {
-        ob << true;
-        ob << bias_layout.value();
-    } else {
-        ob << false;
-    }
-
-    if (weights_zero_points_layout.has_value()) {
-        ob << true;
-        ob << weights_zero_points_layout.value();
-    } else {
-        ob << false;
-    }
-
-    if (activations_zero_points_layout.has_value()) {
-        ob << true;
-        ob << activations_zero_points_layout.value();
-    } else {
-        ob << false;
-    }
-
-    if (compensation_layout.has_value()) {
-        ob << true;
-        ob << compensation_layout.value();
-    } else {
-        ob << false;
-    }
-
-    ob << fused_desc.size();
-#ifdef ENABLE_ONEDNN_FOR_GPU
-    size_t num_fused_prims = fused_desc_onednn.size();
-    ob << num_fused_prims;
-    for (auto fused_prim : fused_desc_onednn) {
-        ob << make_data(&fused_prim.op_type, sizeof(onednn_post_op_type));
-        ob << fused_prim.mem_offset;
-        ob << fused_prim.mem_dep;
-        ob << make_data(&fused_prim.tag, sizeof(dnnl::memory::format_tag));
-        ob << fused_prim.flatten;
-        ob << fused_prim.dims;
-        ob << make_data(&fused_prim.dt, sizeof(dnnl::memory::data_type));
-    }
-#endif // ENABLE_ONEDNN_FOR_GPU
-    ob << primary_input_idx;
-}
-
-void kernel_impl_params::load(BinaryInputBuffer& ib) {
-    prog = nullptr;
-    ib >> desc;
-    size_t dev_type_id = 0;
-    ib >> dev_type_id;
-    dev_type = static_cast<cldnn::device_type>(dev_type_id);
-    ib >> has_runtime_layouts;
-    ib >> unique_id;
-    ib >> input_layouts;
-    ib >> output_layouts;
-    {
-        size_t num_input_offsets;
-        ib >> num_input_offsets;
-        input_offsets.resize(num_input_offsets);
-        for (size_t i = 0; i < num_input_offsets; i++) {
-            std::vector<cldnn::tensor::value_type> sizes;
-            ib >> sizes;
-            input_offsets[i] = cldnn::tensor(sizes);
-        }
-    }
-    bool has_value = false;
-    layout layout_buf;
-
-    ib >> has_value;
-    if (has_value) {
-        ib >> layout_buf;
-        weights_layout = layout_buf;
-    }
-
-    ib >> has_value;
-    if (has_value) {
-        ib >> layout_buf;
-        bias_layout = layout_buf;
-    }
-
-    ib >> has_value;
-    if (has_value) {
-        ib >> layout_buf;
-        weights_zero_points_layout = layout_buf;
-    }
-
-    ib >> has_value;
-    if (has_value) {
-        ib >> layout_buf;
-        activations_zero_points_layout = layout_buf;
-    }
-
-    ib >> has_value;
-    if (has_value) {
-        ib >> layout_buf;
-        compensation_layout = layout_buf;
-    }
-
-    {
-        // Fake fused_desc just for has_fused_primitives()
-        size_t num_fused_desc;
-        ib >> num_fused_desc;
-        if (num_fused_desc > 0) {
-            fused_desc.emplace_back(cldnn::fused_primitive_desc(nullptr));
-        }
-    }
-#ifdef ENABLE_ONEDNN_FOR_GPU
-    size_t num_fused_prims;
-    ib >> num_fused_prims;
-    fused_desc_onednn.resize(num_fused_prims);
-    for (size_t idx = 0; idx < num_fused_prims; ++idx) {
-        ib >> make_data(&fused_desc_onednn[idx].op_type, sizeof(onednn_post_op_type));
-        ib >> fused_desc_onednn[idx].mem_offset;
-        ib >> fused_desc_onednn[idx].mem_dep;
-        ib >> make_data(&fused_desc_onednn[idx].tag, sizeof(dnnl::memory::format_tag));
-        ib >> fused_desc_onednn[idx].flatten;
-        ib >> fused_desc_onednn[idx].dims;
-        ib >> make_data(&fused_desc_onednn[idx].dt, sizeof(dnnl::memory::data_type));
-    }
-#endif // ENABLE_ONEDNN_FOR_GPU
-    ib >> primary_input_idx;
-}
-
 }  // namespace cldnn
diff --git a/src/plugins/intel_gpu/src/graph/loop.cpp b/src/plugins/intel_gpu/src/graph/loop.cpp
index 1fce75761ad..d24c69e8eda 100644
--- a/src/plugins/intel_gpu/src/graph/loop.cpp
+++ b/src/plugins/intel_gpu/src/graph/loop.cpp
@@ -672,35 +672,6 @@ loop_inst::typed_primitive_inst(network & network, loop_node const & node)
     _num_iterations_id = node.get_num_iterations_id();
 }
 
-void loop_inst::save(BinaryOutputBuffer& ob) const {
-    parent::save(ob);
-    ob << _input_primitive_maps;
-    ob << _output_primitive_maps;
-    ob << _back_edges;
-    ob << _trip_count_id;
-    ob << _initial_execution_id;
-    ob << _current_iteration_id;
-    ob << _condition_id;
-    ob << _num_iterations_id;
-    body_network->save(ob);
-}
-
-void loop_inst::load(BinaryInputBuffer& ib) {
-    parent::load(ib);
-    preproc_memories_done = false,
-    ib >> _input_primitive_maps;
-    ib >> _output_primitive_maps;
-    ib >> _back_edges;
-    ib >> _trip_count_id;
-    ib >> _initial_execution_id;
-    ib >> _current_iteration_id;
-    ib >> _condition_id;
-    ib >> _num_iterations_id;
-    body_network = std::make_shared<cldnn::network>(ib, get_network().get_stream_ptr(), get_network().get_engine(), get_network().is_primary_stream(), 0);
-    // set inner network to the new loaded _impl_params from cache.
-    set_inner_networks({body_network});
-}
-
 void loop_inst::postprocess_output_memory(bool is_dynamic, int64_t current_iteration) {
     if (is_dynamic) {
         std::vector<cldnn::memory::ptr> external_outputs;
diff --git a/src/plugins/intel_gpu/src/graph/mutable_data.cpp b/src/plugins/intel_gpu/src/graph/mutable_data.cpp
index 2b2ad7b14a5..e530afc7990 100644
--- a/src/plugins/intel_gpu/src/graph/mutable_data.cpp
+++ b/src/plugins/intel_gpu/src/graph/mutable_data.cpp
@@ -41,6 +41,11 @@ void mutable_data_node::attach_memory(memory::ptr new_mem, bool invalidate_users
     recalc_output_layout(invalidate_users_if_changed);
 }
 
+void mutable_data_node::replace_memory(memory::ptr new_mem, bool invalidate_users_if_changed) {
+    mem = new_mem;
+    recalc_output_layout(invalidate_users_if_changed);
+}
+
 std::string mutable_data_inst::to_string(mutable_data_node const& node) {
     auto node_info = node.desc_to_json();
 
@@ -83,46 +88,4 @@ mutable_data_inst::typed_primitive_inst(network& network, mutable_data_node cons
     }
 }
 
-void mutable_data_inst::save(cldnn::BinaryOutputBuffer& ob) const {
-    parent::save(ob);
-
-    size_t data_size = _outputs[0]->size();
-    ob << make_data(&data_size, sizeof(size_t));
-
-    if (data_size == 0)
-        return;
-
-    allocation_type _allocation_type = _outputs[0]->get_allocation_type();
-
-    if (_allocation_type == allocation_type::usm_host || _allocation_type == allocation_type::usm_shared) {
-        ob << make_data(_outputs[0]->buffer_ptr(), data_size);
-    } else {
-        mem_lock<char, mem_lock_type::read> lock{_outputs[0], get_node().get_program().get_stream()};
-        ob << make_data(lock.data(), data_size);
-    }
-}
-
-void mutable_data_inst::load(BinaryInputBuffer& ib) {
-    parent::load(ib);
-
-    size_t data_size = 0;
-    ib >> make_data(&data_size, sizeof(size_t));
-
-    if (data_size == 0)
-        return;
-
-    OPENVINO_ASSERT(_outputs[0] != nullptr, "Output memory should be allocated before importing data.");
-
-    allocation_type _allocation_type = _outputs[0]->get_allocation_type();
-
-    if (_allocation_type == allocation_type::usm_host || _allocation_type == allocation_type::usm_shared) {
-        ib >> make_data(_outputs[0]->buffer_ptr(), data_size);
-    } else {
-        std::vector<uint8_t> _buf;
-        _buf.resize(data_size);
-        ib >> make_data(_buf.data(), data_size);
-        _outputs[0]->copy_from(get_network().get_stream(), _buf.data());
-    }
-}
-
 }  // namespace cldnn
diff --git a/src/plugins/intel_gpu/src/graph/network.cpp b/src/plugins/intel_gpu/src/graph/network.cpp
index be6f6f27ee6..75d5bc27d71 100644
--- a/src/plugins/intel_gpu/src/graph/network.cpp
+++ b/src/plugins/intel_gpu/src/graph/network.cpp
@@ -355,167 +355,6 @@ network::network(program::ptr program, uint16_t stream_id)
 network::network(program::ptr program, stream::ptr stream, uint16_t stream_id)
     : network(program, program->get_config(), stream, false, stream_id == 0) {}
 
-network::network(cldnn::BinaryInputBuffer& ib, stream::ptr stream, engine& engine, bool is_primary_stream, uint32_t local_net_id)
-    : network(ib, ExecutionConfig{}, stream, engine, is_primary_stream, local_net_id) {}
-
-network::network(cldnn::BinaryInputBuffer& ib, const ExecutionConfig& config, stream::ptr stream, engine& engine, bool is_primary_stream, uint32_t local_net_id)
-    : _program(nullptr)
-    , _config(config)
-    , _engine(engine)
-    , _stream(stream)
-    , _memory_pool(new memory_pool(engine))
-    , _internal(false)
-    , _is_primary_stream(is_primary_stream)
-    , _reset_arguments(true)
-    , _local_net_id(local_net_id)
-    , _shape_predictor(new ShapePredictor(&engine, config.get_property(ov::intel_gpu::buffers_preallocation_ratio))) {
-    net_id = get_unique_net_id();
-
-    GPU_DEBUG_GET_INSTANCE(debug_config);
-    GPU_DEBUG_IF(debug_config->mem_preallocation_params.is_initialized) {
-        auto& mem_preallocation_params = debug_config->mem_preallocation_params;
-        _shape_predictor.reset(new ShapePredictor(&engine,
-                                                  mem_preallocation_params.next_iters_preallocation_count,
-                                                  mem_preallocation_params.max_per_iter_size,
-                                                  mem_preallocation_params.max_per_dim_diff,
-                                                  mem_preallocation_params.buffers_preallocation_ratio));
-    }
-
-    kernels_cache kernels_cache(get_engine(), config, 0, nullptr, {""});
-    ib >> kernels_cache;
-
-    int num_data_nodes;
-    ib >> num_data_nodes;
-
-    for (int i = 0; i < num_data_nodes; ++i) {
-        std::string type;
-        std::string _primitive_id;
-        ib >> type >> _primitive_id;
-        std::shared_ptr<cldnn::primitive_inst> new_primitive_inst = prim_map_storage::instance().get_type_id(type)->create_instance(*this);
-        ib >> *new_primitive_inst;
-        _primitives[_primitive_id] = new_primitive_inst;
-    }
-
-    std::vector<std::shared_ptr<primitive_inst>> insts_to_allocate;
-    size_t exec_order_size;
-    ib >> exec_order_size;
-
-    for (size_t i = 0; i < exec_order_size; ++i) {
-        std::string type;
-        ib >> type;
-        std::shared_ptr<cldnn::primitive_inst> new_primitive_inst = prim_map_storage::instance().get_type_id(type)->create_instance(*this);
-        insts_to_allocate.emplace_back(new_primitive_inst);
-    }
-
-    _outputs.clear();
-    _output_chains.clear();
-
-    for (const auto& p_inst : insts_to_allocate) {
-        ib >> *p_inst;
-        _primitives[p_inst->id()] = p_inst;
-        if (p_inst->get_impl() != nullptr)
-            p_inst->init_by_cached_kernels(kernels_cache);
-    }
-
-    std::vector<primitive_id> exec_order_ids;
-    ib >> exec_order_ids;
-    _exec_order.clear();
-    for (auto& exec_order_id : exec_order_ids) {
-        _exec_order.emplace_back(_primitives[exec_order_id]);
-    }
-
-    for (auto& item : _primitives) {
-        auto& p_inst = item.second;
-        if (p_inst->is_input())
-            _inputs.push_back(p_inst);
-        if (p_inst->is_output()) {
-            _outputs.push_back(p_inst);
-            if (p_inst->type() == cldnn::data::type_id())
-                _data_outputs.push_back(p_inst);
-        }
-        if (auto state_prim = std::dynamic_pointer_cast<memory_state::variable>(p_inst)) {
-            set_variables_state_info(state_prim->variable_id(), p_inst->get_output_layout(0));
-        }
-    }
-
-    for (const auto& p_inst : _exec_order) {
-        p_inst->rebuild_deps(_primitives);
-        p_inst->rebuild_exec_deps(_primitives);
-
-        if (p_inst->type() == cldnn::concatenation::type_id() && p_inst->can_be_optimized()) {
-            // implicit concat
-            std::list<const std::vector<std::pair<std::shared_ptr<const primitive_inst>, int32_t>>*> stack = {&p_inst->dependencies()};
-            while (!stack.empty()) {
-                auto nodes_list = stack.front();
-                stack.pop_front();
-
-                for (const auto& processed_nodes : *nodes_list) {
-                    auto processed_node = processed_nodes.first;
-                    auto dep_node = _primitives[processed_node->id()];
-                    dep_node->set_output_memory(p_inst->output_memory_ptr(), false);
-                    if (processed_node->type() == concatenation::type_id() && processed_node->can_be_optimized()) {
-                        if (!processed_node->dependencies().empty())
-                            stack.push_back(&processed_node->dependencies());
-                    }
-                }
-            }
-        }
-    }
-
-    std::map<std::string, std::string> reuse_map;
-    ib >> reuse_map;
-
-    for (const auto& reuse_pair : reuse_map) {
-        auto& eltw_inst = _primitives.at(reuse_pair.second);
-        auto& prim_inst = _primitives.at(reuse_pair.first);
-        auto& eltw_mem = eltw_inst->output_memory();
-        auto new_mem = eltw_mem.get_engine()->reinterpret_buffer(eltw_mem, prim_inst->output_memory_ptr()->get_layout());
-        prim_inst->set_output_memory(new_mem);
-    }
-
-    for (auto p_inst : _exec_order) {
-        if (p_inst->can_be_optimized() && !p_inst->is_dynamic()) {
-            p_inst->update_output_memory();
-        }
-    }
-
-    add_default_output_chains();
-
-    size_t prims_info_size;
-    ib >> prims_info_size;
-
-    for (size_t i = 0; i < prims_info_size; i++) {
-        primitive_id original_id;
-        std::string type_id;
-        primitive::primitive_id_arr c_dependencies;
-        primitive::primitive_id_arr c_users;
-        primitive::primitive_id_arr c_fused_ids;
-        layout output_layout;
-        std::string layout_str;
-        std::string kernel_id;
-        data_types runtime_precision;
-        bool is_cpu;
-        int exec_id;
-
-        ib >> original_id;
-        ib >> type_id;
-        ib >> c_dependencies;
-        ib >> c_users;
-        ib >> c_fused_ids;
-        ib >> output_layout;
-        ib >> layout_str;
-        ib >> kernel_id;
-        ib >> make_data(&runtime_precision, sizeof(data_types));
-        ib >> is_cpu;
-        ib >> exec_id;
-        primitive_info prim_info(original_id, type_id, c_dependencies, c_users, c_fused_ids,
-                            output_layout, layout_str, kernel_id, runtime_precision, is_cpu, exec_id);
-        _prims_info.emplace_back(prim_info);
-    }
-
-    ib >> _ext_id_mapping;
-}
-
 network::~network() {
     if (_program != nullptr)
         _program->cancel_compilation_context();
@@ -526,118 +365,6 @@ network::~network() {
     }
 }
 
-// Cache blob format:
-//     [ cldnn::kernels_cache ]
-//     [ non executable primitive_inst ]
-//     [ executable primitive_inst ]
-//     [ memory reuse information ]
-void network::save(cldnn::BinaryOutputBuffer& ob) {
-    auto& kernels_cache = _program->get_kernels_cache();
-    kernels_cache.reset();
-    for (const auto& p_inst : _exec_order) {
-        if (p_inst->get_impl() != nullptr) {
-            auto const_impl = static_cast<const primitive_impl*>(p_inst->get_impl());
-            kernels_cache.add_to_cached_kernels(const_impl->get_kernels());
-        }
-    }
-    ob << kernels_cache;
-
-    int num_data_nodes = 0;
-    for (const auto& p_inst : _primitives) {
-        if (p_inst.second->type() == cldnn::data::type_id() ||
-           (p_inst.second->type() == cldnn::mutable_data::type_id() && p_inst.second->get_impl() == nullptr)) {
-            num_data_nodes += 1;
-        }
-    }
-    ob << num_data_nodes;
-
-    for (const auto& p_inst : _primitives) {
-        if (p_inst.second->type() == cldnn::data::type_id() ||
-           (p_inst.second->type() == cldnn::mutable_data::type_id() && p_inst.second->get_impl() == nullptr)) {
-            ob << p_inst.second->get_node().get_primitive()->type_string();
-            ob << p_inst.second->id();
-            ob << *(p_inst.second);
-        }
-    }
-
-    size_t exec_order_size = _exec_order.size();
-    ob << exec_order_size;
-
-    std::unordered_map<primitive_id, size_t> exec_order_num;
-    size_t i = exec_order_size;
-    for (const auto& p_inst : _exec_order) {
-        exec_order_num[p_inst->id()] = --i;
-    }
-
-    std::vector<std::shared_ptr<primitive_inst>> insts_to_allocate(_exec_order.begin(), _exec_order.end());
-    std::sort(insts_to_allocate.begin(),
-              insts_to_allocate.end(),
-              [&exec_order_num, &exec_order_size](std::shared_ptr<primitive_inst> const& lhs, std::shared_ptr<primitive_inst> const& rhs) {
-                    size_t lhs_size = (lhs->mem_allocated()) ? (lhs->get_output_layout().bytes_count() + exec_order_size) : exec_order_num[lhs->id()];
-                    size_t rhs_size = (rhs->mem_allocated()) ? (rhs->get_output_layout().bytes_count() + exec_order_size) : exec_order_num[rhs->id()];
-                    return (lhs_size > rhs_size);
-              });
-
-    for (const auto& p_inst : insts_to_allocate) {
-        ob << p_inst->get_node().get_primitive()->type_string();
-    }
-
-    for (const auto& p_inst : insts_to_allocate) {
-        ob << *p_inst;
-    }
-
-    std::vector<primitive_id> exec_order_ids;
-    for (const auto& p_inst : _exec_order) {
-        exec_order_ids.emplace_back(p_inst->id());
-    }
-    ob << exec_order_ids;
-
-    std::map<std::string, std::string> reuse_map;
-
-    auto& po = _program->get_processing_order();
-    for (auto const& node : po) {
-        if (node->get_preferred_impl_type() == impl_types::onednn) {
-            size_t eltw_dep = 0;
-            for (auto& fused_op : node->get_fused_primitives()) {
-                if (fused_op.is_type<eltwise>() && fused_op.deps.size() == 1) {
-                    // If it is first sum, reuse the buffer
-                    auto fusing_type = onednn_add_fusing_helpers::get_add_fusing_type(*node, fused_op);
-                    if (fusing_type != add_fusing_type::sum || eltw_dep != 0)
-                        continue;
-                    if (!fused_op.has_outer_dep())
-                        continue;
-                    eltw_dep = fused_op.outer_dep_start_idx;
-                    auto& eltw_in = node->get_dependency(eltw_dep);
-                    if (_primitives.find(eltw_in.id()) != _primitives.end() && _primitives.find(node->id()) != _primitives.end()) {
-                        reuse_map[node->id()] = eltw_in.id();
-                    }
-                }
-            }
-        }
-    }
-
-    ob << reuse_map;
-
-    auto& prims_info = get_primitives_info();
-    ob << prims_info.size();
-    for (auto& prim_info : prims_info) {
-        ob << prim_info.original_id;
-        ob << prim_info.type_id;
-        ob << prim_info.c_dependencies;
-        ob << prim_info.c_users;
-        ob << prim_info.c_fused_ids;
-        ob << prim_info.output_layout;
-        ob << prim_info.layout_str;
-        ob << prim_info.kernel_id;
-        ob << make_data(&prim_info.runtime_precision, sizeof(data_types));
-        ob << prim_info.is_cpu;
-        ob << prim_info.exec_id;
-    }
-
-    ob << get_ext_id_mapping();
-    kernels_cache.reset();
-}
-
 network::ptr network::allocate_network(stream::ptr stream, program::ptr program, bool is_internal, bool is_primary_stream) {
     return std::make_shared<network>(program, program->get_config(), stream, is_internal, is_primary_stream);
 }
diff --git a/src/plugins/intel_gpu/src/graph/nodes_ordering.cpp b/src/plugins/intel_gpu/src/graph/nodes_ordering.cpp
index 8c0dbb9c389..e08c07a8f1e 100644
--- a/src/plugins/intel_gpu/src/graph/nodes_ordering.cpp
+++ b/src/plugins/intel_gpu/src/graph/nodes_ordering.cpp
@@ -89,4 +89,29 @@ bool program::nodes_ordering::is_correct(program_node* node) {
     }
     return true;
 }
+
+void program::nodes_ordering::save(cldnn::BinaryOutputBuffer& ob) const {
+    ob << _processing_order.size();
+    auto itr = rbegin();
+    while (itr != rend()) {
+        auto& node = *itr;
+        ob << node->id();
+        itr++;
+    }
+}
+
+void program::nodes_ordering::load(cldnn::BinaryInputBuffer& ib, program& p) {
+    size_t num_nodes;
+    ib >> num_nodes;
+
+    clear();
+    for (size_t i = 0; i < num_nodes; ++i) {
+        primitive_id node_id;
+        ib >> node_id;
+
+        auto node = p.get_node_ptr(node_id).get();
+        _processing_order.push_front(node);
+        processing_order_iterators[node] = _processing_order.begin();
+    }
+}
 }  // namespace cldnn
diff --git a/src/plugins/intel_gpu/src/graph/primitive_inst.cpp b/src/plugins/intel_gpu/src/graph/primitive_inst.cpp
index 749994450f2..3f83e740a8e 100644
--- a/src/plugins/intel_gpu/src/graph/primitive_inst.cpp
+++ b/src/plugins/intel_gpu/src/graph/primitive_inst.cpp
@@ -1666,245 +1666,4 @@ std::string primitive_inst::get_implementation_name() const {
     return "undef";
 }
 
-static primitive_id find_dep_by_mem(const cldnn::primitive_inst* p_inst, memory& mem_ptr, int max_dist = 5) {
-    std::vector<std::pair<primitive_id, int>> queue;
-    size_t head = 0;
-
-    for (auto& p_inst : p_inst->dependencies())
-        queue.emplace_back(std::make_pair(p_inst.first->id(), 0));
-
-    const network& const_network = p_inst->get_network();
-    while (head < queue.size()) {
-        auto curr_item = queue.at(head);
-        auto curr_prim = const_network.get_primitive(curr_item.first);
-
-        if (p_inst->get_network().get_engine().is_the_same_buffer(mem_ptr, curr_prim->output_memory()))
-            return curr_prim->id();
-
-        if (max_dist > curr_item.second)
-            for (auto& p_inst : curr_prim->dependencies())
-                queue.emplace_back(std::make_pair(p_inst.first->id(), curr_item.second+1));
-
-        head += 1;
-    }
-
-    return "NOT_FOUND";
-}
-
-// Cache blob format:
-//     [ kernel_impl_params ]
-//     [ primitive_impl ]
-//     [ member variables of primitive_inst ]
-//     [ output memory information ]
-//     [ memory dependency information ]
-//     [ execution dependency information ]
-//     [ intermediate memory information ]
-void primitive_inst::save(cldnn::BinaryOutputBuffer& ob) const {
-    _impl_params->save(ob);
-    ob.setKernelImplParams(_impl_params.get());
-
-    ob << _node_output_layout;
-    ob << has_mutable_input();
-    ob << mem_allocated();
-    ob << is_dynamic();
-    ob << _node->get_primitive()->type_string();
-    ob << id();
-    ob << org_id();
-    ob << is_input();
-    ob << is_output();
-    ob << inputs_memory_count();
-    ob << outputs_memory_count();
-    ob << get_fused_mem_count();
-    ob << get_fused_mem_offset();
-    ob << can_be_optimized();
-    ob << can_share_buffer();
-    ob << is_constant();
-    ob << needs_completion_event();
-
-    if (type() == cldnn::data::type_id()) {
-        return;
-    }
-
-    ob << _outputs.size();
-    for (size_t i = 0; i < _outputs.size(); ++i) {
-        if (_outputs[i] == nullptr) {
-            ob << true;
-        } else {
-            ob << false;
-            ob << _outputs[i]->get_layout();
-            const auto _allocation_type = _outputs[i]->get_allocation_type();
-            ob << make_data(&_allocation_type, sizeof(_allocation_type));
-        }
-    }
-
-    bool can_reuse_memory = true;
-    if (user_requesting_mem_reuse_false(*_node)) {
-        can_reuse_memory = false;
-    }
-    ob << can_reuse_memory;
-
-    ob << _node->get_memory_dependencies();
-
-    ob << _deps.size();
-    for (const auto& dep : _deps) {
-        ob << dep.first->id();
-        ob << dep.second;
-    }
-
-    ob << _exec_deps.size();
-    for (const auto& dep : _exec_deps) {
-        ob << dep->id();
-    }
-
-    for (size_t i = 0; i < _outputs.size(); ++i) {
-        if (_outputs[i] != nullptr) {
-            if (!mem_allocated())
-                ob << find_dep_by_mem(this, output_memory(i));
-        }
-    }
-
-    ob << _intermediates_memory.size();
-    for (const auto& ibuf : _intermediates_memory) {
-        ob << ibuf->get_layout();
-        const auto _allocation_type = ibuf->get_allocation_type();
-        ob << make_data(&_allocation_type, sizeof(_allocation_type));
-    }
-
-    if (_impl != nullptr) {
-        ob << true;
-        _impl->set_cached_kernel_ids(_network.get_program()->get_kernels_cache());
-        ob << _impl;
-    } else {
-        ob << false;
-    }
-}
-
-int32_t primitive_inst::get_index_in_deps(memory::cptr arg) const {
-    for (uint32_t idx = 0; idx < _deps.size(); ++idx) {
-        if (arg == dep_memory_ptr(idx))
-            return idx;
-    }
-
-    OPENVINO_THROW("[get_index_in_deps]: not found in _deps");
-}
-
-void primitive_inst::load(cldnn::BinaryInputBuffer& ib) {
-    _impl_params->load(ib);
-    ib.setKernelImplParams(_impl_params.get());
-
-    ib >> _node_output_layout;
-    ib >> _has_mutable_input;
-    ib >> _mem_allocated;
-    ib >> _is_dynamic;
-    std::string type_str;
-    ib >> type_str;
-    _type = cldnn::prim_map_storage::instance().get_type_id(type_str);
-    ib >> _id;
-    ib >> _org_id;
-    ib >> _is_input;
-    ib >> _is_output;
-    ib >> _inputs_memory_count;
-    ib >> _outputs_memory_count;
-    ib >> _fused_mem_count;
-    ib >> _fused_mem_offset;
-    ib >> _can_be_optimized;
-    ib >> _can_share_buffer;
-    ib >> _is_constant;
-    ib >> _needs_completion_event;
-
-    if (type() == cldnn::data::type_id()) {
-        return;
-    }
-
-    // mem_allocated : it is true if the output memory is allocated by this layer, and
-    //                 false if this layer reuses output memory that is allocated by other layer.
-    // is_output_null : it is true if the output memory is not allocated yet and false otherwise.
-    size_t num_outputs;
-    std::vector<bool> is_output_null;
-    std::vector<layout> output_layouts;
-    std::vector<allocation_type> allocation_types;
-
-    ib >> num_outputs;
-    is_output_null.resize(num_outputs);
-    for (size_t i = 0; i < num_outputs; ++i) {
-        bool is_null;
-        ib >> is_null;
-        is_output_null[i] = is_null;
-        if (!is_null) {
-            layout output_layout = layout();
-            ib >> output_layout;
-            output_layouts.emplace_back(output_layout);
-
-            allocation_type _allocation_type = allocation_type::unknown;
-            ib >> make_data(&_allocation_type, sizeof(_allocation_type));
-            allocation_types.emplace_back(_allocation_type);
-        }
-    }
-
-    bool can_reuse_memory;
-    ib >> can_reuse_memory;
-
-    std::set<primitive_id> _node_mem_deps;
-    ib >> _node_mem_deps;
-    _runtime_memory_dependencies = _node_mem_deps;
-
-    size_t vector_size = 0UL;
-    ib >> vector_size;
-    for (size_t i = 0; i < vector_size; ++i) {
-        primitive_id dep_id;
-        int32_t dep_idx;
-        ib >> dep_id >> dep_idx;
-        _dep_ids.emplace_back(std::pair<primitive_id, int32_t>(dep_id, dep_idx));
-    }
-
-    ib >> vector_size;
-    _exec_dep_ids.resize(vector_size);
-    for (auto& el : _exec_dep_ids) {
-        ib >> el;
-    }
-
-    _outputs.resize(num_outputs);
-    for (size_t i = 0; i < num_outputs; ++i) {
-        _outputs[i] = nullptr;
-        if (!is_output_null[i]) {
-            if (!_mem_allocated) {
-                std::string dep_id;
-                ib >> dep_id;
-                if (dep_id.compare("NOT_FOUND") != 0 && get_network().get_primitive(dep_id)->output_memory_ptr() != nullptr) {
-                    _outputs[i] = get_network().get_engine().reinterpret_buffer(get_network().get_primitive(dep_id)->output_memory(), output_layouts[i]);
-                } else if (type() == cldnn::mutable_data::type_id()) {
-                    _outputs[i] = get_network().get_engine().allocate_memory(output_layouts[i], allocation_types[i]);
-                }
-            } else {
-                if ((!can_share_buffer()) || can_be_optimized() || is_output()) {
-                    _outputs[i] = get_network().get_engine().allocate_memory(output_layouts[i], allocation_types[i]);
-                } else {
-                    _outputs[i] = get_network().get_memory_pool().get_memory(output_layouts[i], id(), get_network_id(), _node_mem_deps,
-                                                                            allocation_types[i], can_reuse_memory);
-                }
-            }
-        }
-    }
-    _output_changed = false;
-
-    ib >> vector_size;
-    _intermediates_memory.resize(vector_size);
-    for (size_t i = 0; i < vector_size; i++) {
-        layout ibuf_layout = layout();
-        ib >> ibuf_layout;
-        allocation_type _allocation_type;
-        ib >> make_data(&_allocation_type, sizeof(_allocation_type));
-
-        _intermediates_memory[i] = get_network().get_memory_pool().get_memory(ibuf_layout, id(), get_network_id(),
-                                                                            _node_mem_deps, _allocation_type, true, true);
-    }
-
-    bool has_impl;
-    ib >> has_impl;
-    if (has_impl) {
-        _impl.reset();
-        ib >> _impl;
-    }
-}
-
 }  // namespace cldnn
diff --git a/src/plugins/intel_gpu/src/graph/program.cpp b/src/plugins/intel_gpu/src/graph/program.cpp
index e3ec8ea6ae9..dad504cb09e 100644
--- a/src/plugins/intel_gpu/src/graph/program.cpp
+++ b/src/plugins/intel_gpu/src/graph/program.cpp
@@ -1683,3 +1683,245 @@ void program::cancel_compilation_context() {
     if (_compilation_context != nullptr)
         _compilation_context->cancel();
 }
+
+void program::save(cldnn::BinaryOutputBuffer& ob) const {
+    std::map<cldnn::memory::ptr, std::vector<const cldnn::program_node*>> mutable_datas_ptrs;
+    ob << nodes_map.size();
+    for (auto& node : nodes_map) {
+        ob.setKernelImplParams(node.second->get_kernel_impl_params().get());
+
+        if (node.second->is_type<data>() && node.second->as<data>().get_primitive()->mem == nullptr) {
+            auto& data_node = node.second->as<data>();
+            if (data_node.get_attached_memory_ptr() == nullptr) {
+                ob << false;
+                continue;
+            } else {
+                node.second->as<data>().typed_desc()->mem = data_node.get_attached_memory_ptr();
+            }
+        }
+        ob << true;
+
+        ob << node.second->desc;
+
+        if (node.second->is_type<mutable_data>()) {
+            mutable_datas_ptrs[node.second->as<mutable_data>().get_attached_memory_ptr()].push_back(node.second.get());
+        }
+    }
+
+    std::list<std::pair<primitive_id, primitive_id>> output_sharing_mutable_datas;
+    for (auto item : mutable_datas_ptrs) {
+        if (item.second.size() != 2)
+            continue;
+
+        output_sharing_mutable_datas.push_back({item.second[0]->id(), item.second[1]->id()});
+    }
+
+    ob << output_sharing_mutable_datas.size();
+    for (auto& shared_mem_pair : output_sharing_mutable_datas) {
+        ob << shared_mem_pair.first;
+        ob << shared_mem_pair.second;
+    }
+
+    for (auto& node : nodes_map) {
+        ob << node.first;
+        node.second->save(ob);
+        ob << node.second->get_dependant_shape_of_nodes().size();
+        for (auto& dep_node : node.second->get_dependant_shape_of_nodes()) {
+            ob << dep_node->id();
+        }
+    }
+
+    ob << inputs.size();
+    for (auto& input : inputs) {
+        ob << input->id();
+    }
+
+    ob << outputs.size();
+    for (auto& output : outputs) {
+        ob << output->id();
+    }
+
+    ob << _is_body_program;
+    ob << _can_be_optimized;
+    get_processing_order().save(ob);
+
+    {
+        auto& kernels_cache = get_kernels_cache();
+        std::vector<primitive_id> impl_ids;
+        for (auto& node : get_processing_order()) {
+            if (node->get_selected_impl() != nullptr) {
+                impl_ids.emplace_back(node->id());
+                kernels_cache.add_to_cached_kernels(node->get_selected_impl()->get_kernels());
+            }
+        }
+        ob << kernels_cache;
+        ob << impl_ids;
+        for (auto& impl_id : impl_ids) {
+            if (get_node_ptr(impl_id)->get_selected_impl()->is_onednn()) {
+                ob << true;
+                auto params = get_node_ptr(impl_id)->get_kernel_impl_params();
+                ob.setKernelImplParams(params.get());
+                ob << get_node_ptr(impl_id)->selected_impl;
+            } else {
+                ob << false;
+                ob << get_node_ptr(impl_id)->selected_impl;
+            }
+            ob << get_node_ptr(impl_id)->get_selected_impl()->get_cached_kernel_ids(kernels_cache);
+        }
+    }
+
+    ob << optimized_out.size();
+    for (auto& opt_prim : optimized_out) {
+        ob << opt_prim;
+    }
+
+    ob << prim_info.size();
+    for (auto& p_info : prim_info) {
+        ob << p_info.original_id;
+        ob << p_info.type_id;
+        ob << p_info.c_dependencies;
+        ob << p_info.c_users;
+        ob << p_info.c_fused_ids;
+        ob << p_info.output_layout;
+        ob << p_info.layout_str;
+        ob << p_info.kernel_id;
+        ob << make_data(&p_info.runtime_precision, sizeof(data_types));
+        ob << p_info.is_cpu;
+        ob << p_info.exec_id;
+    }
+}
+
+void program::load(cldnn::BinaryInputBuffer& ib) {
+    init_program();
+
+    size_t num_nodes;
+    ib >> num_nodes;
+    bool is_valid_data_node;
+    for (size_t i = 0; i < num_nodes; ++i) {
+        ib >> is_valid_data_node;
+        if (!is_valid_data_node)
+            continue;
+
+        std::shared_ptr<cldnn::primitive> prim;
+        ib >> prim;
+        get_or_create(prim);
+    }
+
+    size_t num_output_sharing_mutable_datas;
+    ib >> num_output_sharing_mutable_datas;
+    for (size_t i = 0; i < num_output_sharing_mutable_datas; ++i) {
+        primitive_id md_id1, md_id2;
+        ib >> md_id1;
+        ib >> md_id2;
+
+        auto& md_node1 = get_node(md_id1).as<mutable_data>();
+        auto& md_node2 = get_node(md_id2).as<mutable_data>();
+
+        md_node2.typed_desc()->mem = md_node1.typed_desc()->mem;
+        md_node2.replace_memory(md_node2.typed_desc()->mem);
+    }
+
+    for (size_t i = 0; i < num_nodes; ++i) {
+        primitive_id prim_id;
+        ib >> prim_id;
+        auto& p_node = get_node(prim_id);
+        p_node.load(ib);
+        size_t num_dep_nodes;
+        ib >> num_dep_nodes;
+        for (size_t i = 0; i < num_dep_nodes; ++i) {
+            ib >> prim_id;
+            auto& dep_node = get_node(prim_id);
+            p_node.add_dependant_shape_of_node(&dep_node);
+        }
+    }
+
+    ib >> num_nodes;
+    inputs.clear();
+    for (size_t i = 0; i < num_nodes; ++i) {
+        primitive_id prim_id;
+        ib >> prim_id;
+        auto& p_node = get_node(prim_id);
+        inputs.emplace_back(&p_node);
+    }
+
+    ib >> num_nodes;
+    outputs.clear();
+    for (size_t i = 0; i < num_nodes; ++i) {
+        primitive_id prim_id;
+        ib >> prim_id;
+        auto& p_node = get_node(prim_id);
+        outputs.emplace_back(&p_node);
+    }
+
+    ib >> _is_body_program;
+    ib >> _can_be_optimized;
+
+    get_processing_order().load(ib, *this);
+
+    {
+        auto& kernels_cache = get_kernels_cache();
+        ib >> kernels_cache;
+
+        std::vector<primitive_id> impl_ids;
+        ib >> impl_ids;
+
+        for (auto& impl_id : impl_ids) {
+            auto& p_node = get_node(impl_id);
+
+            bool is_onednn;
+            ib >> is_onednn;
+            if (is_onednn) {
+                auto params = p_node.get_kernel_impl_params();
+                ib.setKernelImplParams(params.get());
+                ib >> p_node.selected_impl;
+            } else {
+                ib >> p_node.selected_impl;
+            }
+
+            std::vector<std::string> cached_kernel_ids;
+            ib >> cached_kernel_ids;
+            p_node.selected_impl->init_by_cached_kernels(get_kernels_cache(), cached_kernel_ids);
+        }
+    }
+
+    size_t optimized_out_size;
+    ib >> optimized_out_size;
+    optimized_out.clear();
+    for (size_t i = 0; i < optimized_out_size; i++) {
+        primitive_id opt_prim;
+        ib >> opt_prim;
+        optimized_out.emplace_back(opt_prim);
+    }
+
+    size_t prims_info_size;
+    ib >> prims_info_size;
+    prim_info.clear();
+    for (size_t i = 0; i < prims_info_size; i++) {
+        primitive_id original_id;
+        std::string type_id;
+        primitive::primitive_id_arr c_dependencies;
+        primitive::primitive_id_arr c_users;
+        primitive::primitive_id_arr c_fused_ids;
+        layout output_layout;
+        std::string layout_str;
+        std::string kernel_id;
+        data_types runtime_precision;
+        bool is_cpu;
+        int exec_id;
+
+        ib >> original_id;
+        ib >> type_id;
+        ib >> c_dependencies;
+        ib >> c_users;
+        ib >> c_fused_ids;
+        ib >> output_layout;
+        ib >> layout_str;
+        ib >> kernel_id;
+        ib >> make_data(&runtime_precision, sizeof(data_types));
+        ib >> is_cpu;
+        ib >> exec_id;
+        primitive_info p_info(original_id, type_id, c_dependencies, c_users, c_fused_ids,
+                              output_layout, layout_str, kernel_id, runtime_precision, is_cpu, exec_id);
+        prim_info.emplace_back(p_info);
+    }
+}
diff --git a/src/plugins/intel_gpu/src/graph/program_node.cpp b/src/plugins/intel_gpu/src/graph/program_node.cpp
index 354073fbf54..7e9c05882db 100644
--- a/src/plugins/intel_gpu/src/graph/program_node.cpp
+++ b/src/plugins/intel_gpu/src/graph/program_node.cpp
@@ -7,6 +7,9 @@
 #include "primitive_inst.h"
 #include "loop_inst.h"
 #include "shape_of_inst.h"
+#include "activation_inst.h"
+#include "reorder_inst.h"
+#include "quantize_inst.h"
 #include "intel_gpu/runtime/debug_configuration.hpp"
 #ifdef ENABLE_ONEDNN_FOR_GPU
 #include "convolution_inst.h"
@@ -534,6 +537,356 @@ void program_node::add_dependant_shape_of_node(const program_node* node) {
     dependant_shape_of_nodes.insert(node);
 }
 
+void program_node::save(cldnn::BinaryOutputBuffer& ob) const {
+    ob << valid_output_layouts;
+    ob << output_layouts;
+
+    ob << preferred_input_fmts.size();
+    for (auto preferred_input_fmt : preferred_input_fmts) {
+        int32_t format_type_int = preferred_input_fmt;
+        ob << format_type_int;
+    }
+
+    ob << preferred_output_fmts.size();
+    for (auto preferred_output_fmt : preferred_output_fmts) {
+        int32_t format_type_int = preferred_output_fmt;
+        ob << format_type_int;
+    }
+
+    ob << dependencies.size();
+    for (const auto& dep_pair : dependencies) {
+        ob << dep_pair.first->id();
+        ob << dep_pair.second;
+    }
+
+    ob << users.size();
+    for (const auto& user_node : users) {
+        ob << user_node->id();
+    }
+
+    ob << memory_dependencies;
+
+    ob << make_data(&impl_type, sizeof(impl_type));
+    ob << constant;
+    ob << data_flow;
+    ob << in_shape_of_subgraph;
+
+    ob << output;
+    ob << user_mark;
+    ob << optimized;
+    ob << share_buffer;
+    for (const auto& _support_padding : _support_padding_in_axis) {
+        ob << _support_padding;
+    }
+
+    ob << has_reused_memory;
+    ob << reused_memory_color;
+
+    // fused_prims;
+    {
+        ob << fused_prims.size();
+        for (auto& f_desc : fused_prims) {
+            if (get_program().has_node(f_desc.desc->id)) {
+                ob << true;
+                ob << f_desc.desc->id;
+            } else {
+                ob << false;
+                ob << f_desc.desc;
+            }
+            ob << f_desc.input_layout;
+            ob << f_desc.output_layout;
+            ob << cldnn::prim_map_storage::instance().get_type_string(f_desc.f_param->type());
+            if (f_desc.f_param->type() == activation::type_id()) {
+                auto casted = std::dynamic_pointer_cast<ActivationFuseParams>(f_desc.f_param);
+                if (get_program().has_node(casted->_desc->id)) {
+                    ob << true;
+                    ob << casted->_desc->id;
+                } else {
+                    ob << false;
+                    ob << casted->_desc;
+                }
+            } else if (f_desc.f_param->type() == reorder::type_id()) {
+                auto casted = std::dynamic_pointer_cast<ReorderFuseParams>(f_desc.f_param);
+                ob << casted->_in;
+                ob << casted->_out;
+            } else if (f_desc.f_param->type() == eltwise::type_id()) {
+                auto casted = std::dynamic_pointer_cast<EltwiseFuseParams>(f_desc.f_param);
+                if (get_program().has_node(casted->_desc->id)) {
+                    ob << true;
+                    ob << casted->_desc->id;
+                } else {
+                    ob << false;
+                    ob << casted->_desc;
+                }
+            } else if (f_desc.f_param->type() == quantize::type_id()) {
+                auto casted = std::dynamic_pointer_cast<QuantizeFuseParams>(f_desc.f_param);
+                ob << casted->_out_layout;
+                ob << casted->_scale_shift_opt;
+                ob << casted->_need_post_scale;
+                ob << casted->_need_post_shift;
+                ob << casted->_need_pre_shift;
+                ob << casted->_need_clamp;
+                ob << casted->_need_min_clamp;
+                ob << casted->_need_max_clamp;
+                ob << casted->_per_tensor_input_range;
+                ob << casted->_per_tensor_input_scale;
+                ob << casted->_per_tensor_input_shift;
+                ob << casted->_per_tensor_output_range;
+                ob << casted->_per_tensor_output_scale;
+                ob << casted->_per_tensor_output_shift;
+                ob << casted->_in_lo;
+                ob << casted->_in_hi;
+                ob << casted->_in_scale;
+                ob << casted->_in_shift;
+                ob << casted->_out_lo;
+                ob << casted->_out_hi;
+                ob << casted->_out_scale;
+                ob << casted->_out_shift;
+            }
+
+            ob << f_desc.deps.size();
+            for (auto& dep : f_desc.deps) {
+                ob << dep.first;
+                ob << dep.second;
+            }
+            ob << f_desc.fused_deps.size();
+            for (auto& f_dep : f_desc.fused_deps) {
+                ob << f_dep.first;
+                ob << f_dep.second;
+            }
+            ob << f_desc.outer_dep_start_idx;
+            ob << f_desc.total_num_deps;
+        }
+    }
+#ifdef ENABLE_ONEDNN_FOR_GPU
+    size_t num_fused_prims = fused_prims_onednn.size();
+    ob << num_fused_prims;
+    for (auto fused_prim : fused_prims_onednn) {
+        ob << make_data(&fused_prim.op_type, sizeof(onednn_post_op_type));
+        ob << fused_prim.mem_offset;
+        ob << fused_prim.mem_dep;
+        ob << make_data(&fused_prim.tag, sizeof(dnnl::memory::format_tag));
+        ob << fused_prim.flatten;
+        ob << fused_prim.dims;
+        ob << make_data(&fused_prim.dt, sizeof(dnnl::memory::data_type));
+    }
+#endif // ENABLE_ONEDNN_FOR_GPU
+}
+
+void program_node::load(cldnn::BinaryInputBuffer& ib) {
+    ib >> valid_output_layouts;
+    ib >> output_layouts;
+
+    {
+        // preferred_input_fmts
+        size_t preferred_input_fmts_size;
+        int32_t format_type_int;
+        ib >> preferred_input_fmts_size;
+        preferred_input_fmts.clear();
+        for (size_t i = 0; i < preferred_input_fmts_size; ++i) {
+            ib >> format_type_int;
+            preferred_input_fmts.push_back((format::type) format_type_int);
+        }
+    }
+
+    {
+        // preferred_input_fmts
+        size_t preferred_output_fmts_size;
+        int32_t format_type_int;
+        ib >> preferred_output_fmts_size;
+        preferred_output_fmts.clear();
+        for (size_t i = 0; i < preferred_output_fmts_size; ++i) {
+            ib >> format_type_int;
+            preferred_output_fmts.push_back((format::type) format_type_int);
+        }
+    }
+
+    {
+        // dependencies
+        size_t deps_size;
+        primitive_id dep_id;
+        int32_t dep_idx;
+        ib >> deps_size;
+        dependencies.clear();
+        for (size_t i = 0; i < deps_size; ++i) {
+            ib >> dep_id;
+            ib >> dep_idx;
+            dependencies.emplace_back(std::make_pair(get_program().get_node_ptr(dep_id).get(), dep_idx));
+        }
+    }
+
+    {
+        // users
+        size_t users_size;
+        primitive_id user_id;
+        ib >> users_size;
+        users.clear();
+        users.resize(0);
+        for (size_t i = 0; i < users_size; ++i) {
+            ib >> user_id;
+            users.push_back(get_program().get_node_ptr(user_id).get());
+        }
+    }
+
+    ib >> memory_dependencies;
+
+    ib >> make_data(&impl_type, sizeof(impl_type));
+    ib >> constant;
+    ib >> data_flow;
+    ib >> in_shape_of_subgraph;
+
+    ib >> output;
+    ib >> user_mark;
+    ib >> optimized;
+    ib >> share_buffer;
+    for (auto& _support_padding : _support_padding_in_axis) {
+        ib >> _support_padding;
+    }
+    ib >> has_reused_memory;
+    ib >> reused_memory_color;
+
+    // fused_prims;
+    {
+        size_t fused_desc_size;
+        ib >> fused_desc_size;
+        for (size_t i = 0; i < fused_desc_size; ++i) {
+            bool exist_prim;
+            ib >> exist_prim;
+            std::shared_ptr<const primitive> desc;
+            if (exist_prim) {
+                primitive_id desc_id;
+                ib >> desc_id;
+                desc = get_program().get_node_ptr(desc_id)->desc;
+            } else {
+                ib >> desc;
+            }
+            auto f_desc = fused_primitive_desc(desc);
+            ib >> f_desc.input_layout;
+            ib >> f_desc.output_layout;
+
+            std::string f_param_type_str;
+            ib >> f_param_type_str;
+            auto f_param_type = cldnn::prim_map_storage::instance().get_type_id(f_param_type_str);
+            if (f_param_type == activation::type_id()) {
+                ib >> exist_prim;
+                std::shared_ptr<activation> param_desc;
+                if (exist_prim) {
+                    primitive_id desc_id;
+                    ib >> desc_id;
+                    param_desc = std::dynamic_pointer_cast<activation>(get_program().get_node_ptr(desc_id)->desc);
+                } else {
+                    ib >> param_desc;
+                }
+                f_desc.f_param = std::make_shared<ActivationFuseParams>(param_desc);
+            } else if (f_param_type == reorder::type_id()) {
+                layout in, out;
+                ib >> in;
+                ib >> out;
+                f_desc.f_param = std::make_shared<ReorderFuseParams>(in, out);
+            } else if (f_param_type == eltwise::type_id()) {
+                ib >> exist_prim;
+                std::shared_ptr<eltwise> param_desc;
+                if (exist_prim) {
+                    primitive_id desc_id;
+                    ib >> desc_id;
+                    param_desc = std::dynamic_pointer_cast<eltwise>(get_program().get_node_ptr(desc_id)->desc);
+                } else {
+                    ib >> param_desc;
+                }
+                f_desc.f_param = std::make_shared<EltwiseFuseParams>(param_desc);
+            } else if (f_param_type == quantize::type_id()) {
+                layout out_layout;
+                bool scale_shift_opt;
+                bool need_post_scale;
+                bool need_post_shift;
+                bool need_pre_shift;
+                bool need_clamp;
+                bool need_min_clamp;
+                bool need_max_clamp;
+                bool per_tensor_input_range;
+                bool per_tensor_input_scale;
+                bool per_tensor_input_shift;
+                bool per_tensor_output_range;
+                bool per_tensor_output_scale;
+                bool per_tensor_output_shift;
+                float in_lo;
+                float in_hi;
+                float in_scale;
+                float in_shift;
+                float out_lo;
+                float out_hi;
+                float out_scale;
+                float out_shift;
+
+                ib >> out_layout;
+                ib >> scale_shift_opt;
+                ib >> need_post_scale;
+                ib >> need_post_shift;
+                ib >> need_pre_shift;
+                ib >> need_clamp;
+                ib >> need_min_clamp;
+                ib >> need_max_clamp;
+                ib >> per_tensor_input_range;
+                ib >> per_tensor_input_scale;
+                ib >> per_tensor_input_shift;
+                ib >> per_tensor_output_range;
+                ib >> per_tensor_output_scale;
+                ib >> per_tensor_output_shift;
+                ib >> in_lo;
+                ib >> in_hi;
+                ib >> in_scale;
+                ib >> in_shift;
+                ib >> out_lo;
+                ib >> out_hi;
+                ib >> out_scale;
+                ib >> out_shift;
+
+                f_desc.f_param = std::make_shared<QuantizeFuseParams>(out_layout, scale_shift_opt, need_post_scale, need_post_shift,
+                                    need_pre_shift, need_clamp, need_min_clamp, need_max_clamp, per_tensor_input_range,
+                                    per_tensor_input_scale, per_tensor_input_shift, per_tensor_output_range, per_tensor_output_scale,
+                                    per_tensor_output_shift, in_lo, in_hi, in_scale, in_shift, out_lo, out_hi, out_scale, out_shift);
+            } else {
+                f_desc.f_param = std::make_shared<NodeFuseParams>(f_param_type);
+            }
+
+            size_t num_deps;
+            primitive_id prim_id;
+            size_t idx;
+            ib >> num_deps;
+            f_desc.deps.clear();
+            for (size_t i = 0; i < num_deps; ++i) {
+                ib >> prim_id;
+                ib >> idx;
+                f_desc.deps.emplace_back(std::make_pair(prim_id, idx));
+            }
+            ib >> num_deps;
+            f_desc.fused_deps.clear();
+            for (size_t i = 0; i < num_deps; ++i) {
+                ib >> prim_id;
+                ib >> idx;
+                f_desc.fused_deps[prim_id] = idx;
+            }
+            ib >> f_desc.outer_dep_start_idx;
+            ib >> f_desc.total_num_deps;
+            fused_prims.emplace_back(f_desc);
+        }
+    }
+#ifdef ENABLE_ONEDNN_FOR_GPU
+    size_t num_fused_prims;
+    ib >> num_fused_prims;
+    fused_prims_onednn.resize(num_fused_prims);
+    for (size_t idx = 0; idx < num_fused_prims; ++idx) {
+        ib >> make_data(&fused_prims_onednn[idx].op_type, sizeof(onednn_post_op_type));
+        ib >> fused_prims_onednn[idx].mem_offset;
+        ib >> fused_prims_onednn[idx].mem_dep;
+        ib >> make_data(&fused_prims_onednn[idx].tag, sizeof(dnnl::memory::format_tag));
+        ib >> fused_prims_onednn[idx].flatten;
+        ib >> fused_prims_onednn[idx].dims;
+        ib >> make_data(&fused_prims_onednn[idx].dt, sizeof(dnnl::memory::data_type));
+    }
+#endif // ENABLE_ONEDNN_FOR_GPU
+}
+
     /* ----------------------------------------- */
     /* Onednn fused operations integration logic */
     /* ----------------------------------------- */
diff --git a/src/plugins/intel_gpu/src/graph/proposal.cpp b/src/plugins/intel_gpu/src/graph/proposal.cpp
index 9d65b912a3f..310ed53f5e8 100644
--- a/src/plugins/intel_gpu/src/graph/proposal.cpp
+++ b/src/plugins/intel_gpu/src/graph/proposal.cpp
@@ -198,14 +198,4 @@ static void generate_anchors(unsigned int base_size,
         }
     }
 }
-
-void proposal_inst::save(BinaryOutputBuffer& ob) const {
-    parent::save(ob);
-    ob << _anchors;
-}
-
-void proposal_inst::load(BinaryInputBuffer& ib) {
-    parent::load(ib);
-    ib >> _anchors;
-}
 }  // namespace cldnn
diff --git a/src/plugins/intel_gpu/src/graph/read_value.cpp b/src/plugins/intel_gpu/src/graph/read_value.cpp
index 7d37738331f..e9003608ad9 100644
--- a/src/plugins/intel_gpu/src/graph/read_value.cpp
+++ b/src/plugins/intel_gpu/src/graph/read_value.cpp
@@ -42,18 +42,4 @@ void read_value_inst::update_output_memory() {
     const auto& variable = get_network().get_variable(variable_id());
     set_output_memory(variable.get_memory(), false, 0);
 }
-
-void read_value_inst::save(cldnn::BinaryOutputBuffer& ob) const {
-    parent::save(ob);
-
-    ob << variable_id();
-}
-
-void read_value_inst::load(cldnn::BinaryInputBuffer& ib) {
-    parent::load(ib);
-
-    std::string variable_id;
-    ib >> variable_id;
-    set_variable_id(variable_id);
-}
 } // namespace cldnn
diff --git a/src/plugins/intel_gpu/src/graph/reorder.cpp b/src/plugins/intel_gpu/src/graph/reorder.cpp
index 82bfe576ddf..8e556f0b10a 100644
--- a/src/plugins/intel_gpu/src/graph/reorder.cpp
+++ b/src/plugins/intel_gpu/src/graph/reorder.cpp
@@ -275,14 +275,4 @@ void reorder_inst::update_output_memory() {
     }
     _mem_allocated = false;
 }
-
-void reorder_inst::save(cldnn::BinaryOutputBuffer& ob) const {
-    parent::save(ob);
-    ob << _req_reinterpr;
-}
-
-void reorder_inst::load(cldnn::BinaryInputBuffer& ib) {
-    parent::load(ib);
-    ib >> _req_reinterpr;
-}
 }  // namespace cldnn
diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernel_base.h b/src/plugins/intel_gpu/src/kernel_selector/kernel_base.h
index 25f09284dfe..821fdeee347 100644
--- a/src/plugins/intel_gpu/src/kernel_selector/kernel_base.h
+++ b/src/plugins/intel_gpu/src/kernel_selector/kernel_base.h
@@ -57,6 +57,7 @@ public:
         return DeviceFeaturesKey();
     }
     virtual const std::string GetName() const { return kernelName; }
+    virtual void GetUpdateDispatchDataFunc(KernelData& kd) const { }
 
     static const primitive_db& get_db() { return db; }
 
diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernel_selector.cpp b/src/plugins/intel_gpu/src/kernel_selector/kernel_selector.cpp
index 021ff5d9071..0220a235dcd 100644
--- a/src/plugins/intel_gpu/src/kernel_selector/kernel_selector.cpp
+++ b/src/plugins/intel_gpu/src/kernel_selector/kernel_selector.cpp
@@ -145,6 +145,14 @@ KernelsData kernel_selector_base::GetAutoTuneBestKernel(const Params& params, co
     return GetNaiveBestKernel(allImplementations, params, options);
 }
 
+std::shared_ptr<KernelBase> kernel_selector_base::GetImplementation(std::string& kernel_name) const {
+    for (auto& impl : implementations) {
+        if (impl->GetName().compare(kernel_name) == 0)
+            return impl;
+    }
+    return nullptr;
+}
+
 KernelList kernel_selector_base::GetAllImplementations(const Params& params, const optional_params& options, KernelType kType) const {
     using PriorityPair = std::pair<KernelsPriority, std::shared_ptr<KernelBase>>;
     auto comparePriority = [](const PriorityPair& firstImpl, const PriorityPair& secondImpl) {
diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernel_selector.h b/src/plugins/intel_gpu/src/kernel_selector/kernel_selector.h
index 01b4e8ed836..c1ac1756d74 100644
--- a/src/plugins/intel_gpu/src/kernel_selector/kernel_selector.h
+++ b/src/plugins/intel_gpu/src/kernel_selector/kernel_selector.h
@@ -23,6 +23,7 @@ public:
     virtual ~kernel_selector_base() {}
 
     KernelData get_best_kernel(const Params& params, const optional_params& options) const;
+    std::shared_ptr<KernelBase> GetImplementation(std::string& kernel_name) const;
 
 protected:
     template <typename T>
diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/activation/activation_kernel_base.cpp b/src/plugins/intel_gpu/src/kernel_selector/kernels/activation/activation_kernel_base.cpp
index f27b2d189da..1b3bb100607 100644
--- a/src/plugins/intel_gpu/src/kernel_selector/kernels/activation/activation_kernel_base.cpp
+++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/activation/activation_kernel_base.cpp
@@ -81,6 +81,17 @@ bool ActivationKernelBase::Validate(const Params& p, const optional_params& o) c
     return true;
 }
 
+void ActivationKernelBase::GetUpdateDispatchDataFunc(KernelData& kd) const {
+    kd.update_dispatch_data_func = [this](const Params& params, KernelData& kd) {
+        const auto& prim_params = static_cast<const activation_params&>(params);
+        auto dispatchData = SetDefault(prim_params);
+        OPENVINO_ASSERT(kd.kernels.size() == 1, "[GPU] Invalid kernels size for update dispatch data func");
+        kd.kernels[0].params.workGroups.global = dispatchData.gws;
+        kd.kernels[0].params.workGroups.local = dispatchData.lws;
+        kd.kernels[0].skip_execution = KernelData::SkipKernelExecution(prim_params);
+    };
+}
+
 KernelsData ActivationKernelBase::GetCommonKernelsData(const Params& params, const optional_params& options) const {
     if (!Validate(params, options)) {
         return {};
@@ -94,14 +105,7 @@ KernelsData ActivationKernelBase::GetCommonKernelsData(const Params& params, con
     auto entry_point = GetEntryPoint(kernelName, newParams.layerID, params, options);
     auto jit = CreateJit(kernelName, cldnn_jit, entry_point);
 
-    kd.update_dispatch_data_func = [this](const Params& params, KernelData& kd) {
-        const auto& prim_params = static_cast<const activation_params&>(params);
-        auto dispatchData = SetDefault(prim_params);
-        OPENVINO_ASSERT(kd.kernels.size() == 1, "[GPU] Invalid kernels size for update dispatch data func");
-        kd.kernels[0].params.workGroups.global = dispatchData.gws;
-        kd.kernels[0].params.workGroups.local = dispatchData.lws;
-        kd.kernels[0].skip_execution = KernelData::SkipKernelExecution(prim_params);
-    };
+    GetUpdateDispatchDataFunc(kd);
 
     auto& kernel = kd.kernels[0];
     FillCLKernelData(kernel, dispatchData, params.engineInfo, kernelName, jit, entry_point,
diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/activation/activation_kernel_base.h b/src/plugins/intel_gpu/src/kernel_selector/kernels/activation/activation_kernel_base.h
index 314b8f8ca95..b342224cb60 100644
--- a/src/plugins/intel_gpu/src/kernel_selector/kernels/activation/activation_kernel_base.h
+++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/activation/activation_kernel_base.h
@@ -57,5 +57,6 @@ protected:
     virtual JitConstants GetJitConstants(const activation_params& params, DispatchData dispatchData) const;
     virtual DispatchData SetDefault(const activation_params& arg) const;
     KernelsData GetCommonKernelsData(const Params& params, const optional_params& options) const;
+    void GetUpdateDispatchDataFunc(KernelData& kd) const override;
 };
 }  // namespace kernel_selector
diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/arg_max_min/arg_max_min_kernel_axis.cpp b/src/plugins/intel_gpu/src/kernel_selector/kernels/arg_max_min/arg_max_min_kernel_axis.cpp
index 45e02c753e4..2198aa85b81 100644
--- a/src/plugins/intel_gpu/src/kernel_selector/kernels/arg_max_min/arg_max_min_kernel_axis.cpp
+++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/arg_max_min/arg_max_min_kernel_axis.cpp
@@ -113,15 +113,7 @@ ArgMaxMinKernelBase::DispatchData ArgMaxMinKernelAxis::SetDefault(const arg_max_
     return dispatchData;
 }
 
-KernelsData ArgMaxMinKernelAxis::GetKernelsData(const Params& params, const optional_params& options) const {
-    if (!Validate(params, options)) {
-        return {};
-    }
-    const arg_max_min_params& orgParams = static_cast<const arg_max_min_params&>(params);
-    bool is_dynamic = orgParams.has_dynamic_tensors();
-
-    auto dispatchData = SetDefault(orgParams);
-    KernelData kd = KernelData::Default<arg_max_min_params>(params);
+void ArgMaxMinKernelAxis::GetUpdateDispatchDataFunc(KernelData& kd) const {
     kd.update_dispatch_data_func = [this](const Params& params, KernelData& kd) {
         const auto& prim_params = static_cast<const arg_max_min_params&>(params);
         auto dispatchData = SetDefault(prim_params);
@@ -143,6 +135,18 @@ KernelsData ArgMaxMinKernelAxis::GetKernelsData(const Params& params, const opti
         kd.internalBufferSizes.push_back(ops_size * elem_size);
         kd.internalBufferDataType = prim_params.inputs[0].GetDType();
     };
+}
+
+KernelsData ArgMaxMinKernelAxis::GetKernelsData(const Params& params, const optional_params& options) const {
+    if (!Validate(params, options)) {
+        return {};
+    }
+    const arg_max_min_params& orgParams = static_cast<const arg_max_min_params&>(params);
+    bool is_dynamic = orgParams.has_dynamic_tensors();
+
+    auto dispatchData = SetDefault(orgParams);
+    KernelData kd = KernelData::Default<arg_max_min_params>(params);
+    GetUpdateDispatchDataFunc(kd);
 
     auto cldnn_jit = GetJitConstants(orgParams);
     auto entry_point = GetEntryPoint(kernelName, orgParams.layerID, params, options);
diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/arg_max_min/arg_max_min_kernel_axis.h b/src/plugins/intel_gpu/src/kernel_selector/kernels/arg_max_min/arg_max_min_kernel_axis.h
index dd1afa41d1b..741fdf70b54 100644
--- a/src/plugins/intel_gpu/src/kernel_selector/kernels/arg_max_min/arg_max_min_kernel_axis.h
+++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/arg_max_min/arg_max_min_kernel_axis.h
@@ -19,5 +19,6 @@ public:
     ParamsKey GetSupportedKey() const override;
 private:
     bool Validate(const Params&, const optional_params&) const override;
+    void GetUpdateDispatchDataFunc(KernelData& kd) const override;
 };
 }  // namespace kernel_selector
diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/arg_max_min/arg_max_min_kernel_base.cpp b/src/plugins/intel_gpu/src/kernel_selector/kernels/arg_max_min/arg_max_min_kernel_base.cpp
index 976ef67d9ac..07c5f4e9be1 100644
--- a/src/plugins/intel_gpu/src/kernel_selector/kernels/arg_max_min/arg_max_min_kernel_base.cpp
+++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/arg_max_min/arg_max_min_kernel_base.cpp
@@ -40,6 +40,17 @@ ArgMaxMinKernelBase::DispatchData ArgMaxMinKernelBase::SetDefault(const arg_max_
     return dispatchData;
 }
 
+void ArgMaxMinKernelBase::GetUpdateDispatchDataFunc(KernelData& kd) const {
+    kd.update_dispatch_data_func = [this](const Params& params, KernelData& kd) {
+        const auto& prim_params = static_cast<const arg_max_min_params&>(params);
+        auto dispatchData = SetDefault(prim_params);
+        OPENVINO_ASSERT(kd.kernels.size() == 1, "[GPU] Invalid kernels size for update dispatch data func");
+        kd.kernels[0].params.workGroups.global = dispatchData.gws;
+        kd.kernels[0].params.workGroups.local = dispatchData.lws;
+        kd.kernels[0].skip_execution = KernelData::SkipKernelExecution(prim_params);
+    };
+}
+
 KernelsData ArgMaxMinKernelBase::GetCommonKernelsData(const Params& params, const optional_params& options) const {
     if (!Validate(params, options)) {
         return {};
@@ -50,14 +61,7 @@ KernelsData ArgMaxMinKernelBase::GetCommonKernelsData(const Params& params, cons
     DispatchData dispatchData = SetDefault(orgParams);
 
     KernelData kd = KernelData::Default<arg_max_min_params>(params);
-    kd.update_dispatch_data_func = [this](const Params& params, KernelData& kd) {
-        const auto& prim_params = static_cast<const arg_max_min_params&>(params);
-        auto dispatchData = SetDefault(prim_params);
-        OPENVINO_ASSERT(kd.kernels.size() == 1, "[GPU] Invalid kernels size for update dispatch data func");
-        kd.kernels[0].params.workGroups.global = dispatchData.gws;
-        kd.kernels[0].params.workGroups.local = dispatchData.lws;
-        kd.kernels[0].skip_execution = KernelData::SkipKernelExecution(prim_params);
-    };
+    GetUpdateDispatchDataFunc(kd);
 
     auto cldnn_jit = GetJitConstants(orgParams);
     auto entry_point = GetEntryPoint(kernelName, orgParams.layerID, params, options);
diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/arg_max_min/arg_max_min_kernel_base.h b/src/plugins/intel_gpu/src/kernel_selector/kernels/arg_max_min/arg_max_min_kernel_base.h
index 97423a75c7f..192f97b9e72 100644
--- a/src/plugins/intel_gpu/src/kernel_selector/kernels/arg_max_min/arg_max_min_kernel_base.h
+++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/arg_max_min/arg_max_min_kernel_base.h
@@ -55,5 +55,6 @@ protected:
     virtual JitConstants GetJitConstants(const arg_max_min_params& params) const;
     virtual DispatchData SetDefault(const arg_max_min_params& params) const;
     KernelsData GetCommonKernelsData(const Params& params, const optional_params&) const;
+    void GetUpdateDispatchDataFunc(KernelData& kd) const override;
 };
 }  // namespace kernel_selector
diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/border/border_kernel_base.cpp b/src/plugins/intel_gpu/src/kernel_selector/kernels/border/border_kernel_base.cpp
index 4f51946e6c0..2d8a12efc3c 100644
--- a/src/plugins/intel_gpu/src/kernel_selector/kernels/border/border_kernel_base.cpp
+++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/border/border_kernel_base.cpp
@@ -64,6 +64,17 @@ bool BorderKernelBase::SkipKernelExecution(const border_params& params) const {
     return params.outputs[0].LogicalSize() == 0;
 }
 
+void BorderKernelBase::GetUpdateDispatchDataFunc(KernelData& kd) const {
+    kd.update_dispatch_data_func = [this](const Params& params, KernelData& kd) {
+        const auto& prim_params = static_cast<const border_params&>(params);
+        auto dispatchData = SetDefault(prim_params);
+        OPENVINO_ASSERT(kd.kernels.size() == 1, "[GPU] Invalid kernels size for update dispatch data func");
+        kd.kernels[0].params.workGroups.global = dispatchData.gws;
+        kd.kernels[0].params.workGroups.local = dispatchData.lws;
+        kd.kernels[0].skip_execution = SkipKernelExecution(prim_params);
+    };
+}
+
 KernelsData BorderKernelBase::GetCommonKernelsData(const Params& params,
                                                    const optional_params& options) const {
     assert(params.GetType() == KernelType::BORDER);
@@ -73,14 +84,7 @@ KernelsData BorderKernelBase::GetCommonKernelsData(const Params& params,
 
     auto dispatchData = SetDefault(prim_params);
     KernelData k_data = KernelData::Default<border_params>(params);
-    k_data.update_dispatch_data_func = [this](const Params& params, KernelData& kd) {
-        const auto& prim_params = static_cast<const border_params&>(params);
-        auto dispatchData = SetDefault(prim_params);
-        OPENVINO_ASSERT(kd.kernels.size() == 1, "[GPU] Invalid kernels size for update dispatch data func");
-        kd.kernels[0].params.workGroups.global = dispatchData.gws;
-        kd.kernels[0].params.workGroups.local = dispatchData.lws;
-        kd.kernels[0].skip_execution = SkipKernelExecution(prim_params);
-    };
+    GetUpdateDispatchDataFunc(k_data);
 
     auto cldnn_jit = GetJitConstants(prim_params);
     auto entry_point = GetEntryPoint(kernelName, prim_params.layerID, params, options);
diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/border/border_kernel_base.h b/src/plugins/intel_gpu/src/kernel_selector/kernels/border/border_kernel_base.h
index 0fb98d9bc23..49e48be7fce 100644
--- a/src/plugins/intel_gpu/src/kernel_selector/kernels/border/border_kernel_base.h
+++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/border/border_kernel_base.h
@@ -55,5 +55,6 @@ protected:
     DispatchData SetDefault(const border_params& params) const;
     KernelsData GetCommonKernelsData(const Params& params, const optional_params&) const;
     bool SkipKernelExecution(const border_params& params) const;
+    void GetUpdateDispatchDataFunc(KernelData& kd) const override;
 };
 }  // namespace kernel_selector
diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/broadcast/broadcast_kernel_base.cpp b/src/plugins/intel_gpu/src/kernel_selector/kernels/broadcast/broadcast_kernel_base.cpp
index 858b6eeb8d5..49a0eda792e 100644
--- a/src/plugins/intel_gpu/src/kernel_selector/kernels/broadcast/broadcast_kernel_base.cpp
+++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/broadcast/broadcast_kernel_base.cpp
@@ -76,6 +76,17 @@ static std::string GetInputBlockND(const broadcast_params& params) {
     return str_result;
 }
 
+void BroadcastKernelBase::GetUpdateDispatchDataFunc(KernelData& kd) const {
+    kd.update_dispatch_data_func = [](const Params& params, KernelData& kd) {
+        const auto& prim_params = static_cast<const broadcast_params&>(params);
+        auto dispatchData = SetDefault(prim_params);
+        OPENVINO_ASSERT(kd.kernels.size() == 1, "[GPU] Invalid kernels size for update dispatch data func");
+        kd.kernels[0].params.workGroups.global = dispatchData.gws;
+        kd.kernels[0].params.workGroups.local = dispatchData.lws;
+        kd.kernels[0].skip_execution = KernelData::SkipKernelExecution(prim_params);
+    };
+}
+
 KernelsData BroadcastKernelBase::GetCommonKernelsData(const Params& params,
                                                       const optional_params& options) const {
     assert(params.GetType() == KernelType::BROADCAST);
@@ -84,15 +95,7 @@ KernelsData BroadcastKernelBase::GetCommonKernelsData(const Params& params,
 
     auto dispatchData = SetDefault(prim_params);
     KernelData k_data = KernelData::Default<broadcast_params>(params);
-
-    k_data.update_dispatch_data_func = [](const Params& params, KernelData& kd) {
-        const auto& prim_params = static_cast<const broadcast_params&>(params);
-        auto dispatchData = SetDefault(prim_params);
-        OPENVINO_ASSERT(kd.kernels.size() == 1, "[GPU] Invalid kernels size for update dispatch data func");
-        kd.kernels[0].params.workGroups.global = dispatchData.gws;
-        kd.kernels[0].params.workGroups.local = dispatchData.lws;
-        kd.kernels[0].skip_execution = KernelData::SkipKernelExecution(prim_params);
-    };
+    GetUpdateDispatchDataFunc(k_data);
 
     auto cldnn_jit = GetJitConstants(prim_params);
     cldnn_jit.AddConstant(MakeJitConstant("INPUT0_BLOCK_ND", GetInputBlockND(prim_params)));
diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/broadcast/broadcast_kernel_base.h b/src/plugins/intel_gpu/src/kernel_selector/kernels/broadcast/broadcast_kernel_base.h
index 0e9656a5bdf..723ce4f8ec5 100644
--- a/src/plugins/intel_gpu/src/kernel_selector/kernels/broadcast/broadcast_kernel_base.h
+++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/broadcast/broadcast_kernel_base.h
@@ -37,5 +37,6 @@ protected:
     JitConstants GetJitConstants(const broadcast_params& params) const;
     static DispatchData SetDefault(const broadcast_params& params);
     KernelsData GetCommonKernelsData(const Params& params, const optional_params&) const;
+    void GetUpdateDispatchDataFunc(KernelData& kd) const override;
 };
 }  // namespace kernel_selector
diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/concatenation/concatenation_kernel_base.cpp b/src/plugins/intel_gpu/src/kernel_selector/kernels/concatenation/concatenation_kernel_base.cpp
index 9bff04ad9ed..297476ea6c8 100644
--- a/src/plugins/intel_gpu/src/kernel_selector/kernels/concatenation/concatenation_kernel_base.cpp
+++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/concatenation/concatenation_kernel_base.cpp
@@ -100,14 +100,7 @@ ConcatenationKernelBase::DispatchData ConcatenationKernelBase::SetDefault(const
     return dispatchData;
 }
 
-KernelsData ConcatenationKernelBase::GetCommonKernelsData(const Params& params, const optional_params& options) const {
-    if (!Validate(params, options)) {
-        return {};
-    }
-
-    const concatenation_params& orgParams = static_cast<const concatenation_params&>(params);
-    KernelData kd = KernelData::Default<concatenation_params>(params, orgParams.inputs.size());
-
+void ConcatenationKernelBase::GetUpdateDispatchDataFunc(KernelData& kd) const {
     kd.update_dispatch_data_func = [this](const Params& params, KernelData& kd) {
         const auto& prim_params = static_cast<const concatenation_params&>(params);
         uint32_t lastOffset = 0;
@@ -139,6 +132,16 @@ KernelsData ConcatenationKernelBase::GetCommonKernelsData(const Params& params,
             lastOffset += (uint32_t)input.GetDims()[concatChannelIndex].v;
         }
     };
+}
+
+KernelsData ConcatenationKernelBase::GetCommonKernelsData(const Params& params, const optional_params& options) const {
+    if (!Validate(params, options)) {
+        return {};
+    }
+
+    const concatenation_params& orgParams = static_cast<const concatenation_params&>(params);
+    KernelData kd = KernelData::Default<concatenation_params>(params, orgParams.inputs.size());
+    GetUpdateDispatchDataFunc(kd);
 
     bool is_dynamic = orgParams.has_dynamic_tensors();
     uint32_t lastOffset = 0;
diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/concatenation/concatenation_kernel_base.h b/src/plugins/intel_gpu/src/kernel_selector/kernels/concatenation/concatenation_kernel_base.h
index 77511ea135f..f6b8e87ad5b 100644
--- a/src/plugins/intel_gpu/src/kernel_selector/kernels/concatenation/concatenation_kernel_base.h
+++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/concatenation/concatenation_kernel_base.h
@@ -68,5 +68,6 @@ protected:
     virtual size_t GetAlignment(const concatenation_params& /*params*/) const {
         return 1;
     }
+    void GetUpdateDispatchDataFunc(KernelData& kd) const override;
 };
 }  // namespace kernel_selector
diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/convolution/convolution_kernel_base.cpp b/src/plugins/intel_gpu/src/kernel_selector/kernels/convolution/convolution_kernel_base.cpp
index cabfe7d9288..7abd01ac9b3 100644
--- a/src/plugins/intel_gpu/src/kernel_selector/kernels/convolution/convolution_kernel_base.cpp
+++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/convolution/convolution_kernel_base.cpp
@@ -155,6 +155,21 @@ ConvolutionKernelBase::DispatchData ConvolutionKernelBase::SetDefault(const conv
     return dispatchData;
 }
 
+void ConvolutionKernelBase::GetUpdateDispatchDataFunc(KernelData& kd) const {
+    kd.update_dispatch_data_func = [this](const Params& params, KernelData& kd) {
+        const auto& prim_params = static_cast<const convolution_params&>(params);
+        auto dispatchData = SetDefault(prim_params);
+        OPENVINO_ASSERT(kd.kernels.size() == 1, "[GPU] Invalid kernels size for update dispatch data func");
+        kd.kernels[0].params.workGroups.global = dispatchData.gws;
+        kd.kernels[0].params.workGroups.local = dispatchData.lws;
+        kd.kernels[0].skip_execution = KernelData::SkipKernelExecution(prim_params);
+
+        kd.internalBufferSizes.clear();
+        kd.internalBufferSizes.push_back(prim_params.inputs[0].PhysicalSizeInBytes());
+        kd.internalBufferDataType = prim_params.inputs[0].GetDType();
+    };
+}
+
 KernelsData ConvolutionKernelBase::GetCommonKernelsData(const Params& params,
                                                         const optional_params& options,
                                                         const std::string exeMode,
@@ -206,18 +221,7 @@ KernelsData ConvolutionKernelBase::GetCommonKernelsData(const Params& params,
     auto entryPoint = GetEntryPoint(finalKernelName, newParams.layerID, params, options);
     auto jit = CreateJit(finalKernelName, cldnnJit, entryPoint);
 
-    kd.update_dispatch_data_func = [this](const Params& params, KernelData& kd) {
-        const auto& prim_params = static_cast<const convolution_params&>(params);
-        auto dispatchData = SetDefault(prim_params);
-        OPENVINO_ASSERT(kd.kernels.size() == 1, "[GPU] Invalid kernels size for update dispatch data func");
-        kd.kernels[0].params.workGroups.global = dispatchData.gws;
-        kd.kernels[0].params.workGroups.local = dispatchData.lws;
-        kd.kernels[0].skip_execution = KernelData::SkipKernelExecution(prim_params);
-
-        kd.internalBufferSizes.clear();
-        kd.internalBufferSizes.push_back(prim_params.inputs[0].PhysicalSizeInBytes());
-        kd.internalBufferDataType = prim_params.inputs[0].GetDType();
-    };
+    GetUpdateDispatchDataFunc(kd);
 
     auto& kernel = kd.kernels[0];
     FillCLKernelData(kernel,
diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/convolution/convolution_kernel_base.h b/src/plugins/intel_gpu/src/kernel_selector/kernels/convolution/convolution_kernel_base.h
index 30fe07c0068..91a728f34ca 100644
--- a/src/plugins/intel_gpu/src/kernel_selector/kernels/convolution/convolution_kernel_base.h
+++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/convolution/convolution_kernel_base.h
@@ -69,6 +69,7 @@ protected:
     Datatype GetPackedOutputType(const convolution_params& params) const;
     Datatype GetActivationType(const convolution_params& params) const;
     Datatype GetAccumulatorType(const convolution_params& params) const;
+    void GetUpdateDispatchDataFunc(KernelData& kd) const override;
 };
 
 bool ConvolutionCheckInput(const Params& p, const optional_params& o);
diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/cum_sum/cum_sum_kernel_base.cpp b/src/plugins/intel_gpu/src/kernel_selector/kernels/cum_sum/cum_sum_kernel_base.cpp
index 9eb52daaefb..9347eeaa8dc 100644
--- a/src/plugins/intel_gpu/src/kernel_selector/kernels/cum_sum/cum_sum_kernel_base.cpp
+++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/cum_sum/cum_sum_kernel_base.cpp
@@ -66,6 +66,17 @@ CumSumKernelBase::DispatchData CumSumKernelBase::SetDefault(const cum_sum_params
     return dispatchData;
 }
 
+void CumSumKernelBase::GetUpdateDispatchDataFunc(KernelData& kd) const {
+    kd.update_dispatch_data_func = [this](const Params& params, KernelData& kd) {
+        const auto& prim_params = static_cast<const cum_sum_params&>(params);
+        auto dispatchData = SetDefault(prim_params);
+        OPENVINO_ASSERT(kd.kernels.size() == 1, "[GPU] Invalid kernels size for update dispatch data func");
+        kd.kernels[0].params.workGroups.global = dispatchData.gws;
+        kd.kernels[0].params.workGroups.local = dispatchData.lws;
+        kd.kernels[0].skip_execution = KernelData::SkipKernelExecution(prim_params);
+    };
+}
+
 KernelsData CumSumKernelBase::GetCommonKernelsData(const Params& params,
                                                    const optional_params& options) const {
     KernelData kd = KernelData::Default<cum_sum_params>(params);
@@ -80,14 +91,7 @@ KernelsData CumSumKernelBase::GetCommonKernelsData(const Params& params,
     auto cldnn_jit = GetJitConstants(newParams, dispatchData);
     auto jit = CreateJit(kernelName, cldnn_jit, entry_point);
 
-    kd.update_dispatch_data_func = [this](const Params& params, KernelData& kd) {
-        const auto& prim_params = static_cast<const cum_sum_params&>(params);
-        auto dispatchData = SetDefault(prim_params);
-        OPENVINO_ASSERT(kd.kernels.size() == 1, "[GPU] Invalid kernels size for update dispatch data func");
-        kd.kernels[0].params.workGroups.global = dispatchData.gws;
-        kd.kernels[0].params.workGroups.local = dispatchData.lws;
-        kd.kernels[0].skip_execution = KernelData::SkipKernelExecution(prim_params);
-    };
+    GetUpdateDispatchDataFunc(kd);
 
     auto& kernel = kd.kernels[0];
 
diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/cum_sum/cum_sum_kernel_base.h b/src/plugins/intel_gpu/src/kernel_selector/kernels/cum_sum/cum_sum_kernel_base.h
index 42b1f59a640..81b4177ae29 100644
--- a/src/plugins/intel_gpu/src/kernel_selector/kernels/cum_sum/cum_sum_kernel_base.h
+++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/cum_sum/cum_sum_kernel_base.h
@@ -46,5 +46,6 @@ protected:
     KernelsData GetCommonKernelsData(const Params& params, const optional_params&) const;
     bool Validate(const Params&, const optional_params&) const override;
     Datatype GetActivationType(const cum_sum_params& params) const;
+    void GetUpdateDispatchDataFunc(KernelData& kd) const override;
 };
 }  // namespace kernel_selector
diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/eltwise/eltwise_kernel_base.cpp b/src/plugins/intel_gpu/src/kernel_selector/kernels/eltwise/eltwise_kernel_base.cpp
index b2977b633eb..d46e95f03f9 100644
--- a/src/plugins/intel_gpu/src/kernel_selector/kernels/eltwise/eltwise_kernel_base.cpp
+++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/eltwise/eltwise_kernel_base.cpp
@@ -724,6 +724,17 @@ EltwiseKernelBase::DispatchData EltwiseKernelBase::SetDefault(const eltwise_para
     return dispatchData;
 }
 
+void EltwiseKernelBase::GetUpdateDispatchDataFunc(KernelData& kd) const {
+    kd.update_dispatch_data_func = [this](const Params& params, KernelData& kd) {
+        const auto& prim_params = static_cast<const eltwise_params&>(params);
+        auto dispatchData = SetDefault(prim_params);
+        OPENVINO_ASSERT(kd.kernels.size() == 1, "[GPU] Invalid kernels size for update dispatch data func");
+        kd.kernels[0].params.workGroups.global = dispatchData.gws;
+        kd.kernels[0].params.workGroups.local = dispatchData.lws;
+        kd.kernels[0].skip_execution = KernelData::SkipKernelExecution(prim_params);
+    };
+}
+
 KernelsData EltwiseKernelBase::GetCommonKernelsData(const Params& params, const optional_params& options) const {
     if (!Validate(params, options)) {
         return {};
@@ -736,14 +747,7 @@ KernelsData EltwiseKernelBase::GetCommonKernelsData(const Params& params, const
     auto cldnn_jit = GetJitConstants(newParams);
     auto jit = CreateJit(kernelName, cldnn_jit, entry_point);
 
-    kd.update_dispatch_data_func = [this](const Params& params, KernelData& kd) {
-        const auto& prim_params = static_cast<const eltwise_params&>(params);
-        auto dispatchData = SetDefault(prim_params);
-        OPENVINO_ASSERT(kd.kernels.size() == 1, "[GPU] Invalid kernels size for update dispatch data func");
-        kd.kernels[0].params.workGroups.global = dispatchData.gws;
-        kd.kernels[0].params.workGroups.local = dispatchData.lws;
-        kd.kernels[0].skip_execution = KernelData::SkipKernelExecution(prim_params);
-    };
+    GetUpdateDispatchDataFunc(kd);
 
     DispatchData dispatchData = SetDefault(newParams);
 
diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/eltwise/eltwise_kernel_base.h b/src/plugins/intel_gpu/src/kernel_selector/kernels/eltwise/eltwise_kernel_base.h
index 9845f15ee7b..1c7af01ceb8 100644
--- a/src/plugins/intel_gpu/src/kernel_selector/kernels/eltwise/eltwise_kernel_base.h
+++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/eltwise/eltwise_kernel_base.h
@@ -120,5 +120,6 @@ protected:
     Datatype GetAccumulatorType(const eltwise_params &params) const;
 
     bool IsUnsupportedModeForVecCode(const eltwise_params& params) const;
+    void GetUpdateDispatchDataFunc(KernelData& kd) const override;
 };
 }  // namespace kernel_selector
diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/fully_connected/fully_connected_kernel_base.cpp b/src/plugins/intel_gpu/src/kernel_selector/kernels/fully_connected/fully_connected_kernel_base.cpp
index 2d88dd2f942..b6f60d58ad4 100644
--- a/src/plugins/intel_gpu/src/kernel_selector/kernels/fully_connected/fully_connected_kernel_base.cpp
+++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/fully_connected/fully_connected_kernel_base.cpp
@@ -71,6 +71,17 @@ FullyConnectedKernelBase::DispatchData FullyConnectedKernelBase::SetDefault(cons
     return dispatchData;
 }
 
+void FullyConnectedKernelBase::GetUpdateDispatchDataFunc(KernelData& kd) const {
+    kd.update_dispatch_data_func = [this](const Params& params, KernelData& kd) {
+        const auto& prim_params = static_cast<const fully_connected_params&>(params);
+        auto dispatchData = SetDefault(prim_params);
+        OPENVINO_ASSERT(kd.kernels.size() == 1, "[GPU] Invalid kernels size for update dispatch data func");
+        kd.kernels[0].params.workGroups.global = dispatchData.gws;
+        kd.kernels[0].params.workGroups.local = dispatchData.lws;
+        kd.kernels[0].skip_execution = KernelData::SkipKernelExecution(prim_params);
+    };
+}
+
 KernelsData FullyConnectedKernelBase::GetCommonKernelsData(const Params &params,
                                                            const optional_params &options,
                                                            DataLayout dl,
@@ -90,14 +101,7 @@ KernelsData FullyConnectedKernelBase::GetCommonKernelsData(const Params &params,
     }
 
     KernelData kd = KernelData::Default<fully_connected_params>(params);
-    kd.update_dispatch_data_func = [this](const Params& params, KernelData& kd) {
-        const auto& prim_params = static_cast<const fully_connected_params&>(params);
-        auto dispatchData = SetDefault(prim_params);
-        OPENVINO_ASSERT(kd.kernels.size() == 1, "[GPU] Invalid kernels size for update dispatch data func");
-        kd.kernels[0].params.workGroups.global = dispatchData.gws;
-        kd.kernels[0].params.workGroups.local = dispatchData.lws;
-        kd.kernels[0].skip_execution = KernelData::SkipKernelExecution(prim_params);
-    };
+    GetUpdateDispatchDataFunc(kd);
     fully_connected_params& newParams = *static_cast<fully_connected_params*>(kd.params.get());
 
     if (!bProperInput) {
diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/fully_connected/fully_connected_kernel_base.h b/src/plugins/intel_gpu/src/kernel_selector/kernels/fully_connected/fully_connected_kernel_base.h
index 11876a52e16..0eb94cd61ee 100644
--- a/src/plugins/intel_gpu/src/kernel_selector/kernels/fully_connected/fully_connected_kernel_base.h
+++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/fully_connected/fully_connected_kernel_base.h
@@ -69,5 +69,6 @@ protected:
     // --Fused ops
 
     bool Validate(const Params& p, const optional_params&) const override;
+    void GetUpdateDispatchDataFunc(KernelData& kd) const override;
 };
 }  // namespace kernel_selector
diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/gather/gather_elements_kernel_ref.cpp b/src/plugins/intel_gpu/src/kernel_selector/kernels/gather/gather_elements_kernel_ref.cpp
index 0c987987074..6ec1a61e4bd 100644
--- a/src/plugins/intel_gpu/src/kernel_selector/kernels/gather/gather_elements_kernel_ref.cpp
+++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/gather/gather_elements_kernel_ref.cpp
@@ -150,6 +150,17 @@ bool GatherElementsKernelRef::Validate(const Params& p, const optional_params& o
     return true;
 }
 
+void GatherElementsKernelRef::GetUpdateDispatchDataFunc(KernelData& kd) const {
+    kd.update_dispatch_data_func = [this](const Params& params, KernelData& kd) {
+        const auto& prim_params = static_cast<const gather_elements_params&>(params);
+        auto dispatchData = SetDefault(prim_params);
+        OPENVINO_ASSERT(kd.kernels.size() == 1, "[GPU] Invalid kernels size for update dispatch data func");
+        kd.kernels[0].params.workGroups.global = dispatchData.gws;
+        kd.kernels[0].params.workGroups.local = dispatchData.lws;
+        kd.kernels[0].skip_execution = KernelData::SkipKernelExecution(prim_params);
+    };
+}
+
 KernelsData GatherElementsKernelRef::GetKernelsData(const Params& params, const optional_params& options) const {
     if (!Validate(params, options)) {
         return {};
@@ -163,14 +174,7 @@ KernelsData GatherElementsKernelRef::GetKernelsData(const Params& params, const
     auto entry_point = GetEntryPoint(kernelName, newParams.layerID, params, options);
     auto jit = CreateJit(kernelName, cldnn_jit, entry_point);
 
-    kd.update_dispatch_data_func = [this](const Params& params, KernelData& kd) {
-        const auto& prim_params = static_cast<const gather_elements_params&>(params);
-        auto dispatchData = SetDefault(prim_params);
-        OPENVINO_ASSERT(kd.kernels.size() == 1, "[GPU] Invalid kernels size for update dispatch data func");
-        kd.kernels[0].params.workGroups.global = dispatchData.gws;
-        kd.kernels[0].params.workGroups.local = dispatchData.lws;
-        kd.kernels[0].skip_execution = KernelData::SkipKernelExecution(prim_params);
-    };
+    GetUpdateDispatchDataFunc(kd);
 
     auto& kernel = kd.kernels[0];
     FillCLKernelData(kernel, dispatchData, params.engineInfo, kernelName, jit, entry_point,
diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/gather/gather_elements_kernel_ref.h b/src/plugins/intel_gpu/src/kernel_selector/kernels/gather/gather_elements_kernel_ref.h
index 82566fb253f..f273e109b84 100644
--- a/src/plugins/intel_gpu/src/kernel_selector/kernels/gather/gather_elements_kernel_ref.h
+++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/gather/gather_elements_kernel_ref.h
@@ -40,5 +40,6 @@ public:
 
 protected:
     bool Validate(const Params& p, const optional_params& o) const override;
+    void GetUpdateDispatchDataFunc(KernelData& kd) const override;
 };
 }  // namespace kernel_selector
diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/gather/gather_kernel_ref.cpp b/src/plugins/intel_gpu/src/kernel_selector/kernels/gather/gather_kernel_ref.cpp
index 538c4fcfb4e..94671ec79e7 100644
--- a/src/plugins/intel_gpu/src/kernel_selector/kernels/gather/gather_kernel_ref.cpp
+++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/gather/gather_kernel_ref.cpp
@@ -293,6 +293,17 @@ bool GatherKernelRef::Validate(const Params& p, const optional_params& o) const
     return true;
 }
 
+void GatherKernelRef::GetUpdateDispatchDataFunc(KernelData& kd) const {
+    kd.update_dispatch_data_func = [this](const Params& params, KernelData& kd) {
+        const auto& prim_params = static_cast<const gather_params&>(params);
+        auto dispatchData = SetDefault(prim_params);
+        OPENVINO_ASSERT(kd.kernels.size() == 1, "[GPU] Invalid kernels size for update dispatch data func");
+        kd.kernels[0].params.workGroups.global = dispatchData.gws;
+        kd.kernels[0].params.workGroups.local = dispatchData.lws;
+        kd.kernels[0].skip_execution = KernelData::SkipKernelExecution(prim_params);
+    };
+}
+
 KernelsData GatherKernelRef::GetKernelsData(const Params& params, const optional_params& options) const {
     if (!Validate(params, options)) {
         return {};
@@ -308,14 +319,7 @@ KernelsData GatherKernelRef::GetKernelsData(const Params& params, const optional
 
     auto& kernel = kd.kernels[0];
 
-    kd.update_dispatch_data_func = [this](const Params& params, KernelData& kd) {
-        const auto& prim_params = static_cast<const gather_params&>(params);
-        auto dispatchData = SetDefault(prim_params);
-        OPENVINO_ASSERT(kd.kernels.size() == 1, "[GPU] Invalid kernels size for update dispatch data func");
-        kd.kernels[0].params.workGroups.global = dispatchData.gws;
-        kd.kernels[0].params.workGroups.local = dispatchData.lws;
-        kd.kernels[0].skip_execution = KernelData::SkipKernelExecution(prim_params);
-    };
+    GetUpdateDispatchDataFunc(kd);
 
     FillCLKernelData(kernel,
                      dispatchData,
diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/gather/gather_kernel_ref.h b/src/plugins/intel_gpu/src/kernel_selector/kernels/gather/gather_kernel_ref.h
index ded452a7ab5..09975466b9c 100644
--- a/src/plugins/intel_gpu/src/kernel_selector/kernels/gather/gather_kernel_ref.h
+++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/gather/gather_kernel_ref.h
@@ -42,5 +42,6 @@ public:
 
 protected:
     bool Validate(const Params& p, const optional_params& o) const override;
+    void GetUpdateDispatchDataFunc(KernelData& kd) const override;
 };
 }  // namespace kernel_selector
diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/gather/gather_nd_kernel_ref.cpp b/src/plugins/intel_gpu/src/kernel_selector/kernels/gather/gather_nd_kernel_ref.cpp
index 0ff332b5c29..681d5fadf9c 100644
--- a/src/plugins/intel_gpu/src/kernel_selector/kernels/gather/gather_nd_kernel_ref.cpp
+++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/gather/gather_nd_kernel_ref.cpp
@@ -172,6 +172,17 @@ bool GatherNDKernelRef::Validate(const Params& p, const optional_params& o) cons
     return true;
 }
 
+void GatherNDKernelRef::GetUpdateDispatchDataFunc(KernelData& kd) const {
+    kd.update_dispatch_data_func = [this](const Params& params, KernelData& kd) {
+        const auto& prim_params = static_cast<const gather_nd_params&>(params);
+        auto dispatchData = SetDefault(prim_params);
+        OPENVINO_ASSERT(kd.kernels.size() == 1, "[GPU] Invalid kernels size for update dispatch data func");
+        kd.kernels[0].params.workGroups.global = dispatchData.gws;
+        kd.kernels[0].params.workGroups.local = dispatchData.lws;
+        kd.kernels[0].skip_execution = KernelData::SkipKernelExecution(prim_params);
+    };
+}
+
 KernelsData GatherNDKernelRef::GetKernelsData(const Params& params, const optional_params& options) const {
     if (!Validate(params, options)) {
         return {};
@@ -187,14 +198,7 @@ KernelsData GatherNDKernelRef::GetKernelsData(const Params& params, const option
     auto jit = CreateJit(kernelName, cldnn_jit, entry_point);
     auto& kernel = kd.kernels[0];
 
-    kd.update_dispatch_data_func = [this](const Params& params, KernelData& kd) {
-        const auto& prim_params = static_cast<const gather_nd_params&>(params);
-        auto dispatchData = SetDefault(prim_params);
-        OPENVINO_ASSERT(kd.kernels.size() == 1, "[GPU] Invalid kernels size for update dispatch data func");
-        kd.kernels[0].params.workGroups.global = dispatchData.gws;
-        kd.kernels[0].params.workGroups.local = dispatchData.lws;
-        kd.kernels[0].skip_execution = KernelData::SkipKernelExecution(prim_params);
-    };
+    GetUpdateDispatchDataFunc(kd);
 
     FillCLKernelData(kernel,
                      dispatchData,
diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/gather/gather_nd_kernel_ref.h b/src/plugins/intel_gpu/src/kernel_selector/kernels/gather/gather_nd_kernel_ref.h
index a9c944c0fc7..a07d040a4bd 100644
--- a/src/plugins/intel_gpu/src/kernel_selector/kernels/gather/gather_nd_kernel_ref.h
+++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/gather/gather_nd_kernel_ref.h
@@ -43,5 +43,6 @@ public:
 
 protected:
     bool Validate(const Params& p, const optional_params& o) const override;
+    void GetUpdateDispatchDataFunc(KernelData& kd) const override;
 };
 }  // namespace kernel_selector
diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/gemm/gemm_kernel_base.cpp b/src/plugins/intel_gpu/src/kernel_selector/kernels/gemm/gemm_kernel_base.cpp
index 205207ecb57..35d0c002e8c 100644
--- a/src/plugins/intel_gpu/src/kernel_selector/kernels/gemm/gemm_kernel_base.cpp
+++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/gemm/gemm_kernel_base.cpp
@@ -35,6 +35,17 @@ GemmKernelBase::DispatchData GemmKernelBase::SetDefault(const gemm_params& param
     return dispatchData;
 }
 
+void GemmKernelBase::GetUpdateDispatchDataFunc(KernelData& kd) const {
+    kd.update_dispatch_data_func = [this](const Params& params, KernelData& kd) {
+        const auto& prim_params = static_cast<const gemm_params&>(params);
+            auto dispatchData = SetDefault(prim_params);
+            OPENVINO_ASSERT(kd.kernels.size() == 1, "[GPU] Invalid kernels size for update dispatch data func");
+            kd.kernels[0].params.workGroups.global = dispatchData.gws;
+            kd.kernels[0].params.workGroups.local = dispatchData.lws;
+            kd.kernels[0].skip_execution = KernelData::SkipKernelExecution(prim_params);
+    };
+}
+
 KernelsData GemmKernelBase::GetCommonKernelsData(const Params& params,
                                                  const optional_params& options) const {
     if (!Validate(params, options)) {
@@ -45,14 +56,7 @@ KernelsData GemmKernelBase::GetCommonKernelsData(const Params& params,
 
     auto dispatchData = SetDefault(prim_params);
     KernelData k_data = KernelData::Default<gemm_params>(params);
-    k_data.update_dispatch_data_func = [this](const Params& params, KernelData& kd) {
-    const auto& prim_params = static_cast<const gemm_params&>(params);
-        auto dispatchData = SetDefault(prim_params);
-        OPENVINO_ASSERT(kd.kernels.size() == 1, "[GPU] Invalid kernels size for update dispatch data func");
-        kd.kernels[0].params.workGroups.global = dispatchData.gws;
-        kd.kernels[0].params.workGroups.local = dispatchData.lws;
-        kd.kernels[0].skip_execution = KernelData::SkipKernelExecution(prim_params);
-    };
+    GetUpdateDispatchDataFunc(k_data);
     auto cldnn_jit = GetJitConstants(prim_params);
     auto entry_point = GetEntryPoint(kernelName, prim_params.layerID, params, options);
     auto jit = CreateJit(kernelName, cldnn_jit, entry_point);
diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/gemm/gemm_kernel_base.h b/src/plugins/intel_gpu/src/kernel_selector/kernels/gemm/gemm_kernel_base.h
index eddcb427ad4..28032fb1ac5 100644
--- a/src/plugins/intel_gpu/src/kernel_selector/kernels/gemm/gemm_kernel_base.h
+++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/gemm/gemm_kernel_base.h
@@ -54,5 +54,6 @@ protected:
     Datatype GetActivationType(const gemm_params& params) const;
     // --Fused ops
     bool Validate(const Params& p, const optional_params&) const override;
+    void GetUpdateDispatchDataFunc(KernelData& kd) const override;
 };
 }  // namespace kernel_selector
diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/mvn/mvn_kernel_base.cpp b/src/plugins/intel_gpu/src/kernel_selector/kernels/mvn/mvn_kernel_base.cpp
index 50a9d6feb67..d18ed88e426 100644
--- a/src/plugins/intel_gpu/src/kernel_selector/kernels/mvn/mvn_kernel_base.cpp
+++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/mvn/mvn_kernel_base.cpp
@@ -47,6 +47,17 @@ MVNKernelBase::DispatchData MVNKernelBase::SetDefault(const mvn_params& params)
     return dispatchData;
 }
 
+void MVNKernelBase::GetUpdateDispatchDataFunc(KernelData& kd) const {
+    kd.update_dispatch_data_func = [this](const Params& params, KernelData& kd) {
+        const auto& prim_params = static_cast<const mvn_params&>(params);
+        auto dispatchData = SetDefault(prim_params);
+        OPENVINO_ASSERT(kd.kernels.size() == 1, "[GPU] Invalid kernels size for update dispatch data func");
+        kd.kernels[0].params.workGroups.global = dispatchData.gws;
+        kd.kernels[0].params.workGroups.local = dispatchData.lws;
+        kd.kernels[0].skip_execution = KernelData::SkipKernelExecution(prim_params);
+    };
+}
+
 KernelsData MVNKernelBase::GetCommonKernelsData(const Params& params,
                                                 const optional_params& options) const {
     assert(params.GetType() == KernelType::MVN);
@@ -65,14 +76,7 @@ KernelsData MVNKernelBase::GetCommonKernelsData(const Params& params,
     auto entry_point = GetEntryPoint(finalKernelName, orgParams.layerID, params, options);
     auto jit = CreateJit(finalKernelName, cldnn_jit, entry_point);
 
-    kd.update_dispatch_data_func = [this](const Params& params, KernelData& kd) {
-        const auto& prim_params = static_cast<const mvn_params&>(params);
-        auto dispatchData = SetDefault(prim_params);
-        OPENVINO_ASSERT(kd.kernels.size() == 1, "[GPU] Invalid kernels size for update dispatch data func");
-        kd.kernels[0].params.workGroups.global = dispatchData.gws;
-        kd.kernels[0].params.workGroups.local = dispatchData.lws;
-        kd.kernels[0].skip_execution = KernelData::SkipKernelExecution(prim_params);
-    };
+    GetUpdateDispatchDataFunc(kd);
 
     auto& kernel = kd.kernels[0];
     FillCLKernelData(kernel,
diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/mvn/mvn_kernel_base.h b/src/plugins/intel_gpu/src/kernel_selector/kernels/mvn/mvn_kernel_base.h
index 47ab5f10fe2..529f3513d40 100644
--- a/src/plugins/intel_gpu/src/kernel_selector/kernels/mvn/mvn_kernel_base.h
+++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/mvn/mvn_kernel_base.h
@@ -64,5 +64,6 @@ protected:
     virtual std::string GetKernelName(const mvn_params&) const { return kernelName; }
     KernelsData GetCommonKernelsData(const Params& params, const optional_params&) const;
     Datatype GetActivationType(const mvn_params& params) const;
+    void GetUpdateDispatchDataFunc(KernelData& kd) const override;
 };
 }  // namespace kernel_selector
diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/non_zero/count_nonzero_kernel_ref.cpp b/src/plugins/intel_gpu/src/kernel_selector/kernels/non_zero/count_nonzero_kernel_ref.cpp
index e64fa3dffd3..ebbe6a524c1 100644
--- a/src/plugins/intel_gpu/src/kernel_selector/kernels/non_zero/count_nonzero_kernel_ref.cpp
+++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/non_zero/count_nonzero_kernel_ref.cpp
@@ -54,6 +54,17 @@ DeviceFeaturesKey CountNonzeroKernelRef::get_required_device_features_key(const
     return k;
 }
 
+void CountNonzeroKernelRef::GetUpdateDispatchDataFunc(KernelData& kd) const {
+    kd.update_dispatch_data_func = [this](const Params& params, KernelData& kd) {
+        const auto& prim_params = static_cast<const count_nonzero_params&>(params);
+        auto dispatchData = SetDefault(prim_params);
+        OPENVINO_ASSERT(kd.kernels.size() == 1, "[GPU] Invalid kernels size for update dispatch data func");
+        kd.kernels[0].params.workGroups.global = dispatchData.gws;
+        kd.kernels[0].params.workGroups.local = dispatchData.lws;
+        kd.kernels[0].skip_execution = KernelData::SkipKernelExecution(prim_params);
+    };
+}
+
 KernelsData CountNonzeroKernelRef::GetKernelsData(const Params& params, const optional_params& options) const {
     assert(params.GetType() == KernelType::COUNT_NONZERO);
 
@@ -75,14 +86,7 @@ KernelsData CountNonzeroKernelRef::GetKernelsData(const Params& params, const op
 
     auto& kernel = kd.kernels[0];
 
-    kd.update_dispatch_data_func = [this](const Params& params, KernelData& kd) {
-        const auto& prim_params = static_cast<const count_nonzero_params&>(params);
-        auto dispatchData = SetDefault(prim_params);
-        OPENVINO_ASSERT(kd.kernels.size() == 1, "[GPU] Invalid kernels size for update dispatch data func");
-        kd.kernels[0].params.workGroups.global = dispatchData.gws;
-        kd.kernels[0].params.workGroups.local = dispatchData.lws;
-        kd.kernels[0].skip_execution = KernelData::SkipKernelExecution(prim_params);
-    };
+    GetUpdateDispatchDataFunc(kd);
 
     // In case of count-nonzero, the output shape is static unconditionally,
     // so it should be checked as dynamic of the input shape
diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/non_zero/count_nonzero_kernel_ref.h b/src/plugins/intel_gpu/src/kernel_selector/kernels/non_zero/count_nonzero_kernel_ref.h
index 01fb042fd39..c941c2860be 100644
--- a/src/plugins/intel_gpu/src/kernel_selector/kernels/non_zero/count_nonzero_kernel_ref.h
+++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/non_zero/count_nonzero_kernel_ref.h
@@ -40,5 +40,6 @@ public:
 
 protected:
     bool Validate(const Params& p, const optional_params& op) const override;
+    void GetUpdateDispatchDataFunc(KernelData& kd) const override;
 };
 }  // namespace kernel_selector
diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/non_zero/gather_nonzero_kernel_ref.cpp b/src/plugins/intel_gpu/src/kernel_selector/kernels/non_zero/gather_nonzero_kernel_ref.cpp
index b5530d03705..69636f8a76a 100644
--- a/src/plugins/intel_gpu/src/kernel_selector/kernels/non_zero/gather_nonzero_kernel_ref.cpp
+++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/non_zero/gather_nonzero_kernel_ref.cpp
@@ -67,6 +67,17 @@ CommonDispatchData GatherNonzeroKernelRef::SetDefault(const gather_nonzero_param
     return dispatchData;
 }
 
+void GatherNonzeroKernelRef::GetUpdateDispatchDataFunc(KernelData& kd) const {
+    kd.update_dispatch_data_func = [this](const Params& params, KernelData& kd) {
+        const auto& prim_params = static_cast<const gather_nonzero_params&>(params);
+        auto dispatchData = SetDefault(prim_params);
+        OPENVINO_ASSERT(kd.kernels.size() == 1, "[GPU] Invalid kernels size for update dispatch data func");
+        kd.kernels[0].params.workGroups.global = dispatchData.gws;
+        kd.kernels[0].params.workGroups.local = dispatchData.lws;
+        kd.kernels[0].skip_execution = KernelData::SkipKernelExecution(prim_params);
+    };
+}
+
 KernelsData GatherNonzeroKernelRef::GetKernelsData(const Params& params, const optional_params& options) const {
     assert(params.GetType() == KernelType::GATHER_NONZERO);
 
@@ -80,14 +91,7 @@ KernelsData GatherNonzeroKernelRef::GetKernelsData(const Params& params, const o
 
     auto& kernel = kd.kernels[0];
 
-    kd.update_dispatch_data_func = [this](const Params& params, KernelData& kd) {
-        const auto& prim_params = static_cast<const gather_nonzero_params&>(params);
-        auto dispatchData = SetDefault(prim_params);
-        OPENVINO_ASSERT(kd.kernels.size() == 1, "[GPU] Invalid kernels size for update dispatch data func");
-        kd.kernels[0].params.workGroups.global = dispatchData.gws;
-        kd.kernels[0].params.workGroups.local = dispatchData.lws;
-        kd.kernels[0].skip_execution = KernelData::SkipKernelExecution(prim_params);
-    };
+    GetUpdateDispatchDataFunc(kd);
 
     FillCLKernelData(kernel,
                      dispatchData,
diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/non_zero/gather_nonzero_kernel_ref.h b/src/plugins/intel_gpu/src/kernel_selector/kernels/non_zero/gather_nonzero_kernel_ref.h
index 30eeb4330b8..04f45d16d7b 100644
--- a/src/plugins/intel_gpu/src/kernel_selector/kernels/non_zero/gather_nonzero_kernel_ref.h
+++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/non_zero/gather_nonzero_kernel_ref.h
@@ -35,5 +35,6 @@ public:
 
 protected:
     bool Validate(const Params& p, const optional_params& op) const override;
+    void GetUpdateDispatchDataFunc(KernelData& kd) const override;
 };
 }  // namespace kernel_selector
diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/permute/permute_kernel_base.cpp b/src/plugins/intel_gpu/src/kernel_selector/kernels/permute/permute_kernel_base.cpp
index 00045210d65..fa0e29b60b4 100644
--- a/src/plugins/intel_gpu/src/kernel_selector/kernels/permute/permute_kernel_base.cpp
+++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/permute/permute_kernel_base.cpp
@@ -30,6 +30,17 @@ JitConstants PermuteKernelBase::GetJitConstants(const permute_params& params, co
     return jit;
 }
 
+void PermuteKernelBase::GetUpdateDispatchDataFunc(KernelData& kd) const {
+    kd.update_dispatch_data_func = [this](const Params& params, KernelData& kernel_data) {
+        const auto& prim_params = static_cast<const permute_params&>(params);
+        auto dispatchData = SetDefault(prim_params);
+        OPENVINO_ASSERT(kernel_data.kernels.size() == 1, "[GPU] Invalid kernels size for update dispatch data func");
+        kernel_data.kernels[0].params.workGroups.global = dispatchData.gws;
+        kernel_data.kernels[0].params.workGroups.local = dispatchData.lws;
+        kernel_data.kernels[0].skip_execution = KernelData::SkipKernelExecution(prim_params);
+    };
+}
+
 KernelsData PermuteKernelBase::GetKernelsData(const Params& params, const optional_params& options) const {
     if (!Validate(params, options)) {
         return {};
@@ -41,14 +52,7 @@ KernelsData PermuteKernelBase::GetKernelsData(const Params& params, const option
     auto dispatchData = SetDefault(newParams);
     auto cldnn_jit = GetJitConstants(newParams, dispatchData);
 
-    kd.update_dispatch_data_func = [this](const Params& params, KernelData& kernel_data) {
-        const auto& prim_params = static_cast<const permute_params&>(params);
-        auto dispatchData = SetDefault(prim_params);
-        OPENVINO_ASSERT(kernel_data.kernels.size() == 1, "[GPU] Invalid kernels size for update dispatch data func");
-        kernel_data.kernels[0].params.workGroups.global = dispatchData.gws;
-        kernel_data.kernels[0].params.workGroups.local = dispatchData.lws;
-        kernel_data.kernels[0].skip_execution = KernelData::SkipKernelExecution(prim_params);
-    };
+    GetUpdateDispatchDataFunc(kd);
 
     auto entry_point = GetEntryPoint(kernelName, newParams.layerID, params, options);
     std::pair<std::string, std::string> jit = CreateJit(kernelName, cldnn_jit, entry_point);
diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/permute/permute_kernel_base.h b/src/plugins/intel_gpu/src/kernel_selector/kernels/permute/permute_kernel_base.h
index 07952738434..dfec706aaef 100644
--- a/src/plugins/intel_gpu/src/kernel_selector/kernels/permute/permute_kernel_base.h
+++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/permute/permute_kernel_base.h
@@ -19,5 +19,6 @@ public:
 protected:
     virtual JitConstants GetJitConstants(const permute_params& params, const CommonDispatchData& dispatchData) const;
     virtual CommonDispatchData SetDefault(const permute_params& params) const = 0;
+    void GetUpdateDispatchDataFunc(KernelData& kd) const override;
 };
 }  // namespace kernel_selector
diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/quantize/quantize_kernel_base.cpp b/src/plugins/intel_gpu/src/kernel_selector/kernels/quantize/quantize_kernel_base.cpp
index da10f037941..cea90856076 100644
--- a/src/plugins/intel_gpu/src/kernel_selector/kernels/quantize/quantize_kernel_base.cpp
+++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/quantize/quantize_kernel_base.cpp
@@ -29,6 +29,17 @@ JitConstants QuantizeKernelBase::GetJitConstants(const quantize_params& params,
     return jit;
 }
 
+void QuantizeKernelBase::GetUpdateDispatchDataFunc(KernelData& kd) const {
+    kd.update_dispatch_data_func = [this](const Params& params, KernelData& kd) {
+        const auto& prim_params = static_cast<const quantize_params&>(params);
+        auto dispatchData = SetDefault(prim_params);
+        OPENVINO_ASSERT(kd.kernels.size() == 1, "[GPU] Invalid kernels size for update dispatch data func");
+        kd.kernels[0].params.workGroups.global = dispatchData.gws;
+        kd.kernels[0].params.workGroups.local = dispatchData.lws;
+        kd.kernels[0].skip_execution = KernelData::SkipKernelExecution(prim_params);
+    };
+}
+
 KernelsData QuantizeKernelBase::GetKernelsData(const Params& params, const optional_params& options) const {
     assert(params.GetType() == KernelType::QUANTIZE);
 
@@ -44,14 +55,7 @@ KernelsData QuantizeKernelBase::GetKernelsData(const Params& params, const optio
     auto cldnn_jit = GetJitConstants(newParams, dispatchData);
     auto jit = CreateJit(kernelName, cldnn_jit, entry_point);
 
-    kd.update_dispatch_data_func = [this](const Params& params, KernelData& kd) {
-        const auto& prim_params = static_cast<const quantize_params&>(params);
-        auto dispatchData = SetDefault(prim_params);
-        OPENVINO_ASSERT(kd.kernels.size() == 1, "[GPU] Invalid kernels size for update dispatch data func");
-        kd.kernels[0].params.workGroups.global = dispatchData.gws;
-        kd.kernels[0].params.workGroups.local = dispatchData.lws;
-        kd.kernels[0].skip_execution = KernelData::SkipKernelExecution(prim_params);
-    };
+    GetUpdateDispatchDataFunc(kd);
 
     auto& kernel = kd.kernels[0];
 
diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/quantize/quantize_kernel_base.h b/src/plugins/intel_gpu/src/kernel_selector/kernels/quantize/quantize_kernel_base.h
index 93bb971b519..5c4eb0b5538 100644
--- a/src/plugins/intel_gpu/src/kernel_selector/kernels/quantize/quantize_kernel_base.h
+++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/quantize/quantize_kernel_base.h
@@ -20,5 +20,6 @@ public:
 protected:
     virtual JitConstants GetJitConstants(const quantize_params& params, const CommonDispatchData& dispatchData) const;
     virtual CommonDispatchData SetDefault(const quantize_params& params) const = 0;
+    void GetUpdateDispatchDataFunc(KernelData& kd) const override;
 };
 }  // namespace kernel_selector
diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/range/range_kernel_ref.cpp b/src/plugins/intel_gpu/src/kernel_selector/kernels/range/range_kernel_ref.cpp
index 70afd02cbcb..5b109a7d994 100644
--- a/src/plugins/intel_gpu/src/kernel_selector/kernels/range/range_kernel_ref.cpp
+++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/range/range_kernel_ref.cpp
@@ -22,6 +22,17 @@ CommonDispatchData SetDefault(const range_params &params) {
 
 }  // namespace
 
+void RangeKernelRef::GetUpdateDispatchDataFunc(KernelData& kd) const {
+    kd.update_dispatch_data_func = [](const Params& params, KernelData& kd) {
+        const auto& prim_params = static_cast<const range_params&>(params);
+        auto dispatchData = SetDefault(prim_params);
+        OPENVINO_ASSERT(kd.kernels.size() == 1, "[GPU] Invalid kernels size for update dispatch data func");
+        kd.kernels[0].params.workGroups.global = dispatchData.gws;
+        kd.kernels[0].params.workGroups.local = dispatchData.lws;
+        kd.kernels[0].skip_execution = KernelData::SkipKernelExecution(prim_params);
+    };
+}
+
 KernelsData RangeKernelRef::GetKernelsData(const Params &params, const optional_params &options) const {
     if (!Validate(params, options))
         return {};
@@ -34,14 +45,7 @@ KernelsData RangeKernelRef::GetKernelsData(const Params &params, const optional_
     auto jit_constants = MakeBaseParamsJitConstants(prim_params);
     auto jit = CreateJit(kernelName, jit_constants, entry_point);
 
-    kernel_data.update_dispatch_data_func = [](const Params& params, KernelData& kd) {
-        const auto& prim_params = static_cast<const range_params&>(params);
-        auto dispatchData = SetDefault(prim_params);
-        OPENVINO_ASSERT(kd.kernels.size() == 1, "[GPU] Invalid kernels size for update dispatch data func");
-        kd.kernels[0].params.workGroups.global = dispatchData.gws;
-        kd.kernels[0].params.workGroups.local = dispatchData.lws;
-        kd.kernels[0].skip_execution = KernelData::SkipKernelExecution(prim_params);
-    };
+    GetUpdateDispatchDataFunc(kernel_data);
 
     auto &clKernelData = kernel_data.kernels[0];
     bool is_dynamic = prim_params.has_dynamic_tensors();
diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/range/range_kernel_ref.h b/src/plugins/intel_gpu/src/kernel_selector/kernels/range/range_kernel_ref.h
index 762bdfc5216..1dbb2f303df 100644
--- a/src/plugins/intel_gpu/src/kernel_selector/kernels/range/range_kernel_ref.h
+++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/range/range_kernel_ref.h
@@ -25,6 +25,7 @@ class RangeKernelRef: public KernelBaseOpenCL {
     KernelsPriority GetKernelsPriority(const Params &params, const optional_params &options) const override;
     ParamsKey GetSupportedKey() const override;
     bool Validate(const Params &p, const optional_params &o) const override;
+    void GetUpdateDispatchDataFunc(KernelData& kd) const override;
 public:
     RangeKernelRef() :
         KernelBaseOpenCL { "range_ref" } {
diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/reduce/reduce_kernel_base.cpp b/src/plugins/intel_gpu/src/kernel_selector/kernels/reduce/reduce_kernel_base.cpp
index 8d7ba41eea6..bf7978cf0e7 100644
--- a/src/plugins/intel_gpu/src/kernel_selector/kernels/reduce/reduce_kernel_base.cpp
+++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/reduce/reduce_kernel_base.cpp
@@ -231,6 +231,17 @@ Datatype ReduceKernelBase::GetActivationType(const reduce_params& params) const
         return Datatype::F32;
 }
 
+void ReduceKernelBase::GetUpdateDispatchDataFunc(KernelData& kd) const {
+    kd.update_dispatch_data_func = [this](const Params& params, KernelData& kd) {
+        const auto& prim_params = static_cast<const reduce_params&>(params);
+        auto dispatchData = SetDefault(prim_params);
+        OPENVINO_ASSERT(kd.kernels.size() == 1, "[GPU] Invalid kernels size for update dispatch data func");
+        kd.kernels[0].params.workGroups.global = dispatchData.gws;
+        kd.kernels[0].params.workGroups.local = dispatchData.lws;
+        kd.kernels[0].skip_execution = KernelData::SkipKernelExecution(prim_params);
+    };
+}
+
 KernelsData ReduceKernelBase::GetCommonKernelsData(const Params& p,
                                                    const optional_params& options) const {
     if (!Validate(p, options)) {
@@ -246,14 +257,7 @@ KernelsData ReduceKernelBase::GetCommonKernelsData(const Params& p,
     auto entry_point = GetEntryPoint(kernelName, params.layerID, params, options);
     auto jit = CreateJit(kernelName, cldnn_jit, entry_point);
 
-    kd.update_dispatch_data_func = [this](const Params& params, KernelData& kd) {
-        const auto& prim_params = static_cast<const reduce_params&>(params);
-        auto dispatchData = SetDefault(prim_params);
-        OPENVINO_ASSERT(kd.kernels.size() == 1, "[GPU] Invalid kernels size for update dispatch data func");
-        kd.kernels[0].params.workGroups.global = dispatchData.gws;
-        kd.kernels[0].params.workGroups.local = dispatchData.lws;
-        kd.kernels[0].skip_execution = KernelData::SkipKernelExecution(prim_params);
-    };
+    GetUpdateDispatchDataFunc(kd);
 
     auto& kernel = kd.kernels[0];
     FillCLKernelData(kernel,
diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/reduce/reduce_kernel_base.h b/src/plugins/intel_gpu/src/kernel_selector/kernels/reduce/reduce_kernel_base.h
index d3f7d9d7f78..31c1ac31a58 100644
--- a/src/plugins/intel_gpu/src/kernel_selector/kernels/reduce/reduce_kernel_base.h
+++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/reduce/reduce_kernel_base.h
@@ -44,5 +44,6 @@ protected:
     Datatype GetFinalAccumulatorType(const reduce_params& p) const;
     Datatype GetActivationType(const reduce_params& params) const;
     KernelsData GetCommonKernelsData(const Params& params, const optional_params&) const;
+    void GetUpdateDispatchDataFunc(KernelData& kd) const override;
 };
 }  // namespace kernel_selector
diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/reorder/reorder_kernel_base.cpp b/src/plugins/intel_gpu/src/kernel_selector/kernels/reorder/reorder_kernel_base.cpp
index 7aea6878e13..793fe5d2e25 100644
--- a/src/plugins/intel_gpu/src/kernel_selector/kernels/reorder/reorder_kernel_base.cpp
+++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/reorder/reorder_kernel_base.cpp
@@ -222,6 +222,17 @@ KernelsData ReorderKernelBase::GetCommonKernelsData(const reorder_weights_params
     return {kd};
 }
 
+void ReorderKernelBase::GetUpdateDispatchDataFunc(KernelData& kd) const {
+    kd.update_dispatch_data_func = [this](const Params& params, KernelData& kd) {
+        const auto& prim_params = static_cast<const reorder_params&>(params);
+        auto dispatchData = SetDefault(prim_params);
+        OPENVINO_ASSERT(kd.kernels.size() == 1, "[GPU] Invalid kernels size for update dispatch data func");
+        kd.kernels[0].params.workGroups.global = dispatchData.gws;
+        kd.kernels[0].params.workGroups.local = dispatchData.lws;
+        kd.kernels[0].skip_execution = KernelData::SkipKernelExecution(prim_params);
+    };
+}
+
 KernelsData ReorderKernelBase::GetCommonKernelsData(const reorder_params& params, const optional_params& options) const {
     if (!Validate(params, options)) {
         return {};
@@ -237,14 +248,7 @@ KernelsData ReorderKernelBase::GetCommonKernelsData(const reorder_params& params
     auto cldnn_jit = GetJitConstants(newParams);
     auto jit = CreateJit(kernelName, cldnn_jit, entry_point);
 
-    kd.update_dispatch_data_func = [this](const Params& params, KernelData& kd) {
-        const auto& prim_params = static_cast<const reorder_params&>(params);
-        auto dispatchData = SetDefault(prim_params);
-        OPENVINO_ASSERT(kd.kernels.size() == 1, "[GPU] Invalid kernels size for update dispatch data func");
-        kd.kernels[0].params.workGroups.global = dispatchData.gws;
-        kd.kernels[0].params.workGroups.local = dispatchData.lws;
-        kd.kernels[0].skip_execution = KernelData::SkipKernelExecution(prim_params);
-    };
+    GetUpdateDispatchDataFunc(kd);
 
     auto& kernel = kd.kernels[0];
 
diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/reorder/reorder_kernel_base.h b/src/plugins/intel_gpu/src/kernel_selector/kernels/reorder/reorder_kernel_base.h
index 55526dad620..55236b2fe8b 100644
--- a/src/plugins/intel_gpu/src/kernel_selector/kernels/reorder/reorder_kernel_base.h
+++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/reorder/reorder_kernel_base.h
@@ -116,5 +116,6 @@ protected:
     KernelsData GetCommonKernelsData(const reorder_weights_params& params,
                                      const optional_params&) const;
     KernelsData GetCommonKernelsData(const reorder_params& params, const optional_params&) const;
+    void GetUpdateDispatchDataFunc(KernelData& kd) const override;
 };
 }  // namespace kernel_selector
diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/rms/rms_kernel_base.cpp b/src/plugins/intel_gpu/src/kernel_selector/kernels/rms/rms_kernel_base.cpp
index f93cee2876d..d8662934d55 100644
--- a/src/plugins/intel_gpu/src/kernel_selector/kernels/rms/rms_kernel_base.cpp
+++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/rms/rms_kernel_base.cpp
@@ -37,6 +37,17 @@ RMSKernelBase::DispatchData RMSKernelBase::SetDefault(const rms_params& params)
     return dispatchData;
 }
 
+void RMSKernelBase::GetUpdateDispatchDataFunc(KernelData& kd) const {
+    kd.update_dispatch_data_func = [this](const Params& params, KernelData& kd) {
+        const auto& prim_params = static_cast<const rms_params&>(params);
+        auto dispatchData = SetDefault(prim_params);
+        OPENVINO_ASSERT(kd.kernels.size() == 1, "[GPU] Invalid kernels size for update dispatch data func");
+        kd.kernels[0].params.workGroups.global = dispatchData.gws;
+        kd.kernels[0].params.workGroups.local = dispatchData.lws;
+        kd.kernels[0].skip_execution = KernelData::SkipKernelExecution(prim_params);
+    };
+}
+
 KernelsData RMSKernelBase::GetCommonKernelsData(const Params& params, const optional_params& options) const {
     assert(params.GetType() == KernelType::RMS);
 
@@ -52,14 +63,7 @@ KernelsData RMSKernelBase::GetCommonKernelsData(const Params& params, const opti
     auto entry_point = GetEntryPoint(kernelName, orgParams.layerID, params, options);
     auto jit = CreateJit(kernelName, cldnn_jit, entry_point);
 
-    kd.update_dispatch_data_func = [this](const Params& params, KernelData& kd) {
-        const auto& prim_params = static_cast<const rms_params&>(params);
-        auto dispatchData = SetDefault(prim_params);
-        OPENVINO_ASSERT(kd.kernels.size() == 1, "[GPU] Invalid kernels size for update dispatch data func");
-        kd.kernels[0].params.workGroups.global = dispatchData.gws;
-        kd.kernels[0].params.workGroups.local = dispatchData.lws;
-        kd.kernels[0].skip_execution = KernelData::SkipKernelExecution(prim_params);
-    };
+    GetUpdateDispatchDataFunc(kd);
 
     auto& kernel = kd.kernels[0];
     FillCLKernelData(kernel,
diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/rms/rms_kernel_base.h b/src/plugins/intel_gpu/src/kernel_selector/kernels/rms/rms_kernel_base.h
index 546c209bf03..6adbd6aeb66 100644
--- a/src/plugins/intel_gpu/src/kernel_selector/kernels/rms/rms_kernel_base.h
+++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/rms/rms_kernel_base.h
@@ -46,5 +46,6 @@ protected:
     virtual DispatchData SetDefault(const rms_params& params) const;
     KernelsData GetCommonKernelsData(const Params& params, const optional_params&) const;
     Datatype GetAccumulatorType(const rms_params& params) const;
+    void GetUpdateDispatchDataFunc(KernelData& kd) const override;
 };
 }  // namespace kernel_selector
diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/scatter_update/scatter_nd_update_kernel_ref.cpp b/src/plugins/intel_gpu/src/kernel_selector/kernels/scatter_update/scatter_nd_update_kernel_ref.cpp
index 1680d39ca27..b2defdd0f97 100644
--- a/src/plugins/intel_gpu/src/kernel_selector/kernels/scatter_update/scatter_nd_update_kernel_ref.cpp
+++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/scatter_update/scatter_nd_update_kernel_ref.cpp
@@ -152,15 +152,7 @@ static std::string GetInputBlockND(const scatter_nd_update_params& params, size_
     return result;
 }
 
-KernelsData ScatterNDUpdateKernelRef::GetKernelsData(const Params& params, const optional_params& options) const {
-    if (!Validate(params, options)) {
-        return {};
-    }
-
-    KernelData kd = KernelData::Default<scatter_nd_update_params>(params, 2);
-    scatter_nd_update_params& newParams = *static_cast<scatter_nd_update_params*>(kd.params.get());
-    auto cldnn_jit = GetJitConstants(newParams);
-
+void ScatterNDUpdateKernelRef::GetUpdateDispatchDataFunc(KernelData& kd) const {
     kd.update_dispatch_data_func = [this](const Params& params, KernelData& kd) {
         const auto& prim_params = static_cast<const scatter_nd_update_params&>(params);
         OPENVINO_ASSERT(kd.kernels.size() == 2, "[GPU] Invalid kernels size for update dispatch data func");
@@ -176,6 +168,18 @@ KernelsData ScatterNDUpdateKernelRef::GetKernelsData(const Params& params, const
                 kd.kernels[i].skip_execution = false;
         }
     };
+}
+
+KernelsData ScatterNDUpdateKernelRef::GetKernelsData(const Params& params, const optional_params& options) const {
+    if (!Validate(params, options)) {
+        return {};
+    }
+
+    KernelData kd = KernelData::Default<scatter_nd_update_params>(params, 2);
+    scatter_nd_update_params& newParams = *static_cast<scatter_nd_update_params*>(kd.params.get());
+    auto cldnn_jit = GetJitConstants(newParams);
+
+    GetUpdateDispatchDataFunc(kd);
 
     // First iter - copy input data to output data
     // Second iter - update values specified by updates at specific index position specified by indices
diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/scatter_update/scatter_nd_update_kernel_ref.h b/src/plugins/intel_gpu/src/kernel_selector/kernels/scatter_update/scatter_nd_update_kernel_ref.h
index a351320a34f..8a75e5333a4 100644
--- a/src/plugins/intel_gpu/src/kernel_selector/kernels/scatter_update/scatter_nd_update_kernel_ref.h
+++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/scatter_update/scatter_nd_update_kernel_ref.h
@@ -43,5 +43,6 @@ public:
 
 protected:
     bool Validate(const Params& p, const optional_params& o) const override;
+    void GetUpdateDispatchDataFunc(KernelData& kd) const override;
 };
 }  // namespace kernel_selector
diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/scatter_update/scatter_update_kernel_ref.cpp b/src/plugins/intel_gpu/src/kernel_selector/kernels/scatter_update/scatter_update_kernel_ref.cpp
index 5ab01a18fa9..f911adb7b50 100644
--- a/src/plugins/intel_gpu/src/kernel_selector/kernels/scatter_update/scatter_update_kernel_ref.cpp
+++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/scatter_update/scatter_update_kernel_ref.cpp
@@ -301,6 +301,20 @@ bool ScatterUpdateKernelRef::Validate(const Params& p, const optional_params& o)
     return true;
 }
 
+void ScatterUpdateKernelRef::GetUpdateDispatchDataFunc(KernelData& kd) const {
+    kd.update_dispatch_data_func = [this](const Params& params, KernelData& kd) {
+        const auto& prim_params = static_cast<const scatter_update_params&>(params);
+        OPENVINO_ASSERT(kd.kernels.size() == 2, "[GPU] Invalid kernels size for update dispatch data func");
+
+        for (size_t i = 0; i < 2; ++i) {
+            auto dispatchData = SetDefault(prim_params, i == 1);
+            kd.kernels[i].params.workGroups.global = dispatchData.gws;
+            kd.kernels[i].params.workGroups.local = dispatchData.lws;
+            kd.kernels[i].skip_execution = KernelData::SkipKernelExecution(prim_params);
+        }
+    };
+}
+
 KernelsData ScatterUpdateKernelRef::GetKernelsData(const Params& params, const optional_params& options) const {
     if (!Validate(params, options)) {
         return {};
@@ -323,17 +337,7 @@ KernelsData ScatterUpdateKernelRef::GetKernelsData(const Params& params, const o
     scatter_update_params& newParams = *static_cast<scatter_update_params*>(kd.params.get());
     auto cldnn_jit = GetJitConstants(newParams);
 
-    kd.update_dispatch_data_func = [this](const Params& params, KernelData& kd) {
-        const auto& prim_params = static_cast<const scatter_update_params&>(params);
-        OPENVINO_ASSERT(kd.kernels.size() == 2, "[GPU] Invalid kernels size for update dispatch data func");
-
-        for (size_t i = 0; i < 2; ++i) {
-            auto dispatchData = SetDefault(prim_params, i == 1);
-            kd.kernels[i].params.workGroups.global = dispatchData.gws;
-            kd.kernels[i].params.workGroups.local = dispatchData.lws;
-            kd.kernels[i].skip_execution = KernelData::SkipKernelExecution(prim_params);
-        }
-    };
+    GetUpdateDispatchDataFunc(kd);
 
     for (size_t i = start_with_iteration; i < 2; ++i) {
         auto dispatchData = SetDefault(newParams, (i == 1));
diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/scatter_update/scatter_update_kernel_ref.h b/src/plugins/intel_gpu/src/kernel_selector/kernels/scatter_update/scatter_update_kernel_ref.h
index df4d01f84db..4917fd542c3 100644
--- a/src/plugins/intel_gpu/src/kernel_selector/kernels/scatter_update/scatter_update_kernel_ref.h
+++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/scatter_update/scatter_update_kernel_ref.h
@@ -40,5 +40,6 @@ public:
 
 protected:
     bool Validate(const Params& p, const optional_params& o) const override;
+    void GetUpdateDispatchDataFunc(KernelData& kd) const override;
 };
 }  // namespace kernel_selector
diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/select/select_kernel_base.cpp b/src/plugins/intel_gpu/src/kernel_selector/kernels/select/select_kernel_base.cpp
index 0cc48e0bd70..56064d7889c 100644
--- a/src/plugins/intel_gpu/src/kernel_selector/kernels/select/select_kernel_base.cpp
+++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/select/select_kernel_base.cpp
@@ -109,6 +109,17 @@ SelectKernelBase::DispatchData SelectKernelBase::SetDefault(const select_params&
     return dispatchData;
 }
 
+void SelectKernelBase::GetUpdateDispatchDataFunc(KernelData& kd) const {
+    kd.update_dispatch_data_func = [this](const Params& params, KernelData& kd) {
+        const auto& prim_params = static_cast<const select_params&>(params);
+        auto dispatchData = SetDefault(prim_params);
+        OPENVINO_ASSERT(kd.kernels.size() == 1, "[GPU] Invalid kernels size for update dispatch data func");
+        kd.kernels[0].params.workGroups.global = dispatchData.gws;
+        kd.kernels[0].params.workGroups.local = dispatchData.lws;
+        kd.kernels[0].skip_execution = KernelData::SkipKernelExecution(prim_params);
+    };
+}
+
 KernelsData SelectKernelBase::GetCommonKernelsData(const Params& params, const optional_params& options) const {
     if (!Validate(params, options)) {
         return {};
@@ -123,14 +134,7 @@ KernelsData SelectKernelBase::GetCommonKernelsData(const Params& params, const o
 
     DispatchData dispatchData = SetDefault(newParams);
 
-    kd.update_dispatch_data_func = [this](const Params& params, KernelData& kd) {
-        const auto& prim_params = static_cast<const select_params&>(params);
-        auto dispatchData = SetDefault(prim_params);
-        OPENVINO_ASSERT(kd.kernels.size() == 1, "[GPU] Invalid kernels size for update dispatch data func");
-        kd.kernels[0].params.workGroups.global = dispatchData.gws;
-        kd.kernels[0].params.workGroups.local = dispatchData.lws;
-        kd.kernels[0].skip_execution = KernelData::SkipKernelExecution(prim_params);
-    };
+    GetUpdateDispatchDataFunc(kd);
 
     auto& kernel = kd.kernels[0];
     FillCLKernelData(kernel, dispatchData, params.engineInfo, kernelName, jit, entry_point,
diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/select/select_kernel_base.h b/src/plugins/intel_gpu/src/kernel_selector/kernels/select/select_kernel_base.h
index 664b44e379b..46d20882115 100644
--- a/src/plugins/intel_gpu/src/kernel_selector/kernels/select/select_kernel_base.h
+++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/select/select_kernel_base.h
@@ -37,5 +37,6 @@ protected:
     virtual JitConstants GetJitConstants(const select_params& params) const;
     virtual DispatchData SetDefault(const select_params& params) const;
     KernelsData GetCommonKernelsData(const Params& params, const optional_params& options) const;
+    void GetUpdateDispatchDataFunc(KernelData& kd) const override;
 };
 }  // namespace kernel_selector
diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/shape_of/shape_of_kernel_ref.cpp b/src/plugins/intel_gpu/src/kernel_selector/kernels/shape_of/shape_of_kernel_ref.cpp
index 1730316ca2b..99b124dd003 100644
--- a/src/plugins/intel_gpu/src/kernel_selector/kernels/shape_of/shape_of_kernel_ref.cpp
+++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/shape_of/shape_of_kernel_ref.cpp
@@ -32,6 +32,17 @@ bool ShapeOfKernelRef::SkipKernelExecution(const shape_of_params& params) const
     return false;
 }
 
+void ShapeOfKernelRef::GetUpdateDispatchDataFunc(KernelData& kd) const {
+    kd.update_dispatch_data_func = [this](const Params& params, KernelData& kd) {
+        const auto& prim_params = static_cast<const shape_of_params&>(params);
+        auto dispatchData = SetDefault(prim_params);
+        OPENVINO_ASSERT(kd.kernels.size() == 1, "[GPU] Invalid kernels size for update dispatch data func");
+        kd.kernels[0].params.workGroups.global = dispatchData.gws;
+        kd.kernels[0].params.workGroups.local = dispatchData.lws;
+        kd.kernels[0].skip_execution = SkipKernelExecution(prim_params);
+    };
+}
+
 KernelsData ShapeOfKernelRef::GetKernelsData(const Params &params, const optional_params &options) const {
     KernelsData kernels_data;
     if (!Validate(params, options))
@@ -46,14 +57,7 @@ KernelsData ShapeOfKernelRef::GetKernelsData(const Params &params, const optiona
     auto &clKernelData = kernel_data.kernels[0];
     clKernelData.skip_execution = SkipKernelExecution(derived_params);
 
-    kernel_data.update_dispatch_data_func = [this](const Params& params, KernelData& kd) {
-        const auto& prim_params = static_cast<const shape_of_params&>(params);
-        auto dispatchData = SetDefault(prim_params);
-        OPENVINO_ASSERT(kd.kernels.size() == 1, "[GPU] Invalid kernels size for update dispatch data func");
-        kd.kernels[0].params.workGroups.global = dispatchData.gws;
-        kd.kernels[0].params.workGroups.local = dispatchData.lws;
-        kd.kernels[0].skip_execution = SkipKernelExecution(prim_params);
-    };
+    GetUpdateDispatchDataFunc(kernel_data);
 
     FillCLKernelData(clKernelData, dispatch_data, params.engineInfo, kernelName, jit, entry_point, EXE_MODE_DEFAULT,
                      false, false, 0, 0, 1, derived_params.inputs[0].is_dynamic());
diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/shape_of/shape_of_kernel_ref.h b/src/plugins/intel_gpu/src/kernel_selector/kernels/shape_of/shape_of_kernel_ref.h
index bbf0a39b1ca..b3933c84167 100644
--- a/src/plugins/intel_gpu/src/kernel_selector/kernels/shape_of/shape_of_kernel_ref.h
+++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/shape_of/shape_of_kernel_ref.h
@@ -30,6 +30,7 @@ class ShapeOfKernelRef: public KernelBaseOpenCL {
     bool Validate(const Params &p, const optional_params &o) const override;
     virtual JitConstants GetJitConstants(const shape_of_params& params) const;
     bool SkipKernelExecution(const shape_of_params& params) const;
+    void GetUpdateDispatchDataFunc(KernelData& kd) const override;
 public:
     ShapeOfKernelRef() :
         KernelBaseOpenCL { "shape_of_ref" } {
diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/softmax/softmax_kernel_bf.cpp b/src/plugins/intel_gpu/src/kernel_selector/kernels/softmax/softmax_kernel_bf.cpp
index c3e8f267c40..3e7cd1c5399 100644
--- a/src/plugins/intel_gpu/src/kernel_selector/kernels/softmax/softmax_kernel_bf.cpp
+++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/softmax/softmax_kernel_bf.cpp
@@ -90,17 +90,21 @@ KernelsPriority SoftmaxKernel_bf::GetKernelsPriority(const Params& /*params*/, c
     return FORCE_PRIORITY_6;
 }
 
+void SoftmaxKernel_bf::GetUpdateDispatchDataFunc(KernelData& kd) const {
+    kd.update_dispatch_data_func = [this](const Params& params, KernelData& kd) {
+        const auto& prim_params = static_cast<const softmax_params&>(params);
+        auto dispatchData = SetDefault(prim_params);
+        OPENVINO_ASSERT(kd.kernels.size() == 1, "[GPU] Invalid kernels size for update dispatch data func");
+        kd.kernels[0].params.workGroups.global = dispatchData.gws;
+        kd.kernels[0].params.workGroups.local = dispatchData.lws;
+        kd.kernels[0].skip_execution = KernelData::SkipKernelExecution(prim_params);
+    };
+}
+
 KernelsData SoftmaxKernel_bf::GetKernelsData(const Params& params, const optional_params& optionalParams) const {
     KernelsData kds = GetCommonKernelsData(params, optionalParams);
     if (!kds.empty()) {
-        kds[0].update_dispatch_data_func = [this](const Params& params, KernelData& kd) {
-            const auto& prim_params = static_cast<const softmax_params&>(params);
-            auto dispatchData = SetDefault(prim_params);
-            OPENVINO_ASSERT(kd.kernels.size() == 1, "[GPU] Invalid kernels size for update dispatch data func");
-            kd.kernels[0].params.workGroups.global = dispatchData.gws;
-            kd.kernels[0].params.workGroups.local = dispatchData.lws;
-            kd.kernels[0].skip_execution = KernelData::SkipKernelExecution(prim_params);
-        };
+        GetUpdateDispatchDataFunc(kds[0]);
     }
 
     return kds;
diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/softmax/softmax_kernel_bf.h b/src/plugins/intel_gpu/src/kernel_selector/kernels/softmax/softmax_kernel_bf.h
index 4f122267339..d71a273f527 100644
--- a/src/plugins/intel_gpu/src/kernel_selector/kernels/softmax/softmax_kernel_bf.h
+++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/softmax/softmax_kernel_bf.h
@@ -24,5 +24,6 @@ protected:
     std::vector<KernelBase::FusedOpType> GetSupportedFusedOps() const override {
         return { FusedOpType::QUANTIZE };
     }
+    void GetUpdateDispatchDataFunc(KernelData& kd) const override;
 };
 }  // namespace kernel_selector
diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/softmax/softmax_kernel_ref.cpp b/src/plugins/intel_gpu/src/kernel_selector/kernels/softmax/softmax_kernel_ref.cpp
index 5f99bc71fba..21f92d7216a 100644
--- a/src/plugins/intel_gpu/src/kernel_selector/kernels/softmax/softmax_kernel_ref.cpp
+++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/softmax/softmax_kernel_ref.cpp
@@ -44,23 +44,27 @@ KernelsPriority SoftmaxKernelRef::GetKernelsPriority(const Params& /*params*/, c
     return DONT_USE_IF_HAVE_SOMETHING_ELSE;
 }
 
+void SoftmaxKernelRef::GetUpdateDispatchDataFunc(KernelData& kd) const {
+    kd.update_dispatch_data_func = [this](const Params& params, KernelData& kd) {
+        const auto& prim_params = static_cast<const softmax_params&>(params);
+        auto dispatchData = SetDefault(prim_params);
+        OPENVINO_ASSERT(kd.kernels.size() == 1, "[GPU] Invalid kernels size for update dispatch data func");
+        kd.kernels[0].params.workGroups.global = dispatchData.gws;
+        kd.kernels[0].params.workGroups.local = dispatchData.lws;
+        kd.kernels[0].skip_execution = KernelData::SkipKernelExecution(prim_params);
+        kd.internalBufferSizes.clear();
+        kd.internalBufferSizes.push_back(prim_params.inputs[0].PhysicalSizeInBytes());
+        kd.internalBufferDataType = prim_params.inputs[0].GetDType();
+    };
+}
+
 KernelsData SoftmaxKernelRef::GetKernelsData(const Params& params, const optional_params& options) const {
     KernelsData kds = GetCommonKernelsData(params, options);
     if (!kds.empty()) {
         const softmax_params& orgParams = static_cast<const softmax_params&>(params);
         bool is_dynamic = orgParams.outputs[0].is_dynamic();
 
-        kds[0].update_dispatch_data_func = [this](const Params& params, KernelData& kd) {
-            const auto& prim_params = static_cast<const softmax_params&>(params);
-            auto dispatchData = SetDefault(prim_params);
-            OPENVINO_ASSERT(kd.kernels.size() == 1, "[GPU] Invalid kernels size for update dispatch data func");
-            kd.kernels[0].params.workGroups.global = dispatchData.gws;
-            kd.kernels[0].params.workGroups.local = dispatchData.lws;
-            kd.kernels[0].skip_execution = KernelData::SkipKernelExecution(prim_params);
-            kd.internalBufferSizes.clear();
-            kd.internalBufferSizes.push_back(prim_params.inputs[0].PhysicalSizeInBytes());
-            kd.internalBufferDataType = prim_params.inputs[0].GetDType();
-        };
+        GetUpdateDispatchDataFunc(kds[0]);
 
         if (is_dynamic) {
             auto& args = kds[0].kernels[0].params.arguments;
diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/softmax/softmax_kernel_ref.h b/src/plugins/intel_gpu/src/kernel_selector/kernels/softmax/softmax_kernel_ref.h
index 1972383f6a8..f622092d6e7 100644
--- a/src/plugins/intel_gpu/src/kernel_selector/kernels/softmax/softmax_kernel_ref.h
+++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/softmax/softmax_kernel_ref.h
@@ -20,5 +20,6 @@ public:
 protected:
     DispatchData SetDefault(const softmax_params& params) const override;
     JitConstants GetJitConstants(const softmax_params& params, DispatchData dispatchData) const override;
+    void GetUpdateDispatchDataFunc(KernelData& kd) const override;
 };
 }  // namespace kernel_selector
diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/strided_slice/strided_slice_kernel_ref.cpp b/src/plugins/intel_gpu/src/kernel_selector/kernels/strided_slice/strided_slice_kernel_ref.cpp
index 88e80f0c058..f2f60af369b 100644
--- a/src/plugins/intel_gpu/src/kernel_selector/kernels/strided_slice/strided_slice_kernel_ref.cpp
+++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/strided_slice/strided_slice_kernel_ref.cpp
@@ -205,6 +205,17 @@ JitConstants StridedSliceKernelRef::GetJitConstants(const strided_slice_params&
     return jit;
 }
 
+void StridedSliceKernelRef::GetUpdateDispatchDataFunc(KernelData& kd) const {
+    kd.update_dispatch_data_func = [this](const Params& params, KernelData& kd) {
+        const auto& prim_params = static_cast<const strided_slice_params&>(params);
+        auto dispatchData = SetDefault(prim_params);
+        OPENVINO_ASSERT(kd.kernels.size() == 1, "[GPU] Invalid kernels size for update dispatch data func");
+        kd.kernels[0].params.workGroups.global = dispatchData.gws;
+        kd.kernels[0].params.workGroups.local = dispatchData.lws;
+        kd.kernels[0].skip_execution = KernelData::SkipKernelExecution(prim_params);
+    };
+}
+
 KernelsData StridedSliceKernelRef::GetKernelsData(const Params& params, const optional_params& options) const {
     if (!Validate(params, options)) {
         return {};
@@ -237,14 +248,7 @@ KernelsData StridedSliceKernelRef::GetKernelsData(const Params& params, const op
 
     auto& kernel = kd.kernels[0];
 
-    kd.update_dispatch_data_func = [this](const Params& params, KernelData& kd) {
-        const auto& prim_params = static_cast<const strided_slice_params&>(params);
-        auto dispatchData = SetDefault(prim_params);
-        OPENVINO_ASSERT(kd.kernels.size() == 1, "[GPU] Invalid kernels size for update dispatch data func");
-        kd.kernels[0].params.workGroups.global = dispatchData.gws;
-        kd.kernels[0].params.workGroups.local = dispatchData.lws;
-        kd.kernels[0].skip_execution = KernelData::SkipKernelExecution(prim_params);
-    };
+    GetUpdateDispatchDataFunc(kd);
 
     FillCLKernelData(kernel, dispatchData, params.engineInfo, kernelName, jit, entry_point,
                      "", false, false, static_cast<int>(newParams.inputs.size()),
diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/strided_slice/strided_slice_kernel_ref.h b/src/plugins/intel_gpu/src/kernel_selector/kernels/strided_slice/strided_slice_kernel_ref.h
index 4fc7195afbc..d9de317f23b 100644
--- a/src/plugins/intel_gpu/src/kernel_selector/kernels/strided_slice/strided_slice_kernel_ref.h
+++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/strided_slice/strided_slice_kernel_ref.h
@@ -66,6 +66,7 @@ public:
 
 protected:
     bool Validate(const Params& p, const optional_params& o) const override;
+    void GetUpdateDispatchDataFunc(KernelData& kd) const override;
 
     std::vector<FusedOpType> GetSupportedFusedOps() const override {
         return { FusedOpType::ACTIVATION };
diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/tile/tile_kernel_ref.cpp b/src/plugins/intel_gpu/src/kernel_selector/kernels/tile/tile_kernel_ref.cpp
index 831f6ebc1ec..fcdadd81a57 100644
--- a/src/plugins/intel_gpu/src/kernel_selector/kernels/tile/tile_kernel_ref.cpp
+++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/tile/tile_kernel_ref.cpp
@@ -50,6 +50,17 @@ JitConstants TileKernelRef::GetJitConstants(const tile_params& params) const {
     return jit;
 }
 
+void TileKernelRef::GetUpdateDispatchDataFunc(KernelData& kd) const {
+    kd.update_dispatch_data_func = [this](const Params& params, KernelData& kd) {
+        const auto& prim_params = static_cast<const tile_params&>(params);
+        auto dispatchData = SetDefault(prim_params);
+        OPENVINO_ASSERT(kd.kernels.size() == 1, "[GPU] Invalid kernels size for update dispatch data func");
+        kd.kernels[0].params.workGroups.global = dispatchData.gws;
+        kd.kernels[0].params.workGroups.local = dispatchData.lws;
+        kd.kernels[0].skip_execution = KernelData::SkipKernelExecution(prim_params);
+    };
+}
+
 KernelsData TileKernelRef::GetKernelsData(const Params& params, const optional_params& options) const {
     assert(params.GetType() == KernelType::TILE);
 
@@ -61,14 +72,7 @@ KernelsData TileKernelRef::GetKernelsData(const Params& params, const optional_p
     auto cldnn_jit = GetJitConstants(newParams);
     auto jit = CreateJit(kernelName, cldnn_jit, entry_point);
 
-    kd.update_dispatch_data_func = [this](const Params& params, KernelData& kd) {
-        const auto& prim_params = static_cast<const tile_params&>(params);
-        auto dispatchData = SetDefault(prim_params);
-        OPENVINO_ASSERT(kd.kernels.size() == 1, "[GPU] Invalid kernels size for update dispatch data func");
-        kd.kernels[0].params.workGroups.global = dispatchData.gws;
-        kd.kernels[0].params.workGroups.local = dispatchData.lws;
-        kd.kernels[0].skip_execution = KernelData::SkipKernelExecution(prim_params);
-    };
+    GetUpdateDispatchDataFunc(kd);
 
     auto& kernel = kd.kernels[0];
 
diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/tile/tile_kernel_ref.h b/src/plugins/intel_gpu/src/kernel_selector/kernels/tile/tile_kernel_ref.h
index dce8f1e30f1..5101a799b00 100644
--- a/src/plugins/intel_gpu/src/kernel_selector/kernels/tile/tile_kernel_ref.h
+++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/tile/tile_kernel_ref.h
@@ -31,5 +31,6 @@ public:
     KernelsData GetKernelsData(const Params& params, const optional_params& options) const override;
     KernelsPriority GetKernelsPriority(const Params& params, const optional_params& options) const override;
     ParamsKey GetSupportedKey() const override;
+    void GetUpdateDispatchDataFunc(KernelData& kd) const override;
 };
 }  // namespace kernel_selector
diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/unique/unique_kernel_ref.cpp b/src/plugins/intel_gpu/src/kernel_selector/kernels/unique/unique_kernel_ref.cpp
index 24553e43087..370881b2262 100644
--- a/src/plugins/intel_gpu/src/kernel_selector/kernels/unique/unique_kernel_ref.cpp
+++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/unique/unique_kernel_ref.cpp
@@ -124,6 +124,20 @@ JitConstants MakeFlattenedJitConstants(size_t rank, bool simple_layout) {
 
 }  // namespace
 
+void UniqueCountKernelRef::GetUpdateDispatchDataFunc(KernelData& kd) const {
+    kd.update_dispatch_data_func = [](const Params& params, KernelData& kd) {
+        const auto& prim_params = dynamic_cast<const unique_count_params&>(params);
+        auto dispatchData = SetDefault(prim_params);
+        OPENVINO_ASSERT(kd.kernels.size() == 1, "[GPU] Invalid kernels size for update dispatch data func");
+        kd.kernels[0].params.workGroups.global = dispatchData.gws;
+        kd.kernels[0].params.workGroups.local = dispatchData.lws;
+        kd.kernels[0].skip_execution = KernelData::SkipKernelExecution(prim_params);
+        // Need to adjust buffer size according to input size
+        kd.internalBufferSizes.front() = prim_params.inputs.front().PhysicalSizeInBytes();
+        kd.internalBufferDataType = prim_params.inputs.front().GetDType();
+    };
+}
+
 KernelsData UniqueCountKernelRef::GetKernelsData(const Params& params, const optional_params& options) const {
     if (!Validate(params, options)) {
         return {};
@@ -137,17 +151,7 @@ KernelsData UniqueCountKernelRef::GetKernelsData(const Params& params, const opt
     const auto jit = CreateJit(kernelName, jit_constants, entry_point);
     auto& kernel = kernel_data.kernels.front();
 
-    kernel_data.update_dispatch_data_func = [](const Params& params, KernelData& kd) {
-        const auto& prim_params = dynamic_cast<const unique_count_params&>(params);
-        auto dispatchData = SetDefault(prim_params);
-        OPENVINO_ASSERT(kd.kernels.size() == 1, "[GPU] Invalid kernels size for update dispatch data func");
-        kd.kernels[0].params.workGroups.global = dispatchData.gws;
-        kd.kernels[0].params.workGroups.local = dispatchData.lws;
-        kd.kernels[0].skip_execution = KernelData::SkipKernelExecution(prim_params);
-        // Need to adjust buffer size according to input size
-        kd.internalBufferSizes.front() = prim_params.inputs.front().PhysicalSizeInBytes();
-        kd.internalBufferDataType = prim_params.inputs.front().GetDType();
-    };
+    GetUpdateDispatchDataFunc(kernel_data);
 
     FillCLKernelData(kernel,
                      dispatch_data,
@@ -234,6 +238,17 @@ CommonDispatchData UniqueCountKernelRef::SetDefault(const unique_count_params& /
     return dispatch_data;
 }
 
+void UniqueGatherKernelRef::GetUpdateDispatchDataFunc(KernelData& kd) const {
+    kd.update_dispatch_data_func = [](const Params& params, KernelData& kd) {
+        const auto& prim_params = dynamic_cast<const unique_gather_params&>(params);
+        auto dispatchData = SetDefault(prim_params);
+        OPENVINO_ASSERT(kd.kernels.size() == 1, "[GPU] Invalid kernels size for update dispatch data func");
+        kd.kernels[0].params.workGroups.global = dispatchData.gws;
+        kd.kernels[0].params.workGroups.local = dispatchData.lws;
+        kd.kernels[0].skip_execution = KernelData::SkipKernelExecution(prim_params);
+    };
+}
+
 KernelsData UniqueGatherKernelRef::GetKernelsData(const Params& params, const optional_params& options) const {
     if (!Validate(params, options)) {
         return {};
@@ -247,14 +262,7 @@ KernelsData UniqueGatherKernelRef::GetKernelsData(const Params& params, const op
     const auto jit = CreateJit(kernelName, jit_constants, entry_point);
     auto& kernel = kernel_data.kernels.front();
 
-    kernel_data.update_dispatch_data_func = [](const Params& params, KernelData& kd) {
-        const auto& prim_params = dynamic_cast<const unique_gather_params&>(params);
-        auto dispatchData = SetDefault(prim_params);
-        OPENVINO_ASSERT(kd.kernels.size() == 1, "[GPU] Invalid kernels size for update dispatch data func");
-        kd.kernels[0].params.workGroups.global = dispatchData.gws;
-        kd.kernels[0].params.workGroups.local = dispatchData.lws;
-        kd.kernels[0].skip_execution = KernelData::SkipKernelExecution(prim_params);
-    };
+    GetUpdateDispatchDataFunc(kernel_data);
 
     FillCLKernelData(kernel,
                      dispatch_data,
diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/unique/unique_kernel_ref.hpp b/src/plugins/intel_gpu/src/kernel_selector/kernels/unique/unique_kernel_ref.hpp
index 792079e7848..759647b7eb1 100644
--- a/src/plugins/intel_gpu/src/kernel_selector/kernels/unique/unique_kernel_ref.hpp
+++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/unique/unique_kernel_ref.hpp
@@ -37,6 +37,7 @@ protected:
     bool Validate(const Params& params, const optional_params& options) const override;
     JitConstants GetJitConstants(const unique_count_params& kernel_params) const;
     static CommonDispatchData SetDefault(const unique_count_params& kernel_params);
+    void GetUpdateDispatchDataFunc(KernelData& kd) const override;
 };
 
 /**
@@ -69,6 +70,7 @@ protected:
     bool Validate(const Params& params, const optional_params& options) const override;
     JitConstants GetJitConstants(const unique_gather_params& kernel_params) const;
     static CommonDispatchData SetDefault(const unique_gather_params& kernel_params);
+    void GetUpdateDispatchDataFunc(KernelData& kd) const override;
 };
 
 }  // namespace kernel_selector
diff --git a/src/plugins/intel_gpu/src/plugin/compiled_model.cpp b/src/plugins/intel_gpu/src/plugin/compiled_model.cpp
index 48d75b4640c..696e9d4d113 100644
--- a/src/plugins/intel_gpu/src/plugin/compiled_model.cpp
+++ b/src/plugins/intel_gpu/src/plugin/compiled_model.cpp
@@ -68,7 +68,6 @@ CompiledModel::CompiledModel(std::shared_ptr<ov::Model> model,
     , m_context(context)
     , m_config(config)
     , m_wait_executor(std::make_shared<ov::threading::CPUStreamsExecutor>(ov::threading::IStreamsExecutor::Config{"Intel GPU plugin wait executor"}))
-    , m_model(model->is_dynamic() ? model : nullptr)
     , m_model_name(model->get_friendly_name())
     , m_inputs(ov::ICompiledModel::inputs())
     , m_outputs(ov::ICompiledModel::outputs())
@@ -80,7 +79,7 @@ CompiledModel::CompiledModel(std::shared_ptr<ov::Model> model,
     }
 }
 
-CompiledModel::CompiledModel(cldnn::BinaryInputBuffer ib,
+CompiledModel::CompiledModel(cldnn::BinaryInputBuffer& ib,
                              const std::shared_ptr<const ov::IPlugin>& plugin,
                              RemoteContextImpl::Ptr context,
                              const ExecutionConfig& config)
@@ -92,7 +91,6 @@ CompiledModel::CompiledModel(cldnn::BinaryInputBuffer ib,
     , m_context(context)
     , m_config(config)
     , m_wait_executor(std::make_shared<ov::threading::CPUStreamsExecutor>(ov::threading::IStreamsExecutor::Config{"Intel GPU plugin wait executor"}))
-    , m_model(nullptr)
     , m_model_name("")
     , m_loaded_from_cache(true) {
     {
@@ -168,10 +166,9 @@ CompiledModel::CompiledModel(cldnn::BinaryInputBuffer ib,
         }
     }
 
-    auto pos = ib.tellg();
+    auto graph_base = std::make_shared<Graph>(ib, context, m_config, 0);
     for (uint16_t n = 0; n < m_config.get_property(ov::num_streams); n++) {
-        ib.seekg(pos);
-        auto graph = std::make_shared<Graph>(ib, context, m_config, n);
+        auto graph = n == 0 ? graph_base : std::make_shared<Graph>(graph_base, n);
         m_graphs.push_back(graph);
     }
 }
@@ -195,9 +192,6 @@ void CompiledModel::export_model(std::ostream& model) const {
 
     cldnn::BinaryOutputBuffer ob(model);
 
-    bool is_dynamic = get_graph(0)->get_network()->is_dynamic();
-
-    ob << is_dynamic;
     // Inputs
     {
         const auto& params = inputs();
@@ -237,12 +231,7 @@ void CompiledModel::export_model(std::ostream& model) const {
         }
     }
 
-    if (is_dynamic) {
-        ov::pass::StreamSerialize serializer(model, {}, ov::pass::Serialize::Version::UNSPECIFIED);
-        serializer.run_on_model(m_model);
-    } else {
-        get_graph(0)->export_model(ob);
-    }
+    get_graph(0)->export_model(ob);
 }
 
 std::shared_ptr<const ov::Model> CompiledModel::get_runtime_model() const {
diff --git a/src/plugins/intel_gpu/src/plugin/graph.cpp b/src/plugins/intel_gpu/src/plugin/graph.cpp
index 0eeeb3555a0..1194f659d89 100644
--- a/src/plugins/intel_gpu/src/plugin/graph.cpp
+++ b/src/plugins/intel_gpu/src/plugin/graph.cpp
@@ -84,8 +84,19 @@ Graph::Graph(cldnn::BinaryInputBuffer &ib, const RemoteContextImpl::Ptr& context
             ib >> perfEntry.parentPrimitive;
         }
     }
+    {
+        bool bool_prop_value;
+        ib >> bool_prop_value;
+        m_config.set_property(ov::intel_gpu::partial_build_program(bool_prop_value));
+        ib >> bool_prop_value;
+        m_config.set_property(ov::intel_gpu::optimize_data(bool_prop_value));
+        ib >> bool_prop_value;
+        m_config.set_property(ov::intel_gpu::allow_new_shape_infer(bool_prop_value));
+    }
 
-    m_network = std::make_shared<cldnn::network>(ib, get_engine().create_stream(config), get_engine(), m_stream_id == 0, 0);
+    auto imported_prog = std::make_shared<cldnn::program>(get_engine(), m_config);
+    imported_prog->load(ib);
+    build(imported_prog);
 }
 
 Graph::Graph(std::shared_ptr<Graph> graph, uint16_t stream_id)
@@ -448,8 +459,14 @@ void Graph::export_model(cldnn::BinaryOutputBuffer &ob) {
             ob << perf_item.second.second.parentPrimitive;
         }
     }
+    {
+        ob << m_config.get_property(ov::intel_gpu::partial_build_program);
+        ob << m_config.get_property(ov::intel_gpu::optimize_data);
+        ob << m_config.get_property(ov::intel_gpu::allow_new_shape_infer);
+    }
 
-    m_network->save(ob);
+    ob.set_stream(m_network->get_stream_ptr().get());
+    m_network->get_program()->save(ob);
 }
 
 std::shared_ptr<ov::Model> Graph::get_runtime_model() {
diff --git a/src/plugins/intel_gpu/src/plugin/plugin.cpp b/src/plugins/intel_gpu/src/plugin/plugin.cpp
index 60d2077495f..5ed0e899364 100644
--- a/src/plugins/intel_gpu/src/plugin/plugin.cpp
+++ b/src/plugins/intel_gpu/src/plugin/plugin.cpp
@@ -311,40 +311,8 @@ std::shared_ptr<ov::ICompiledModel> Plugin::import_model(std::istream& model,
     config.set_user_property(preprocess_config(orig_config));
     config.apply_user_properties(context_impl->get_engine().get_device_info());
 
-    {
-        cldnn::BinaryInputBuffer ib(model, context_impl->get_engine());
-
-        CompiledModel::Ptr compiled_model;
-        bool is_dynamic;
-        ib >> is_dynamic;
-
-        if (is_dynamic) {
-            std::string xmlString, xmlInOutString;
-            ov::Tensor data_tensor;
-
-            ov::pass::StreamSerialize::DataHeader hdr = {};
-            model.read(reinterpret_cast<char*>(&hdr), sizeof hdr);
-
-            // read blob content
-            model.seekg(hdr.consts_offset);
-            if (hdr.consts_size) {
-                data_tensor = ov::Tensor(ov::element::u8, {hdr.consts_size});
-                model.read(static_cast<char*>(data_tensor.data()), hdr.consts_size);
-            }
-
-            // read XML content
-            model.seekg(hdr.model_offset);
-            xmlString.resize(hdr.model_size);
-            model.read(&xmlString[0], hdr.model_size);
-
-            auto transformed_model = get_core()->read_model(xmlString, data_tensor, true);
-            compiled_model = std::make_shared<CompiledModel>(transformed_model, shared_from_this(), context_impl, config);
-        } else {
-            compiled_model = std::make_shared<CompiledModel>(ib, shared_from_this(), context_impl, config);
-        }
-
-        return compiled_model;
-    }
+    cldnn::BinaryInputBuffer ib(model, context_impl->get_engine());
+    return std::make_shared<CompiledModel>(ib, shared_from_this(), context_impl, config);
 }
 
 ov::Any Plugin::get_property(const std::string& name, const ov::AnyMap& options) const {
diff --git a/src/plugins/intel_gpu/tests/functional/subgraph_tests/dynamic/kv_cache.cpp b/src/plugins/intel_gpu/tests/functional/subgraph_tests/dynamic/kv_cache.cpp
index 0ad059d9f0c..d3fea8828b2 100644
--- a/src/plugins/intel_gpu/tests/functional/subgraph_tests/dynamic/kv_cache.cpp
+++ b/src/plugins/intel_gpu/tests/functional/subgraph_tests/dynamic/kv_cache.cpp
@@ -3,6 +3,7 @@
 //
 
 #include "common_test_utils/ov_tensor_utils.hpp"
+#include "common_test_utils/file_utils.hpp"
 #include "openvino/core/node_vector.hpp"
 #include "openvino/core/partial_shape.hpp"
 #include "openvino/core/preprocess/pre_post_process.hpp"
@@ -82,6 +83,29 @@ TEST_P(KVCacheTest, CompareWithRefs) {
     run();
 }
 
+TEST_P(KVCacheTest, CompareWithRefs_cached) {
+    SKIP_IF_CURRENT_TEST_IS_DISABLED()
+
+    std::stringstream ss;
+    ss << "gpu_model_cache_" << std::hash<std::string>{}(
+          std::string(::testing::UnitTest::GetInstance()->current_test_info()->test_suite_name()) +
+          std::string(::testing::UnitTest::GetInstance()->current_test_info()->name()));
+    std::string cacheDirName = ss.str();
+    {
+        ov::test::utils::removeFilesWithExt(cacheDirName, "blob");
+        ov::test::utils::removeFilesWithExt(cacheDirName, "cl_cache");
+        ov::test::utils::removeDir(cacheDirName);
+        core->set_property(ov::cache_dir(cacheDirName));
+        compile_model();
+    }
+    {
+        run();
+        ov::test::utils::removeFilesWithExt(cacheDirName, "blob");
+        ov::test::utils::removeFilesWithExt(cacheDirName, "cl_cache");
+        ov::test::utils::removeDir(cacheDirName);
+    }
+}
+
 namespace {
 
 const std::vector<ov::element::Type> precisions = {ov::element::f32, ov::element::f16};
@@ -102,222 +126,285 @@ INSTANTIATE_TEST_SUITE_P(smoke_GPU_Dynamic,
                          KVCacheTest::get_test_case_name);
 } // namespace
 
-TEST(KVCacheTest, smoke_multipleIterations) {
-#if defined(ANDROID)
-    GTEST_SKIP();
-#endif
-    auto core = ov::Core();
+class KVCacheTests: public ::testing::Test {
+    public:
+    void test_smoke_multipleIterations(bool is_caching_test) {
+    #if defined(ANDROID)
+        GTEST_SKIP();
+    #endif
+        auto core = ov::Core();
 
-    const size_t batch = 1;
-    const size_t n_heads = 32;
-    const size_t n_features = 80;
-    const size_t context_size = 20;
-    size_t cache_size = 0;
+        std::string cacheDirName;
+        if (is_caching_test) {
+            std::stringstream ss;
+            ss << "gpu_model_cache_" << std::hash<std::string>{}(
+                  std::string(::testing::UnitTest::GetInstance()->current_test_info()->test_suite_name()) +
+                  std::string(::testing::UnitTest::GetInstance()->current_test_info()->name()));
+            cacheDirName = ss.str();
+            ov::test::utils::removeFilesWithExt(cacheDirName, "blob");
+            ov::test::utils::removeFilesWithExt(cacheDirName, "cl_cache");
+            ov::test::utils::removeDir(cacheDirName);
+            core.set_property(ov::cache_dir(cacheDirName));
+        }
 
-    ov::element::Type element_type = ov::element::f16;
+        const size_t batch = 1;
+        const size_t n_heads = 32;
+        const size_t n_features = 80;
+        const size_t context_size = 20;
+        size_t cache_size = 0;
 
-    auto model = tests::make_llm_kv_cache_pattern(batch, n_heads, n_features, element_type);
-    auto compiled_model = core.compile_model(model, ov::test::utils::DEVICE_GPU, ov::hint::inference_precision(ov::element::f16));
+        ov::element::Type element_type = ov::element::f16;
 
-    auto input0 = model->get_parameters().at(0);
-    auto input1 = model->get_parameters().at(1);
-    auto input2 = model->get_parameters().at(2);
-    auto output0 = model->get_results().at(0);
-    auto output1 = model->get_results().at(1);
+        auto model = tests::make_llm_kv_cache_pattern(batch, n_heads, n_features, element_type);
+        if (is_caching_test) {
+            core.compile_model(model, ov::test::utils::DEVICE_GPU, ov::hint::inference_precision(ov::element::f16));
+        }
+        auto compiled_model = core.compile_model(model, ov::test::utils::DEVICE_GPU, ov::hint::inference_precision(ov::element::f16));
 
-    auto get_ref_results = [&model, &input0, &input1, &input2](const ov::Tensor& kv_cache, const ov::Tensor& new_token_data, const ov::Tensor& matmul_data) {
-        auto ref_model = model->clone();
-        ov::Tensor kv_cache_copy(kv_cache.get_element_type(), kv_cache.get_shape());
-        kv_cache.copy_to(kv_cache_copy);
-        ngraph::helpers::resize_function(ref_model, {kv_cache_copy.get_shape(), new_token_data.get_shape(), matmul_data.get_shape()});
-        return ngraph::helpers::interpretFunction(ref_model, {{input0, kv_cache_copy}, {input1, new_token_data}, {input2, matmul_data}});
-    };
+        auto input0 = model->get_parameters().at(0);
+        auto input1 = model->get_parameters().at(1);
+        auto input2 = model->get_parameters().at(2);
+        auto output0 = model->get_results().at(0);
+        auto output1 = model->get_results().at(1);
 
-    auto compare_tensors = [&model](const std::vector<ov::Tensor> expected, const std::vector<ov::Tensor>& actual) {
-            ASSERT_EQ(expected.size(), actual.size());
-            ASSERT_EQ(expected.size(), model->get_results().size());
-            auto compareMap = ov::test::utils::getCompareMap();
-            const auto& results = model->get_results();
-            for (size_t j = 0; j < results.size(); j++) {
-                const auto result = results[j];
-                for (size_t i = 0; i < result->get_input_size(); ++i) {
-                    std::shared_ptr<ov::Node> inputNode = result->get_input_node_shared_ptr(i);
-                    if (std::dynamic_pointer_cast<ov::op::v0::Convert>(inputNode)) {
-                        std::shared_ptr<ov::Node> nextNodePtr = inputNode->get_input_node_shared_ptr(0);
-                        if (!ngraph::is_type<ov::op::v0::Result>(nextNodePtr)) {
-                            inputNode = nextNodePtr;
+        auto get_ref_results = [&model, &input0, &input1, &input2](const ov::Tensor& kv_cache, const ov::Tensor& new_token_data,
+                                                                   const ov::Tensor& matmul_data) {
+            auto ref_model = model->clone();
+            ov::Tensor kv_cache_copy(kv_cache.get_element_type(), kv_cache.get_shape());
+            kv_cache.copy_to(kv_cache_copy);
+            ngraph::helpers::resize_function(ref_model, {kv_cache_copy.get_shape(), new_token_data.get_shape(), matmul_data.get_shape()});
+            return ngraph::helpers::interpretFunction(ref_model, {{input0, kv_cache_copy}, {input1, new_token_data}, {input2, matmul_data}});
+        };
+
+        auto compare_tensors = [&model](const std::vector<ov::Tensor> expected, const std::vector<ov::Tensor>& actual) {
+                ASSERT_EQ(expected.size(), actual.size());
+                ASSERT_EQ(expected.size(), model->get_results().size());
+                auto compareMap = ov::test::utils::getCompareMap();
+                const auto& results = model->get_results();
+                for (size_t j = 0; j < results.size(); j++) {
+                    const auto result = results[j];
+                    for (size_t i = 0; i < result->get_input_size(); ++i) {
+                        std::shared_ptr<ov::Node> inputNode = result->get_input_node_shared_ptr(i);
+                        if (std::dynamic_pointer_cast<ov::op::v0::Convert>(inputNode)) {
+                            std::shared_ptr<ov::Node> nextNodePtr = inputNode->get_input_node_shared_ptr(0);
+                            if (!ngraph::is_type<ov::op::v0::Result>(nextNodePtr)) {
+                                inputNode = nextNodePtr;
+                            }
                         }
+                        auto it = compareMap.find(inputNode->get_type_info());
+                        ASSERT_NE(it, compareMap.end());
+                        it->second(inputNode, i, expected[j], actual[j], 1e-4f, 1e-4f);
                     }
-                    auto it = compareMap.find(inputNode->get_type_info());
-                    ASSERT_NE(it, compareMap.end());
-                    it->second(inputNode, i, expected[j], actual[j], 1e-4f, 1e-4f);
                 }
-            }
-    };
+        };
 
-    auto infer_request = compiled_model.create_infer_request();
-    auto kv_cache_input = infer_request.get_tensor(output0);
-    auto matmul_out = infer_request.get_tensor(output1);
-    auto new_token_input = infer_request.get_tensor(input1);
-    auto matmul_input = infer_request.get_tensor(input2);
+        auto infer_request = compiled_model.create_infer_request();
+        auto kv_cache_input = infer_request.get_tensor(output0);
+        auto matmul_out = infer_request.get_tensor(output1);
+        auto new_token_input = infer_request.get_tensor(input1);
+        auto matmul_input = infer_request.get_tensor(input2);
 
-    infer_request.set_tensor(input0, kv_cache_input);
-    infer_request.set_tensor(input1, new_token_input);
-    infer_request.set_tensor(input2, matmul_input);
+        infer_request.set_tensor(input0, kv_cache_input);
+        infer_request.set_tensor(input1, new_token_input);
+        infer_request.set_tensor(input2, matmul_input);
 
-    {
-        const ov::Shape new_token_size_initial = {batch, context_size, n_heads, n_features};
-        const ov::Shape kv_cache_size_initial = {batch, n_heads, cache_size, n_features};
-        const ov::Shape matmul_in_size_initial = {batch, n_heads, context_size, context_size};
+        {
+            const ov::Shape new_token_size_initial = {batch, context_size, n_heads, n_features};
+            const ov::Shape kv_cache_size_initial = {batch, n_heads, cache_size, n_features};
+            const ov::Shape matmul_in_size_initial = {batch, n_heads, context_size, context_size};
 
-        auto new_token_data = ov::test::utils::create_and_fill_tensor(element_type, new_token_size_initial);
-        auto matmul_data = ov::test::utils::create_and_fill_tensor(element_type, matmul_in_size_initial);
+            auto new_token_data = ov::test::utils::create_and_fill_tensor(element_type, new_token_size_initial);
+            auto matmul_data = ov::test::utils::create_and_fill_tensor(element_type, matmul_in_size_initial);
 
-        kv_cache_input.set_shape(kv_cache_size_initial);
-        new_token_input.set_shape(new_token_data.get_shape());
-        matmul_input.set_shape(matmul_data.get_shape());
+            kv_cache_input.set_shape(kv_cache_size_initial);
+            new_token_input.set_shape(new_token_data.get_shape());
+            matmul_input.set_shape(matmul_data.get_shape());
 
-        new_token_data.copy_to(new_token_input);
-        matmul_data.copy_to(matmul_input);
+            new_token_data.copy_to(new_token_input);
+            matmul_data.copy_to(matmul_input);
 
-        auto ref_results = get_ref_results(kv_cache_input, new_token_data, matmul_data);
+            auto ref_results = get_ref_results(kv_cache_input, new_token_data, matmul_data);
 
-        infer_request.infer();
+            infer_request.infer();
 
-        compare_tensors(ref_results, {kv_cache_input, matmul_out});
+            compare_tensors(ref_results, {kv_cache_input, matmul_out});
 
-        cache_size += context_size;
+            cache_size += context_size;
+        }
+
+        const size_t input_tokens = 1;
+        const size_t niters = 10;
+        const ov::Shape new_token_size = {batch, input_tokens, n_heads, n_features};
+        size_t context_length = cache_size + input_tokens;
+        for (size_t i = 0; i < niters; i++, context_length += input_tokens) {
+            ov::Shape matmul_in_size_loop = {batch, n_heads, input_tokens, context_length};
+            auto new_token_data = ov::test::utils::create_and_fill_tensor(element_type, new_token_size);
+            auto matmul_data = ov::test::utils::create_and_fill_tensor(element_type, matmul_in_size_loop);
+            auto ref_results = get_ref_results(kv_cache_input, new_token_data, matmul_data);
+
+            new_token_input.set_shape(new_token_data.get_shape());
+            matmul_input.set_shape(matmul_data.get_shape());
+            new_token_data.copy_to(new_token_input);
+            matmul_data.copy_to(matmul_input);
+
+            infer_request.infer();
+
+            compare_tensors(ref_results, {kv_cache_input, matmul_out});
+        }
+
+        if (is_caching_test) {
+            ov::test::utils::removeFilesWithExt(cacheDirName, "blob");
+            ov::test::utils::removeFilesWithExt(cacheDirName, "cl_cache");
+            ov::test::utils::removeDir(cacheDirName);
+        }
     }
 
-    const size_t input_tokens = 1;
-    const size_t niters = 10;
-    const ov::Shape new_token_size = {batch, input_tokens, n_heads, n_features};
-    size_t context_length = cache_size + input_tokens;
-    for (size_t i = 0; i < niters; i++, context_length += input_tokens) {
-        ov::Shape matmul_in_size_loop = {batch, n_heads, input_tokens, context_length};
-        auto new_token_data = ov::test::utils::create_and_fill_tensor(element_type, new_token_size);
-        auto matmul_data = ov::test::utils::create_and_fill_tensor(element_type, matmul_in_size_loop);
-        auto ref_results = get_ref_results(kv_cache_input, new_token_data, matmul_data);
+    void test_smoke_multipleIterations_stateful(bool is_caching_test) {
+    #if defined(ANDROID)
+        GTEST_SKIP();
+    #endif
+        auto core = ov::Core();
 
-        new_token_input.set_shape(new_token_data.get_shape());
-        matmul_input.set_shape(matmul_data.get_shape());
-        new_token_data.copy_to(new_token_input);
-        matmul_data.copy_to(matmul_input);
+        std::string cacheDirName;
+        if (is_caching_test) {
+            std::stringstream ss;
+            ss << "gpu_model_cache_" << std::hash<std::string>{}(
+                  std::string(::testing::UnitTest::GetInstance()->current_test_info()->test_suite_name()) +
+                  std::string(::testing::UnitTest::GetInstance()->current_test_info()->name()));
+            std::string cacheDirName = ss.str();
+            ov::test::utils::removeFilesWithExt(cacheDirName, "blob");
+            ov::test::utils::removeFilesWithExt(cacheDirName, "cl_cache");
+            ov::test::utils::removeDir(cacheDirName);
+            core.set_property(ov::cache_dir(cacheDirName));
+        }
 
-        infer_request.infer();
+        const size_t batch = 1;
+        const size_t n_heads = 32;
+        const size_t n_features = 80;
+        const size_t context_size = 20;
+        size_t cache_size = 0;
 
-        compare_tensors(ref_results, {kv_cache_input, matmul_out});
+        ov::element::Type element_type = ov::element::f16;
+
+        auto model = tests::make_llm_kv_cache_pattern(batch, n_heads, n_features, element_type, true);
+        auto ref_model = tests::make_llm_kv_cache_pattern(batch, n_heads, n_features, element_type, false);
+        if (is_caching_test) {
+            core.compile_model(model, ov::test::utils::DEVICE_GPU, ov::hint::inference_precision(ov::element::f16));
+        }
+        auto compiled_model = core.compile_model(model, ov::test::utils::DEVICE_GPU, ov::hint::inference_precision(ov::element::f16));
+
+        auto input0 = model->get_parameters().at(0);
+        auto input1 = model->get_parameters().at(1);
+        auto output0 = model->get_results().at(0);
+
+        auto get_ref_results = [&ref_model](const ov::Tensor& kv_cache, const ov::Tensor& new_token_data, const ov::Tensor& matmul_data) {
+            auto input0 = ref_model->get_parameters().at(0);
+            auto input1 = ref_model->get_parameters().at(1);
+            auto input2 = ref_model->get_parameters().at(2);
+            ngraph::helpers::resize_function(ref_model, {kv_cache.get_shape(), new_token_data.get_shape(), matmul_data.get_shape()});
+            return ngraph::helpers::interpretFunction(ref_model, {{input0, kv_cache}, {input1, new_token_data}, {input2, matmul_data}});
+        };
+
+        auto compare_tensors = [&model](const std::vector<ov::Tensor> expected, const std::vector<ov::Tensor>& actual) {
+                ASSERT_EQ(expected.size(), actual.size());
+                ASSERT_EQ(expected.size(), model->get_results().size());
+                auto compareMap = ov::test::utils::getCompareMap();
+                const auto& results = model->get_results();
+                for (size_t j = 0; j < results.size(); j++) {
+                    const auto result = results[j];
+                    for (size_t i = 0; i < result->get_input_size(); ++i) {
+                        std::shared_ptr<ov::Node> inputNode = result->get_input_node_shared_ptr(i);
+                        if (std::dynamic_pointer_cast<ov::op::v0::Convert>(inputNode)) {
+                            std::shared_ptr<ov::Node> nextNodePtr = inputNode->get_input_node_shared_ptr(0);
+                            if (!ngraph::is_type<ov::op::v0::Result>(nextNodePtr)) {
+                                inputNode = nextNodePtr;
+                            }
+                        }
+                        auto it = compareMap.find(inputNode->get_type_info());
+                        ASSERT_NE(it, compareMap.end());
+                        it->second(inputNode, i, expected[j], actual[j], 1e-4f, 1e-4f);
+                    }
+                }
+        };
+
+        auto infer_request = compiled_model.create_infer_request();
+        auto matmul_out = infer_request.get_tensor(output0);
+        auto new_token_input = infer_request.get_tensor(input0);
+        auto matmul_input = infer_request.get_tensor(input1);
+
+        infer_request.set_tensor(input0, new_token_input);
+        infer_request.set_tensor(input1, matmul_input);
+
+        ov::Tensor ref_kv_cache;
+
+        {
+            const ov::Shape new_token_size_initial = {batch, context_size, n_heads, n_features};
+            const ov::Shape kv_cache_size_initial = {batch, n_heads, cache_size, n_features};
+            const ov::Shape matmul_in_size_initial = {batch, n_heads, context_size, context_size};
+
+            auto new_token_data = ov::test::utils::create_and_fill_tensor(element_type, new_token_size_initial);
+            auto matmul_data = ov::test::utils::create_and_fill_tensor(element_type, matmul_in_size_initial);
+
+            new_token_input.set_shape(new_token_data.get_shape());
+            matmul_input.set_shape(matmul_data.get_shape());
+
+            new_token_data.copy_to(new_token_input);
+            matmul_data.copy_to(matmul_input);
+
+            ref_kv_cache = ov::Tensor(element_type, kv_cache_size_initial);
+
+            auto ref_results = get_ref_results(ref_kv_cache, new_token_data, matmul_data);
+            ref_kv_cache = ref_results[0];
+
+            infer_request.infer();
+
+            compare_tensors({ ref_results[1] }, {matmul_out});
+
+            cache_size += context_size;
+        }
+
+        const size_t input_tokens = 1;
+        const size_t niters = 10;
+        const ov::Shape new_token_size = {batch, input_tokens, n_heads, n_features};
+        size_t context_length = cache_size + input_tokens;
+        for (size_t i = 0; i < niters; i++, context_length += input_tokens) {
+            ov::Shape matmul_in_size_loop = {batch, n_heads, input_tokens, context_length};
+            auto new_token_data = ov::test::utils::create_and_fill_tensor(element_type, new_token_size);
+            auto matmul_data = ov::test::utils::create_and_fill_tensor(element_type, matmul_in_size_loop);
+            auto ref_results = get_ref_results(ref_kv_cache, new_token_data, matmul_data);
+            ref_kv_cache = ref_results[0];
+
+            new_token_input.set_shape(new_token_data.get_shape());
+            matmul_input.set_shape(matmul_data.get_shape());
+            new_token_data.copy_to(new_token_input);
+            matmul_data.copy_to(matmul_input);
+
+            infer_request.infer();
+
+            compare_tensors({ ref_results[1] }, {matmul_out});
+        }
+
+        if (is_caching_test) {
+            ov::test::utils::removeFilesWithExt(cacheDirName, "blob");
+            ov::test::utils::removeFilesWithExt(cacheDirName, "cl_cache");
+            ov::test::utils::removeDir(cacheDirName);
+        }
     }
+};
+
+TEST_F(KVCacheTests, smoke_multipleIterations) {
+    this->test_smoke_multipleIterations(false);
 }
 
-TEST(KVCacheTest, smoke_multipleIterations_stateful) {
-#if defined(ANDROID)
-    GTEST_SKIP();
-#endif
-    auto core = ov::Core();
-
-    const size_t batch = 1;
-    const size_t n_heads = 32;
-    const size_t n_features = 80;
-    const size_t context_size = 20;
-    size_t cache_size = 0;
-
-    ov::element::Type element_type = ov::element::f16;
-
-    auto model = tests::make_llm_kv_cache_pattern(batch, n_heads, n_features, element_type, true);
-    auto ref_model = tests::make_llm_kv_cache_pattern(batch, n_heads, n_features, element_type, false);
-    auto compiled_model = core.compile_model(model, ov::test::utils::DEVICE_GPU, ov::hint::inference_precision(ov::element::f16));
-
-    auto input0 = model->get_parameters().at(0);
-    auto input1 = model->get_parameters().at(1);
-    auto output0 = model->get_results().at(0);
-
-    auto get_ref_results = [&ref_model](const ov::Tensor& kv_cache, const ov::Tensor& new_token_data, const ov::Tensor& matmul_data) {
-        auto input0 = ref_model->get_parameters().at(0);
-        auto input1 = ref_model->get_parameters().at(1);
-        auto input2 = ref_model->get_parameters().at(2);
-        ngraph::helpers::resize_function(ref_model, {kv_cache.get_shape(), new_token_data.get_shape(), matmul_data.get_shape()});
-        return ngraph::helpers::interpretFunction(ref_model, {{input0, kv_cache}, {input1, new_token_data}, {input2, matmul_data}});
-    };
-
-    auto compare_tensors = [&model](const std::vector<ov::Tensor> expected, const std::vector<ov::Tensor>& actual) {
-            ASSERT_EQ(expected.size(), actual.size());
-            ASSERT_EQ(expected.size(), model->get_results().size());
-            auto compareMap = ov::test::utils::getCompareMap();
-            const auto& results = model->get_results();
-            for (size_t j = 0; j < results.size(); j++) {
-                const auto result = results[j];
-                for (size_t i = 0; i < result->get_input_size(); ++i) {
-                    std::shared_ptr<ov::Node> inputNode = result->get_input_node_shared_ptr(i);
-                    if (std::dynamic_pointer_cast<ov::op::v0::Convert>(inputNode)) {
-                        std::shared_ptr<ov::Node> nextNodePtr = inputNode->get_input_node_shared_ptr(0);
-                        if (!ngraph::is_type<ov::op::v0::Result>(nextNodePtr)) {
-                            inputNode = nextNodePtr;
-                        }
-                    }
-                    auto it = compareMap.find(inputNode->get_type_info());
-                    ASSERT_NE(it, compareMap.end());
-                    it->second(inputNode, i, expected[j], actual[j], 1e-4f, 1e-4f);
-                }
-            }
-    };
-
-    auto infer_request = compiled_model.create_infer_request();
-    auto matmul_out = infer_request.get_tensor(output0);
-    auto new_token_input = infer_request.get_tensor(input0);
-    auto matmul_input = infer_request.get_tensor(input1);
-
-    infer_request.set_tensor(input0, new_token_input);
-    infer_request.set_tensor(input1, matmul_input);
-
-    ov::Tensor ref_kv_cache;
-
-    {
-        const ov::Shape new_token_size_initial = {batch, context_size, n_heads, n_features};
-        const ov::Shape kv_cache_size_initial = {batch, n_heads, cache_size, n_features};
-        const ov::Shape matmul_in_size_initial = {batch, n_heads, context_size, context_size};
-
-        auto new_token_data = ov::test::utils::create_and_fill_tensor(element_type, new_token_size_initial);
-        auto matmul_data = ov::test::utils::create_and_fill_tensor(element_type, matmul_in_size_initial);
-
-        new_token_input.set_shape(new_token_data.get_shape());
-        matmul_input.set_shape(matmul_data.get_shape());
-
-        new_token_data.copy_to(new_token_input);
-        matmul_data.copy_to(matmul_input);
-
-        ref_kv_cache = ov::Tensor(element_type, kv_cache_size_initial);
-
-        auto ref_results = get_ref_results(ref_kv_cache, new_token_data, matmul_data);
-        ref_kv_cache = ref_results[0];
-
-        infer_request.infer();
-
-        compare_tensors({ ref_results[1] }, {matmul_out});
-
-        cache_size += context_size;
-    }
-
-    const size_t input_tokens = 1;
-    const size_t niters = 10;
-    const ov::Shape new_token_size = {batch, input_tokens, n_heads, n_features};
-    size_t context_length = cache_size + input_tokens;
-    for (size_t i = 0; i < niters; i++, context_length += input_tokens) {
-        ov::Shape matmul_in_size_loop = {batch, n_heads, input_tokens, context_length};
-        auto new_token_data = ov::test::utils::create_and_fill_tensor(element_type, new_token_size);
-        auto matmul_data = ov::test::utils::create_and_fill_tensor(element_type, matmul_in_size_loop);
-        auto ref_results = get_ref_results(ref_kv_cache, new_token_data, matmul_data);
-        ref_kv_cache = ref_results[0];
-
-        new_token_input.set_shape(new_token_data.get_shape());
-        matmul_input.set_shape(matmul_data.get_shape());
-        new_token_data.copy_to(new_token_input);
-        matmul_data.copy_to(matmul_input);
-
-        infer_request.infer();
-
-        compare_tensors({ ref_results[1] }, {matmul_out});
-    }
+TEST_F(KVCacheTests, smoke_multipleIterations_cached) {
+    this->test_smoke_multipleIterations(true);
 }
 
+TEST_F(KVCacheTests, smoke_multipleIterations_stateful) {
+    this->test_smoke_multipleIterations_stateful(false);
+}
+
+TEST_F(KVCacheTests, smoke_multipleIterations_stateful_cached) {
+    this->test_smoke_multipleIterations_stateful(true);
+}
 } // namespace SubgraphTestsDefinitions
diff --git a/src/plugins/intel_gpu/tests/functional/subgraph_tests/dynamic/read_value_assign.cpp b/src/plugins/intel_gpu/tests/functional/subgraph_tests/dynamic/read_value_assign.cpp
index 2bab22153ed..25a6b3c23c1 100644
--- a/src/plugins/intel_gpu/tests/functional/subgraph_tests/dynamic/read_value_assign.cpp
+++ b/src/plugins/intel_gpu/tests/functional/subgraph_tests/dynamic/read_value_assign.cpp
@@ -2,9 +2,9 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-#include <openvino/opsets/opset1.hpp>
-#include <common_test_utils/ov_tensor_utils.hpp>
-
+#include "openvino/opsets/opset1.hpp"
+#include "common_test_utils/ov_tensor_utils.hpp"
+#include "common_test_utils/file_utils.hpp"
 #include "ov_models/builders.hpp"
 #include "ov_models/utils/ov_helpers.hpp"
 #include "shared_test_classes/base/layer_test_utils.hpp"
@@ -72,8 +72,31 @@ protected:
 };
 
 TEST_P(ReadValueAssignGPUTest, CompareWithRefs) {
-   SKIP_IF_CURRENT_TEST_IS_DISABLED()
-   run();
+    SKIP_IF_CURRENT_TEST_IS_DISABLED()
+    run();
+}
+
+TEST_P(ReadValueAssignGPUTest, CompareWithRefs_cached) {
+    SKIP_IF_CURRENT_TEST_IS_DISABLED()
+
+    std::stringstream ss;
+    ss << "gpu_model_cache_" << std::hash<std::string>{}(
+          std::string(::testing::UnitTest::GetInstance()->current_test_info()->test_suite_name()) +
+          std::string(::testing::UnitTest::GetInstance()->current_test_info()->name()));
+    std::string cacheDirName = ss.str();
+    {
+        ov::test::utils::removeFilesWithExt(cacheDirName, "blob");
+        ov::test::utils::removeFilesWithExt(cacheDirName, "cl_cache");
+        ov::test::utils::removeDir(cacheDirName);
+        core->set_property(ov::cache_dir(cacheDirName));
+        compile_model();
+    }
+    {
+        run();
+        ov::test::utils::removeFilesWithExt(cacheDirName, "blob");
+        ov::test::utils::removeFilesWithExt(cacheDirName, "cl_cache");
+        ov::test::utils::removeDir(cacheDirName);
+    }
 }
 
 namespace {
diff --git a/src/plugins/intel_gpu/tests/functional/subgraph_tests/dynamic/rms_norm_decomposition.cpp b/src/plugins/intel_gpu/tests/functional/subgraph_tests/dynamic/rms_norm_decomposition.cpp
index 2ea4fc415b5..60cc7202073 100644
--- a/src/plugins/intel_gpu/tests/functional/subgraph_tests/dynamic/rms_norm_decomposition.cpp
+++ b/src/plugins/intel_gpu/tests/functional/subgraph_tests/dynamic/rms_norm_decomposition.cpp
@@ -3,6 +3,8 @@
 //
 
 #include "ov_models/builders.hpp"
+#include "common_test_utils/file_utils.hpp"
+#include "random_generator.hpp"
 #include "shared_test_classes/base/layer_test_utils.hpp"
 #include "shared_test_classes/base/ov_subgraph.hpp"
 
@@ -131,6 +133,29 @@ TEST_P(RMSNormDecomposition, CompareWithRefs) {
     run();
 }
 
+TEST_P(RMSNormDecomposition, CompareWithRefs_cached) {
+    SKIP_IF_CURRENT_TEST_IS_DISABLED()
+
+    std::stringstream ss;
+    ss << "gpu_model_cache_" << std::hash<std::string>{}(
+          std::string(::testing::UnitTest::GetInstance()->current_test_info()->test_suite_name()) +
+          std::string(::testing::UnitTest::GetInstance()->current_test_info()->name()));
+    std::string cacheDirName = ss.str();
+    {
+        ov::test::utils::removeFilesWithExt(cacheDirName, "blob");
+        ov::test::utils::removeFilesWithExt(cacheDirName, "cl_cache");
+        ov::test::utils::removeDir(cacheDirName);
+        core->set_property(ov::cache_dir(cacheDirName));
+        compile_model();
+    }
+    {
+        run();
+        ov::test::utils::removeFilesWithExt(cacheDirName, "blob");
+        ov::test::utils::removeFilesWithExt(cacheDirName, "cl_cache");
+        ov::test::utils::removeDir(cacheDirName);
+    }
+}
+
 namespace {
 
 const std::vector<ov::test::ElementType> input_precisions = {ov::element::f32, ov::element::f16};
diff --git a/src/plugins/intel_gpu/tests/unit/test_cases/condition_gpu_test.cpp b/src/plugins/intel_gpu/tests/unit/test_cases/condition_gpu_test.cpp
index b32ab461ae2..75764e26ccb 100644
--- a/src/plugins/intel_gpu/tests/unit/test_cases/condition_gpu_test.cpp
+++ b/src/plugins/intel_gpu/tests/unit/test_cases/condition_gpu_test.cpp
@@ -72,7 +72,7 @@ public:
         return converted_data_vec;
     }
 
-    void run_test() {
+    void run_test(bool is_caching_test = false) {
         auto& engine = get_test_engine();
 
         auto dat_dt = static_cast<ov::element::Type>(ov::element::from<typename ConditionDataType::type>());
@@ -122,25 +122,25 @@ public:
             eltwise(output_id, { input_info(cond_id), input_info(scale_data_id) }, eltwise_mode::prod)
         );
 
-        network net(engine, topology, config);
+        network::ptr net = get_network(engine, topology, config, get_test_stream_ptr(), is_caching_test);
         set_values(input, convert_data({ 1, 2, 3, 4 }));
         set_values(scale_mem, convert_data({ 10 }));
-        net.set_input_data(input_id, input);
-        net.set_input_data(scale_data_id, scale_mem);
+        net->set_input_data(input_id, input);
+        net->set_input_data(scale_data_id, scale_mem);
 
-        decltype(net.execute()) out;
+        decltype(net->execute()) out;
 
         //WHEN TRUE
         set_values(predicate, { 1 });
-        net.set_input_data(pred_id, predicate);
-        out = net.execute();
+        net->set_input_data(pred_id, predicate);
+        out = net->execute();
         auto out_data_true = out.at(output_id).get_memory();
         ASSERT_TRUE(is_output_equal(out_data_true, convert_data({ 20, 40 })));
 
         //WHEN FALSE
         set_values(predicate, { 0 });
-        net.set_input_data(pred_id, predicate);
-        out = net.execute();
+        net->set_input_data(pred_id, predicate);
+        out = net->execute();
         auto out_data_false = out.at(output_id).get_memory();
         ASSERT_TRUE(is_output_equal(out_data_false, convert_data({ 15, 35 })));
     }
@@ -155,671 +155,750 @@ TYPED_TEST(condition_gpu_basic_test, simple_basic_test) {
     this->run_test();
 }
 
-TEST(condition_gpu, basic_range_equal_comp) {
-    auto& engine = get_test_engine();
-    ExecutionConfig config = get_test_default_config(engine);
-    config.set_property(ov::intel_gpu::optimize_data(true));
-    auto input0 = engine.allocate_memory({ data_types::f32, format::bfyx,{ 1, 1, 2, 1 } });
-    auto input1 = engine.allocate_memory({ data_types::f32, format::bfyx,{ 1, 1, 2, 1 } });
-
-    auto predicate = engine.allocate_memory({ data_types::u8, format::bfyx,{ 1, 1, 1, 1 } });
-
-    primitive_id condi_id = "condi";
-    primitive_id branch_input_id = "branch_input";
-    primitive_id concat_id = "concat";
-
-    cldnn::topology topology;
-    topology.add(
-        input_layout("input0", input0->get_layout())
-    );
-    topology.add(
-        input_layout("input1", input1->get_layout())
-    );
-    topology.add(
-        input_layout("predicate", predicate->get_layout())
-    );
-    topology.add(
-        concatenation("concat", { input_info("input0"), input_info("input1") }, 3)
-    );
-
-    condition::branch branch_true;
-    {
-        cldnn::topology branch_true_topology  = generate_simple_branch(true,  condi_id, branch_input_id);
-        branch_true.inner_program = program::build_program(engine, branch_true_topology, config, false, false, true);
-        branch_true.input_map.insert({concat_id, branch_input_id});
-        branch_true.output_map.insert({0, "condi_when_true"});
-    }
-    condition::branch branch_false;
-    {
-        cldnn::topology branch_false_topology = generate_simple_branch(false, condi_id, branch_input_id);
-        branch_false.inner_program = program::build_program(engine, branch_false_topology, config, false, false, true);
-        branch_false.input_map.insert({concat_id, branch_input_id});
-        branch_false.output_map.insert({0, "condi_when_false"});
-    }
-
-    topology.add(
-        condition("condi", {input_info("predicate"), input_info("concat")}, branch_true, branch_false)
-    );
-
-    std::vector<float> input0_data = {
-        1, 2
-    };
-    std::vector<float> input1_data = {
-        3, 4
-    };
-    std::vector<uint8_t> predicate_data_true = {
-        1
-    };
-    std::vector<float> pooling_when_true_data = {
-        2, 4
-    };
-    std::vector<uint8_t> predicate_data_false = {
-        0
-    };
-    std::vector<float> pooling_when_false_data = {
-        1.5, 3.5
-    };
-
-    set_values(input0, input0_data);
-    set_values(input1, input1_data);
-    network net(engine, topology, config);
-    net.set_input_data("input0", input0);
-    net.set_input_data("input1", input1);
-
-    decltype(net.execute()) outputs;
-
-    //CHECK TRUE
-    set_values(predicate, predicate_data_true);
-    net.set_input_data("predicate", predicate);
-    outputs = net.execute();
-
-    auto out_data_true = outputs.at("condi").get_memory();
-    ASSERT_TRUE(is_output_equal(out_data_true, pooling_when_true_data));
-
-    //CHECK FALSE
-    set_values(predicate, predicate_data_false);
-    net.set_input_data("predicate", predicate);
-    outputs = net.execute();
-
-    auto out_data_false = outputs.at("condi").get_memory();
-    ASSERT_TRUE(is_output_equal(out_data_false, pooling_when_false_data));
+TYPED_TEST(condition_gpu_basic_test, simple_basic_test_cached) {
+    this->run_test(true);
 }
 
-TEST(condition_gpu, dynamic_shapes) {
-    auto& engine = get_test_engine();
-    ExecutionConfig config = get_test_default_config(engine);
-    config.set_property(ov::intel_gpu::optimize_data(true));
-    config.set_property(ov::intel_gpu::allow_new_shape_infer(true));
-    const int64_t d1 = 2;
-    const int64_t d2 = 4;
-    layout input_lay = {{-1, d1, -1, d2}, data_types::f32, format::bfyx};
+class condition_gpu_tests: public ::testing::Test {
+public:
+    void test_basic_range_equal_comp(bool is_caching_test) {
+        auto& engine = get_test_engine();
+        ExecutionConfig config = get_test_default_config(engine);
+        config.set_property(ov::intel_gpu::optimize_data(true));
+        auto input0 = engine.allocate_memory({ data_types::f32, format::bfyx,{ 1, 1, 2, 1 } });
+        auto input1 = engine.allocate_memory({ data_types::f32, format::bfyx,{ 1, 1, 2, 1 } });
 
-    auto predicate = engine.allocate_memory({{ 1 }, data_types::u8, format::bfyx });
+        auto predicate = engine.allocate_memory({ data_types::u8, format::bfyx,{ 1, 1, 1, 1 } });
 
-    const primitive_id condition_id = "condition";
-    const primitive_id condition_id_true = condition_id + "_when_true";
-    const primitive_id condition_id_false = condition_id + "_when_false";
-    const primitive_id branch_input_id = "branch_input";
-    const primitive_id model_input = "input";
-    const primitive_id predicate_input = "predicate";
-    const primitive_id tranpose = "transpose";
+        primitive_id condi_id = "condi";
+        primitive_id branch_input_id = "branch_input";
+        primitive_id concat_id = "concat";
 
-    cldnn::topology topology;
-    topology.add(input_layout(model_input, input_lay));
-    topology.add(input_layout(predicate_input, predicate->get_layout()));
-    topology.add(permute(tranpose, model_input, {1, 0, 2, 3}));
-    const float shift = 4.f;
+        cldnn::topology topology;
+        topology.add(
+            input_layout("input0", input0->get_layout())
+        );
+        topology.add(
+            input_layout("input1", input1->get_layout())
+        );
+        topology.add(
+            input_layout("predicate", predicate->get_layout())
+        );
+        topology.add(
+            concatenation("concat", { input_info("input0"), input_info("input1") }, 3)
+        );
 
-    auto generate_simple_branch = [&](bool branch_true_false, const primitive_id& input_id, const data_types dt) {
-        auto mem = engine.allocate_memory(layout{{d1, 1, 1, d2}, dt, format::bfyx});
+        condition::branch branch_true;
         {
-            cldnn::mem_lock<float> l(mem, get_test_stream());
-            for (size_t i = 0; i < mem->count(); i++) {
-                l.data()[i] = shift;
-            }
+            cldnn::topology branch_true_topology  = generate_simple_branch(true,  condi_id, branch_input_id);
+            branch_true.inner_program = program::build_program(engine, branch_true_topology, config, false, false, true);
+            branch_true.input_map.insert({concat_id, branch_input_id});
+            branch_true.output_map.insert({0, "condi_when_true"});
+        }
+        condition::branch branch_false;
+        {
+            cldnn::topology branch_false_topology = generate_simple_branch(false, condi_id, branch_input_id);
+            branch_false.inner_program = program::build_program(engine, branch_false_topology, config, false, false, true);
+            branch_false.input_map.insert({concat_id, branch_input_id});
+            branch_false.output_map.insert({0, "condi_when_false"});
         }
 
-        primitive_id const_id = "const_input";
-        eltwise_mode mode = branch_true_false ? eltwise_mode::sum : eltwise_mode::sub;
-        auto id = branch_true_false ? condition_id_true : condition_id_false;
-        cldnn::topology branch_topology(input_layout(input_id, { {d1, -1, -1, d2}, dt, format::bfyx }),
-                                        data(const_id, mem),
-                                        eltwise(id, {input_id, const_id}, mode)
+        topology.add(
+            condition("condi", {input_info("predicate"), input_info("concat")}, branch_true, branch_false)
         );
-        condition::branch branch;
-        branch.inner_program = program::build_program(engine, branch_topology, config, false, false, true);
-        branch.input_map.insert({tranpose, branch_input_id});
-        branch.output_map.insert({0, id});
 
-        return branch;
-    };
+        std::vector<float> input0_data = {
+            1, 2
+        };
+        std::vector<float> input1_data = {
+            3, 4
+        };
+        std::vector<uint8_t> predicate_data_true = {
+            1
+        };
+        std::vector<float> pooling_when_true_data = {
+            2, 4
+        };
+        std::vector<uint8_t> predicate_data_false = {
+            0
+        };
+        std::vector<float> pooling_when_false_data = {
+            1.5, 3.5
+        };
 
-    condition::branch branch_true = generate_simple_branch(true, branch_input_id, data_types::f32);
-    condition::branch branch_false = generate_simple_branch(false, branch_input_id, data_types::f32);
+        set_values(input0, input0_data);
+        set_values(input1, input1_data);
+        network::ptr net = get_network(engine, topology, config, get_test_stream_ptr(), is_caching_test);
+        net->set_input_data("input0", input0);
+        net->set_input_data("input1", input1);
 
-    topology.add(condition(condition_id, { input_info(predicate_input), tranpose }, branch_true, branch_false));
+        decltype(net->execute()) outputs;
 
-    tests::random_generator rg(GET_SUITE_NAME);
-    std::vector<uint8_t> predicate_data_true = { 1 };
-    std::vector<uint8_t> predicate_data_false = { 0 };
-
-    network net(engine, topology, config);
-
-    auto check_output = [](const cldnn::memory::ptr mem, const std::vector<float>& ref, ov::Shape expected_shape) {
-        ASSERT_EQ(mem->get_layout().get_shape(), expected_shape);
-        ASSERT_EQ(mem->count(), ref.size());
-        cldnn::mem_lock<float> ptr(mem, get_test_stream());
-        for (size_t i = 0; i < mem->get_layout().count(); i++) {
-            ASSERT_EQ(ptr[i], ref[i]) << "i = " << i;
-        }
-    };
-
-    for (size_t i = 0; i < 10; i++) {
-        layout l = {{1, d1, 1 + static_cast<int64_t>(i), d2}, data_types::f32, format::bfyx};
-        std::vector<float> input_data = rg.generate_random_1d<float>(l.count(), -10, 10);
-        auto mem = engine.allocate_memory(l);
-        std::vector<float> expected_result_when_true = input_data;
-        std::vector<float> expected_result_when_false = input_data;
-
-        for (size_t i = 0; i < input_data.size(); i++) {
-            expected_result_when_true[i] += shift;
-            expected_result_when_false[i] -= shift;
-        }
-
-        set_values(mem, input_data);
+        //CHECK TRUE
         set_values(predicate, predicate_data_true);
-        net.set_input_data(model_input, mem);
-        net.set_input_data(predicate_input, predicate);
-        auto outputs = net.execute();
-        check_output(outputs.at(condition_id).get_memory(), expected_result_when_true, {d1, 1, 1+i, d2});
+        net->set_input_data("predicate", predicate);
+        outputs = net->execute();
 
+        auto out_data_true = outputs.at("condi").get_memory();
+        ASSERT_TRUE(is_output_equal(out_data_true, pooling_when_true_data));
+
+        //CHECK FALSE
         set_values(predicate, predicate_data_false);
-        net.set_input_data(model_input, mem);
-        net.set_input_data(predicate_input, predicate);
-        outputs = net.execute();
-        check_output(outputs.at(condition_id).get_memory(), expected_result_when_false, {d1, 1, 1+i, d2});
+        net->set_input_data("predicate", predicate);
+        outputs = net->execute();
+
+        auto out_data_false = outputs.at("condi").get_memory();
+        ASSERT_TRUE(is_output_equal(out_data_false, pooling_when_false_data));
     }
-}
 
-// This case will check the layout of condition in these conditions.
-// - it re-allocated at primitive_inst::realloc_if_needed().
-// - it can be skip subgraph.
-TEST(condition_gpu, dynamic_shapes_skip_condition) {
-    auto& engine = get_test_engine();
-    ExecutionConfig config = get_test_default_config(engine);
-    config.set_property(ov::intel_gpu::optimize_data(true));
-    config.set_property(ov::intel_gpu::allow_new_shape_infer(true));
-    const int64_t d1 = 2;
-    const int64_t d2 = 4;
-    layout input_lay = {{-1, d1, -1, d2}, data_types::f32, format::bfyx};
+    void test_dynamic_shapes(bool is_caching_test) {
+        auto& engine = get_test_engine();
+        ExecutionConfig config = get_test_default_config(engine);
+        config.set_property(ov::intel_gpu::optimize_data(true));
+        config.set_property(ov::intel_gpu::allow_new_shape_infer(true));
+        const int64_t d1 = 2;
+        const int64_t d2 = 4;
+        layout input_lay = {{-1, d1, -1, d2}, data_types::f32, format::bfyx};
 
-    auto predicate = engine.allocate_memory({{ 1 }, data_types::u8, format::bfyx });
+        auto predicate = engine.allocate_memory({{ 1 }, data_types::u8, format::bfyx });
 
-    const primitive_id condition_id = "condition";
-    const primitive_id condition_id_true = condition_id + "_when_true";
-    const primitive_id condition_id_false = condition_id + "_when_false";
-    const primitive_id branch_input_id = "branch_input";
-    const primitive_id model_input = "input";
-    const primitive_id predicate_input = "predicate";
-    const primitive_id reorder_id = "reorder";
-    const primitive_id tranpose = "transpose";
+        const primitive_id condition_id = "condition";
+        const primitive_id condition_id_true = condition_id + "_when_true";
+        const primitive_id condition_id_false = condition_id + "_when_false";
+        const primitive_id branch_input_id = "branch_input";
+        const primitive_id model_input = "input";
+        const primitive_id predicate_input = "predicate";
+        const primitive_id tranpose = "transpose";
 
-    cldnn::topology topology;
-    topology.add(input_layout(model_input, input_lay));
-    topology.add(input_layout(predicate_input, predicate->get_layout()));
-    topology.add(permute(tranpose, model_input, {1, 0, 2, 3}));
+        cldnn::topology topology;
+        topology.add(input_layout(model_input, input_lay));
+        topology.add(input_layout(predicate_input, predicate->get_layout()));
+        topology.add(permute(tranpose, model_input, {1, 0, 2, 3}));
+        const float shift = 4.f;
 
-    auto generate_simple_branch = [&](bool branch_true_false, const primitive_id& input_id, const data_types dt) {
-        auto id = branch_true_false ? condition_id_true : condition_id_false;
-        cldnn::topology branch_topology(input_layout(input_id, { {d1, -1, -1, d2}, dt, format::bfyx }),
-                                        reorder(id, input_info(input_id), { {d1, -1, -1, d2}, dt, format::bfyx })
+        auto generate_simple_branch = [&](bool branch_true_false, const primitive_id& input_id, const data_types dt) {
+            auto mem = engine.allocate_memory(layout{{d1, 1, 1, d2}, dt, format::bfyx});
+            {
+                cldnn::mem_lock<float> l(mem, get_test_stream());
+                for (size_t i = 0; i < mem->count(); i++) {
+                    l.data()[i] = shift;
+                }
+            }
+
+            primitive_id const_id = "const_input";
+            eltwise_mode mode = branch_true_false ? eltwise_mode::sum : eltwise_mode::sub;
+            auto id = branch_true_false ? condition_id_true : condition_id_false;
+            cldnn::topology branch_topology(input_layout(input_id, { {d1, -1, -1, d2}, dt, format::bfyx }),
+                                            data(const_id, mem),
+                                            eltwise(id, {input_id, const_id}, mode)
+            );
+            condition::branch branch;
+            branch.inner_program = program::build_program(engine, branch_topology, config, false, false, true);
+            branch.input_map.insert({tranpose, branch_input_id});
+            branch.output_map.insert({0, id});
+
+            return branch;
+        };
+
+        condition::branch branch_true = generate_simple_branch(true, branch_input_id, data_types::f32);
+        condition::branch branch_false = generate_simple_branch(false, branch_input_id, data_types::f32);
+
+        topology.add(condition(condition_id, { input_info(predicate_input), tranpose }, branch_true, branch_false));
+
+        tests::random_generator rg(GET_SUITE_NAME);
+        std::vector<uint8_t> predicate_data_true = { 1 };
+        std::vector<uint8_t> predicate_data_false = { 0 };
+
+        network::ptr net = get_network(engine, topology, config, get_test_stream_ptr(), is_caching_test);
+
+        auto check_output = [](const cldnn::memory::ptr mem, const std::vector<float>& ref, ov::Shape expected_shape) {
+            ASSERT_EQ(mem->get_layout().get_shape(), expected_shape);
+            ASSERT_EQ(mem->count(), ref.size());
+            cldnn::mem_lock<float> ptr(mem, get_test_stream());
+            for (size_t i = 0; i < mem->get_layout().count(); i++) {
+                ASSERT_EQ(ptr[i], ref[i]) << "i = " << i;
+            }
+        };
+
+        for (size_t i = 0; i < 10; i++) {
+            layout l = {{1, d1, 1 + static_cast<int64_t>(i), d2}, data_types::f32, format::bfyx};
+            std::vector<float> input_data = rg.generate_random_1d<float>(l.count(), -10, 10);
+            auto mem = engine.allocate_memory(l);
+            std::vector<float> expected_result_when_true = input_data;
+            std::vector<float> expected_result_when_false = input_data;
+
+            for (size_t i = 0; i < input_data.size(); i++) {
+                expected_result_when_true[i] += shift;
+                expected_result_when_false[i] -= shift;
+            }
+
+            set_values(mem, input_data);
+            set_values(predicate, predicate_data_true);
+            net->set_input_data(model_input, mem);
+            net->set_input_data(predicate_input, predicate);
+            auto outputs = net->execute();
+            check_output(outputs.at(condition_id).get_memory(), expected_result_when_true, {d1, 1, 1+i, d2});
+
+            set_values(predicate, predicate_data_false);
+            net->set_input_data(model_input, mem);
+            net->set_input_data(predicate_input, predicate);
+            outputs = net->execute();
+            check_output(outputs.at(condition_id).get_memory(), expected_result_when_false, {d1, 1, 1+i, d2});
+        }
+    }
+
+    // This case will check the layout of condition in these conditions.
+    // - it re-allocated at primitive_inst::realloc_if_needed().
+    // - it can be skip subgraph.
+    void test_dynamic_shapes_skip_condition(bool is_caching_test) {
+        auto& engine = get_test_engine();
+        ExecutionConfig config = get_test_default_config(engine);
+        config.set_property(ov::intel_gpu::optimize_data(true));
+        config.set_property(ov::intel_gpu::allow_new_shape_infer(true));
+        const int64_t d1 = 2;
+        const int64_t d2 = 4;
+        layout input_lay = {{-1, d1, -1, d2}, data_types::f32, format::bfyx};
+
+        auto predicate = engine.allocate_memory({{ 1 }, data_types::u8, format::bfyx });
+
+        const primitive_id condition_id = "condition";
+        const primitive_id condition_id_true = condition_id + "_when_true";
+        const primitive_id condition_id_false = condition_id + "_when_false";
+        const primitive_id branch_input_id = "branch_input";
+        const primitive_id model_input = "input";
+        const primitive_id predicate_input = "predicate";
+        const primitive_id reorder_id = "reorder";
+        const primitive_id tranpose = "transpose";
+
+        cldnn::topology topology;
+        topology.add(input_layout(model_input, input_lay));
+        topology.add(input_layout(predicate_input, predicate->get_layout()));
+        topology.add(permute(tranpose, model_input, {1, 0, 2, 3}));
+
+        auto generate_simple_branch = [&](bool branch_true_false, const primitive_id& input_id, const data_types dt) {
+            auto id = branch_true_false ? condition_id_true : condition_id_false;
+            cldnn::topology branch_topology(input_layout(input_id, { {d1, -1, -1, d2}, dt, format::bfyx }),
+                                            reorder(id, input_info(input_id), { {d1, -1, -1, d2}, dt, format::bfyx })
+            );
+            condition::branch branch;
+            branch.inner_program = program::build_program(engine, branch_topology, config, false, false, true);
+            branch.input_map.insert({tranpose, branch_input_id});
+            branch.output_map.insert({0, id});
+
+            return branch;
+        };
+
+        condition::branch branch_true = generate_simple_branch(true, branch_input_id, data_types::f32);
+        condition::branch branch_false = generate_simple_branch(false, branch_input_id, data_types::f32);
+
+        topology.add(reorder(reorder_id, input_info(predicate_input), { {d1, -1, -1, d2}, data_types::f32, format::bfyx }));
+        topology.add(condition(condition_id, { reorder_id, tranpose }, branch_true, branch_false));
+
+        tests::random_generator rg(GET_SUITE_NAME);
+        std::vector<uint8_t> predicate_data_true = { 1 };
+        std::vector<uint8_t> predicate_data_false = { 0 };
+
+        network::ptr net = get_network(engine, topology, config, get_test_stream_ptr(), is_caching_test);
+
+        for (int i = 0; i < 10; i++) {
+            layout l = {{1, d1, 1 + static_cast<int64_t>(i), d2}, data_types::f32, format::bfyx};
+            std::vector<float> input_data = rg.generate_random_1d<float>(l.count(), -10, 10);
+            auto mem = engine.allocate_memory(l);
+
+            set_values(mem, input_data);
+            set_values(predicate, predicate_data_true);
+            net->set_input_data(model_input, mem);
+            net->set_input_data(predicate_input, predicate);
+            auto outputs = net->execute();
+
+            auto cond_layout = outputs.at(condition_id).get_layout();
+            ASSERT_TRUE(cond_layout.get_dim(2) == (i + 1));
+        }
+    }
+
+    void test_basic_stacked_ifs(bool is_caching_test) {
+        /*
+            <prims...>
+            <if>
+            <...>
+            <end_if>
+            <...>
+            <if>
+            <...>
+            <end_if>
+            <prims...>
+        */
+        auto& engine = get_test_engine();
+        ExecutionConfig config = get_test_default_config(engine);
+        config.set_property(ov::intel_gpu::optimize_data(true));
+        auto input = engine.allocate_memory({ data_types::f32, format::bfyx,{ 1, 1, 4, 1 } });
+        auto predicate = engine.allocate_memory({ data_types::f32, format::bfyx,{ 1, 1, 1, 1 } });
+        auto predicate2 = engine.allocate_memory({ data_types::f32, format::bfyx,{ 1, 1, 1, 1 } });
+
+        primitive_id input_id           = "input";
+        primitive_id pred_id            = "predicate";
+        primitive_id predicate2_id      = "predicate2";
+        primitive_id branch_input_id    = "branch_input";
+        primitive_id cond_id            = "condi";
+        primitive_id cond2_id           = "condi2";
+        primitive_id scale_data_id      = "scale_data";
+        primitive_id output_id          = "output";
+
+        topology condi_1_true = generate_simple_branch(true, cond_id, branch_input_id);
+        topology condi_1_false = generate_simple_branch(false, cond_id, branch_input_id);
+        topology condi_2_true;
+        condi_2_true.add(
+            input_layout(branch_input_id, { data_types::f32, format::bfyx,{ 1, 1, 2, 1 } }),
+            activation("activ_when_true", input_info(branch_input_id), activation_func::log2)
+        );
+        topology condi_2_false;
+        condi_2_false.add(
+            input_layout(branch_input_id, { data_types::f32, format::bfyx,{ 1, 1, 2, 1 } }),
+            activation("activ_when_false", input_info(branch_input_id), activation_func::relu)
         );
-        condition::branch branch;
-        branch.inner_program = program::build_program(engine, branch_topology, config, false, false, true);
-        branch.input_map.insert({tranpose, branch_input_id});
-        branch.output_map.insert({0, id});
 
-        return branch;
-    };
+        condition::branch branch_condi_1_true;
+        branch_condi_1_true.inner_program = program::build_program(engine, condi_1_true, config, false, false, true);
+        branch_condi_1_true.input_map.insert({input_id, branch_input_id});
+        branch_condi_1_true.output_map.insert({0, "condi_when_true"});
 
-    condition::branch branch_true = generate_simple_branch(true, branch_input_id, data_types::f32);
-    condition::branch branch_false = generate_simple_branch(false, branch_input_id, data_types::f32);
+        condition::branch branch_condi_1_false;
+        branch_condi_1_false.inner_program = program::build_program(engine, condi_1_false, config, false, false, true);
+        branch_condi_1_false.input_map.insert({input_id, branch_input_id});
+        branch_condi_1_false.output_map.insert({0, "condi_when_false"});
 
-    topology.add(reorder(reorder_id, input_info(predicate_input), { {d1, -1, -1, d2}, data_types::f32, format::bfyx }));
-    topology.add(condition(condition_id, { reorder_id, tranpose }, branch_true, branch_false));
+        condition::branch branch_condi_2_true;
+        branch_condi_2_true.inner_program = program::build_program(engine, condi_2_true, config, false, false, true);
+        branch_condi_2_true.input_map.insert({cond_id, branch_input_id});
+        branch_condi_2_true.output_map.insert({0, "activ_when_true"});
 
-    tests::random_generator rg(GET_SUITE_NAME);
-    std::vector<uint8_t> predicate_data_true = { 1 };
-    std::vector<uint8_t> predicate_data_false = { 0 };
+        condition::branch branch_condi_2_false;
+        branch_condi_2_false.inner_program = program::build_program(engine, condi_2_false, config, false, false, true);
+        branch_condi_2_false.input_map.insert({cond_id, branch_input_id});
+        branch_condi_2_false.output_map.insert({0, "activ_when_false"});
 
-    network net(engine, topology, config);
+        topology topology;
+        topology.add(
+            input_layout(input_id, input->get_layout())
+        );
+        topology.add(
+            input_layout(pred_id, predicate->get_layout())
+        );
+        topology.add(
+            condition(cond_id, { input_info(pred_id), input_info(input_id) }, branch_condi_1_true, branch_condi_1_false)
+        );
+        topology.add(
+            input_layout(predicate2_id, predicate2->get_layout())
+        );
+        topology.add(
+            condition(cond2_id, { input_info(predicate2_id), input_info(cond_id) }, branch_condi_2_true, branch_condi_2_false)
+        );
 
-    for (int i = 0; i < 10; i++) {
-        layout l = {{1, d1, 1 + static_cast<int64_t>(i), d2}, data_types::f32, format::bfyx};
-        std::vector<float> input_data = rg.generate_random_1d<float>(l.count(), -10, 10);
-        auto mem = engine.allocate_memory(l);
+        std::vector<float> input_data = {
+            1, 2, 3, 4
+        };
+        std::vector<uint8_t> predicate_data = {
+            1
+        };
+        std::vector<uint8_t> predicate_2_data = {
+            0
+        };
+        set_values(input, input_data);
+        set_values(predicate, predicate_data);
+        set_values(predicate2, predicate_2_data);
 
-        set_values(mem, input_data);
-        set_values(predicate, predicate_data_true);
-        net.set_input_data(model_input, mem);
-        net.set_input_data(predicate_input, predicate);
-        auto outputs = net.execute();
+        network::ptr net = get_network(engine, topology, config, get_test_stream_ptr(), is_caching_test);
+        net->set_input_data(input_id, input);
+        net->set_input_data(pred_id, predicate);
+        net->set_input_data(predicate2_id, predicate2);
+        auto outputs = net->execute();
 
-        auto cond_layout = outputs.at(condition_id).get_layout();
-        ASSERT_TRUE(cond_layout.get_dim(2) == (i + 1));
+        std::vector<float> ref_data = {
+            2.0f, 4.0f
+        };
+        auto out_data = outputs.at(cond2_id).get_memory();
+        ASSERT_TRUE(is_output_equal(out_data, ref_data));
     }
-}
 
-TEST(condition_gpu, basic_stacked_ifs) {
-    /*
+    void test_basic_nested_ifs(bool is_caching_test) {
+        /*
         <prims...>
-        <if>
+        <if 0>
         <...>
-        <end_if>
+        <if 1>
         <...>
-        <if>
+        <end_if 1>
         <...>
-        <end_if>
+        <end_if 0>
         <prims...>
-    */
-    auto& engine = get_test_engine();
-    ExecutionConfig config = get_test_default_config(engine);
-    config.set_property(ov::intel_gpu::optimize_data(true));
-    auto input = engine.allocate_memory({ data_types::f32, format::bfyx,{ 1, 1, 4, 1 } });
-    auto predicate = engine.allocate_memory({ data_types::f32, format::bfyx,{ 1, 1, 1, 1 } });
-    auto predicate2 = engine.allocate_memory({ data_types::f32, format::bfyx,{ 1, 1, 1, 1 } });
+        */
+        auto& engine = get_test_engine();
+        ExecutionConfig config = get_test_default_config(engine);
+        config.set_property(ov::intel_gpu::optimize_data(true));
+        auto input = engine.allocate_memory({ data_types::f32, format::bfyx,{ 1, 1, 4, 1 } });
+        auto predicate = engine.allocate_memory({ data_types::f32, format::bfyx,{ 1, 1, 1, 1 } });
+        auto predicate2 = engine.allocate_memory({ data_types::f32, format::bfyx,{ 1, 1, 1, 1 } });
+        auto scale_5_mem = engine.allocate_memory({ data_types::f32, format::bfyx,{ 1, 1, 1, 1 } });
+        set_values(scale_5_mem, { 5.0f });
+        auto scale_10_mem = engine.allocate_memory({ data_types::f32, format::bfyx,{ 1, 1, 1, 1 } });
+        set_values(scale_10_mem, { 10.0f });
 
-    primitive_id input_id           = "input";
-    primitive_id pred_id            = "predicate";
-    primitive_id predicate2_id      = "predicate2";
-    primitive_id branch_input_id    = "branch_input";
-    primitive_id cond_id            = "condi";
-    primitive_id cond2_id           = "condi2";
-    primitive_id scale_data_id      = "scale_data";
-    primitive_id output_id          = "output";
+        condition::branch nested_true;
+        {
+            cldnn::topology nested_true_topology;
+            nested_true_topology.add(
+                input_layout("branch_input1", { data_types::f32, format::bfyx,{ 1, 1, 2, 1 } }),
+                data("scale_5_data", scale_5_mem),
+                eltwise("scale_5", { input_info("branch_input1"), input_info("scale_5_data") }, eltwise_mode::prod)
+            );
+            nested_true.inner_program = program::build_program(engine, nested_true_topology, config, false, false, true);
+            nested_true.input_map.insert({"pooling_when_true", "branch_input1"});
+            nested_true.output_map.insert({0, "scale_5"});
+        }
+        condition::branch nested_false;
+        {
+            cldnn::topology nested_false_topology;
+            nested_false_topology.add(
+                input_layout("branch_input2", { data_types::f32, format::bfyx,{ 1, 1, 2, 1 } }),
+                data("scale_10_data", scale_10_mem),
+                eltwise("scale_10", { input_info("branch_input2"), input_info("scale_10_data") }, eltwise_mode::prod)
+            );
+            nested_false.inner_program = program::build_program(engine, nested_false_topology, config, false, false, true);
+            nested_false.input_map.insert({"pooling_when_true", "branch_input2"});
+            nested_false.output_map.insert({0, "scale_10"});
+        }
 
-    topology condi_1_true = generate_simple_branch(true, cond_id, branch_input_id);
-    topology condi_1_false = generate_simple_branch(false, cond_id, branch_input_id);
-    topology condi_2_true;
-    condi_2_true.add(
-        input_layout(branch_input_id, { data_types::f32, format::bfyx,{ 1, 1, 2, 1 } }),
-        activation("activ_when_true", input_info(branch_input_id), activation_func::log2)
-    );
-    topology condi_2_false;
-    condi_2_false.add(
-        input_layout(branch_input_id, { data_types::f32, format::bfyx,{ 1, 1, 2, 1 } }),
-        activation("activ_when_false", input_info(branch_input_id), activation_func::relu)
-    );
+        condition::branch branch_true;
+        {
+            cldnn::topology branch_true_topology;
+            branch_true_topology.add(
+                input_layout("branch_input3", { data_types::f32, format::bfyx,{ 1, 1, 4, 1 } }),
+                pooling("pooling_when_true", input_info("branch_input3"), cldnn::pooling_mode::max, { 1, 2 }, { 1, 2 }),
+                input_layout("predicate2", predicate2->get_layout()),
+                condition( "condi_nested", {input_info("predicate2"), input_info("pooling_when_true")}, nested_true, nested_false)
+            );
+            branch_true.inner_program = program::build_program(engine, branch_true_topology, config, false, false, true);
+            branch_true.input_map.insert({"input", "branch_input3"});
+            branch_true.output_map.insert({0, "condi_nested"});
+        }
 
-    condition::branch branch_condi_1_true;
-    branch_condi_1_true.inner_program = program::build_program(engine, condi_1_true, config, false, false, true);
-    branch_condi_1_true.input_map.insert({input_id, branch_input_id});
-    branch_condi_1_true.output_map.insert({0, "condi_when_true"});
+        condition::branch branch_false;
+        {
+            cldnn::topology branch_false_topology;
+            branch_false_topology.add(
+                input_layout("branch_input4", { data_types::f32, format::bfyx,{ 1, 1, 4, 1 } }),
+                pooling("pooling_when_false", input_info("branch_input4"), cldnn::pooling_mode::average, { 1, 2 }, { 1, 2 })
+            );
+            branch_false.inner_program = program::build_program(engine, branch_false_topology, config, false, false, true);
+            branch_false.input_map.insert({"input", "branch_input4"});
+            branch_false.output_map.insert({0, "pooling_when_false"});
+        }
 
-    condition::branch branch_condi_1_false;
-    branch_condi_1_false.inner_program = program::build_program(engine, condi_1_false, config, false, false, true);
-    branch_condi_1_false.input_map.insert({input_id, branch_input_id});
-    branch_condi_1_false.output_map.insert({0, "condi_when_false"});
+        cldnn::topology topology;
+        topology.add(
+            input_layout("input", input->get_layout())
+        );
 
-    condition::branch branch_condi_2_true;
-    branch_condi_2_true.inner_program = program::build_program(engine, condi_2_true, config, false, false, true);
-    branch_condi_2_true.input_map.insert({cond_id, branch_input_id});
-    branch_condi_2_true.output_map.insert({0, "activ_when_true"});
+        topology.add(
+            input_layout("predicate", predicate->get_layout())
+        );
 
-    condition::branch branch_condi_2_false;
-    branch_condi_2_false.inner_program = program::build_program(engine, condi_2_false, config, false, false, true);
-    branch_condi_2_false.input_map.insert({cond_id, branch_input_id});
-    branch_condi_2_false.output_map.insert({0, "activ_when_false"});
+        topology.add(
+            condition("condi", {input_info("predicate"), input_info("input")}, branch_true, branch_false)
+        );
 
-    topology topology;
-    topology.add(
-        input_layout(input_id, input->get_layout())
-    );
-    topology.add(
-        input_layout(pred_id, predicate->get_layout())
-    );
-    topology.add(
-        condition(cond_id, { input_info(pred_id), input_info(input_id) }, branch_condi_1_true, branch_condi_1_false)
-    );
-    topology.add(
-        input_layout(predicate2_id, predicate2->get_layout())
-    );
-    topology.add(
-        condition(cond2_id, { input_info(predicate2_id), input_info(cond_id) }, branch_condi_2_true, branch_condi_2_false)
-    );
+        std::vector<float> input_data = {
+            1.0f, 2.0f, 3.0f, 4.0f
+        };
+        std::vector<float> predicate_data = {
+            1.0f
+        };
+        std::vector<float> predicate_2_data = {
+            2.0f, 4.0f
+        };
+        set_values(input, input_data);
+        set_values(predicate, predicate_data);
+        set_values(predicate2, predicate_2_data);
 
-    std::vector<float> input_data = {
-        1, 2, 3, 4
-    };
-    std::vector<uint8_t> predicate_data = {
-        1
-    };
-    std::vector<uint8_t> predicate_2_data = {
-        0
-    };
-    set_values(input, input_data);
-    set_values(predicate, predicate_data);
-    set_values(predicate2, predicate_2_data);
+        network::ptr net = get_network(engine, topology, config, get_test_stream_ptr(), is_caching_test);
+        net->set_input_data("input", input);
+        net->set_input_data("predicate", predicate);
+        net->set_input_data("predicate2", predicate2);
+        auto outputs = net->execute();
 
-    network net(engine, topology, config);
-    net.set_input_data(input_id, input);
-    net.set_input_data(pred_id, predicate);
-    net.set_input_data(predicate2_id, predicate2);
-    auto outputs = net.execute();
+        auto out_data = outputs.at("condi").get_memory();
+        ASSERT_TRUE(is_output_equal(out_data, std::vector<float>({ 10.0f, 20.0f })));
+    }
 
-    std::vector<float> ref_data = {
-        2.0f, 4.0f
-    };
-    auto out_data = outputs.at(cond2_id).get_memory();
-    ASSERT_TRUE(is_output_equal(out_data, ref_data));
+    void test_negative_predicate_wrong_layout(bool is_caching_test) {
+        auto& engine = get_test_engine();
+        ExecutionConfig config = get_test_default_config(engine);
+        config.set_property(ov::intel_gpu::optimize_data(true));
+        auto input = engine.allocate_memory({ data_types::f32, format::bfyx,{ 1, 1, 4, 1 } });
+        auto predicate = engine.allocate_memory({ data_types::f32, format::bfyx,{ 1, 1, 5, 1 } });
+
+        primitive_id input_id           = "input";
+        primitive_id pred_id            = "predicate";
+        primitive_id branch_input_id    = "branch_input";
+        primitive_id cond_id            = "condi";
+
+        condition::branch branch_true;
+        {
+            cldnn::topology branch_true_topology   = generate_simple_branch(true,  cond_id, branch_input_id, data_types::f32);
+            branch_true.inner_program = program::build_program(engine, branch_true_topology, config, false, false, true);
+            branch_true.input_map.insert({input_id, branch_input_id});
+            branch_true.output_map.insert({0, "condi_when_true"});
+        }
+        condition::branch branch_false;
+        {
+            cldnn::topology branch_false_topology  = generate_simple_branch(false, cond_id, branch_input_id, data_types::f32);
+            branch_false.inner_program = program::build_program(engine, branch_false_topology, config, false, false, true);
+            branch_false.input_map.insert({input_id, branch_input_id});
+            branch_false.output_map.insert({0, "condi_when_false"});
+        }
+
+        topology topology;
+        topology.add(
+            input_layout(input_id, input->get_layout())
+        );
+        topology.add(
+            input_layout(pred_id, predicate->get_layout())
+        );
+        topology.add(
+            condition(cond_id, {input_info(pred_id), input_info(input_id)}, branch_true, branch_false)
+        );
+
+        EXPECT_ANY_THROW(network::ptr net = get_network(engine, topology, config, get_test_stream_ptr(), is_caching_test););
+    }
+
+    void test_negative_not_same_layouts(bool is_caching_test) {
+        auto& engine = get_test_engine();
+        ExecutionConfig config = get_test_default_config(engine);
+        config.set_property(ov::intel_gpu::optimize_data(true));
+        auto input = engine.allocate_memory({ data_types::f32, format::bfyx,{ 1, 1, 4, 1 } });
+        auto predicate = engine.allocate_memory({ data_types::u8, format::bfyx,{ 1, 1, 1, 1 } });
+
+        primitive_id input_id           = "input";
+        primitive_id pred_id            = "predicate";
+        primitive_id branch_input_id    = "branch_input";
+        primitive_id cond_id            = "condi";
+
+        condition::branch branch_true;
+        {
+            primitive_id pool_id = "pooling_when_true";
+            topology branch_true_topology;
+            branch_true_topology.add(
+                input_layout(branch_input_id, { data_types::f32, format::bfyx,{ 1, 1, 4, 1 } }),
+                pooling(pool_id, input_info(branch_input_id), cldnn::pooling_mode::max, { 1, 2 }, { 1, 2 })
+            );
+            branch_true.inner_program = program::build_program(engine, branch_true_topology, config, false, false, true);
+            branch_true.input_map.insert({input_id, branch_input_id});
+            branch_true.output_map.insert({0, pool_id});
+        }
+
+        condition::branch branch_false;
+        {
+            primitive_id pool_id = "pooling_when_false";
+            topology branch_false_topology;
+            branch_false_topology.add(
+                input_layout(branch_input_id, { data_types::f32, format::bfyx,{ 1, 1, 4, 1 } }),
+                pooling(pool_id, input_info(branch_input_id), cldnn::pooling_mode::max, { 1, 4 }, { 1, 4 })
+            );
+            branch_false.inner_program = program::build_program(engine, branch_false_topology, config, false, false, true);
+            branch_false.input_map.insert({input_id, branch_input_id});
+            branch_false.output_map.insert({0, pool_id});
+        }
+
+
+        topology topology;
+        topology.add(
+            input_layout(input_id, input->get_layout())
+        );
+        topology.add(
+            input_layout(pred_id, predicate->get_layout())
+        );
+        topology.add(
+            condition(cond_id, {input_info(pred_id), input_info(input_id)}, branch_true, branch_false)
+        );
+
+        EXPECT_ANY_THROW(network::ptr net = get_network(engine, topology, config, get_test_stream_ptr(), is_caching_test););
+    }
+
+    void test_negative_same_names_within_different_networks(bool is_caching_test) {
+        auto& engine = get_test_engine();
+        ExecutionConfig config = get_test_default_config(engine);
+        config.set_property(ov::intel_gpu::optimize_data(true));
+        auto input = engine.allocate_memory({ data_types::f32, format::bfyx,{ 1, 1, 4, 1 } });
+        auto predicate = engine.allocate_memory({ data_types::u8, format::bfyx,{ 1, 1, 1, 1 } });
+
+        primitive_id input_id           = "input";
+        primitive_id pred_id         = "predicate";
+        primitive_id branch_input_id    = "branch_input";
+        primitive_id cond_id            = "condi";
+        primitive_id duplicated_id      = "pooling_check_name";
+
+        condition::branch branch_true;
+        {
+            topology branch_true_topology;
+            branch_true_topology.add(
+                input_layout(branch_input_id, { data_types::f32, format::bfyx,{ 1, 1, 4, 1 } }),
+                pooling(duplicated_id, input_info(branch_input_id), cldnn::pooling_mode::max, { 2, 1 }, { 2, 1 })
+            );
+            branch_true.inner_program = program::build_program(engine, branch_true_topology, config, false, false, true);
+            branch_true.input_map.insert({input_id, branch_input_id});
+            branch_true.output_map.insert({0, duplicated_id});
+        }
+
+        condition::branch branch_false;
+        {
+            topology branch_false_topology;
+            branch_false_topology.add(
+                input_layout(branch_input_id, { data_types::f32, format::bfyx,{ 1, 1, 4, 1 } }),
+                pooling("pooling_when_false", input_info(branch_input_id), cldnn::pooling_mode::max, { 2, 1 }, { 2, 1 })
+            );
+            branch_false.inner_program = program::build_program(engine, branch_false_topology, config, false, false, true);
+            branch_false.input_map.insert({input_id, branch_input_id});
+            branch_false.output_map.insert({0, "pooling_when_false"});
+        }
+
+        topology topology;
+        topology.add(
+            input_layout(input_id, input->get_layout())
+        );
+        topology.add(
+            input_layout(pred_id, predicate->get_layout())
+        );
+        topology.add(
+            condition(cond_id, {input_info(pred_id), input_info(input_id)}, branch_true, branch_false)
+        );
+        topology.add(
+            pooling(duplicated_id, input_info(cond_id), cldnn::pooling_mode::max, { 2, 1 }, { 2, 1 })
+        );
+
+        EXPECT_ANY_THROW(network::ptr net = get_network(engine, topology, config, get_test_stream_ptr(), is_caching_test););
+    }
+
+    void test_empty_body(bool is_caching_test) {
+        auto& engine = get_test_engine();
+        ExecutionConfig config = get_test_default_config(engine);
+        config.set_property(ov::intel_gpu::optimize_data(true));
+        auto input_mem = engine.allocate_memory({ data_types::f32, format::bfyx,{ 1, 1, 4, 1 } });
+        auto predicate_mem = engine.allocate_memory({ data_types::u8, format::bfyx,{ 1, 1, 1, 1 } });
+
+        primitive_id input_id1           = "input1";
+        primitive_id input_id2           = "input2";
+        primitive_id pred_id             = "predicate";
+        primitive_id branch_input_id1    = "branch_input1";
+        primitive_id branch_input_id2    = "branch_input2";
+        primitive_id cond_id             = "condi";
+
+        condition::branch branch_true;
+        {
+            topology branch_true_topology;
+            branch_true_topology.add(
+                input_layout(branch_input_id1, { data_types::f32, format::bfyx,{ 1, 1, 4, 1 } }),
+                input_layout(branch_input_id2, { data_types::f32, format::bfyx,{ 1, 1, 4, 1 } }),
+                eltwise("eltwise", { input_info(branch_input_id1), input_info(branch_input_id2) }, eltwise_mode::sum)
+            );
+            branch_true.inner_program = program::build_program(engine, branch_true_topology, config, false, false, true);
+            branch_true.input_map.insert({input_id1, branch_input_id1});
+            branch_true.input_map.insert({input_id2, branch_input_id2});
+            branch_true.output_map.insert({0, "eltwise"});
+        }
+
+        condition::branch branch_false;
+        {
+            topology branch_false_topology;
+            branch_false_topology.add(
+                input_layout(branch_input_id2, { data_types::f32, format::bfyx, { 1, 1, 4, 1 } }),
+                reorder("result", input_info(branch_input_id2), {data_types::f32, format::bfyx, {1, 1, 4, 1}})
+            );
+            branch_false.inner_program = program::build_program(engine, branch_false_topology, config, false, false, true);
+            branch_false.input_map.insert({input_id2, branch_input_id2});
+            branch_false.output_map.insert({0, "result"});
+        }
+
+        topology topology;
+        topology.add(input_layout(input_id1, input_mem->get_layout()));
+        topology.add(input_layout(input_id2, input_mem->get_layout()));
+        topology.add(input_layout(pred_id, predicate_mem->get_layout()));
+        topology.add(condition(cond_id, {input_info(pred_id), input_info(input_id1), input_info(input_id2)}, branch_true, branch_false)
+        );
+
+        network::ptr net = get_network(engine, topology, config, get_test_stream_ptr(), is_caching_test);
+        ASSERT_TRUE(net->get_primitive(cond_id)->get_node().as<condition>().get_branch_false().inner_program->can_be_optimized());
+        ASSERT_FALSE(net->get_primitive(cond_id)->get_node().as<condition>().get_branch_true().inner_program->can_be_optimized());
+    }
+};
+
+TEST_F(condition_gpu_tests, basic_range_equal_comp) {
+    this->test_basic_range_equal_comp(false);
 }
 
-TEST(condition_gpu, basic_nested_ifs) {
-    /*
-    <prims...>
-    <if 0>
-    <...>
-    <if 1>
-    <...>
-    <end_if 1>
-    <...>
-    <end_if 0>
-    <prims...>
-    */
-    auto& engine = get_test_engine();
-    ExecutionConfig config = get_test_default_config(engine);
-    config.set_property(ov::intel_gpu::optimize_data(true));
-    auto input = engine.allocate_memory({ data_types::f32, format::bfyx,{ 1, 1, 4, 1 } });
-    auto predicate = engine.allocate_memory({ data_types::f32, format::bfyx,{ 1, 1, 1, 1 } });
-    auto predicate2 = engine.allocate_memory({ data_types::f32, format::bfyx,{ 1, 1, 1, 1 } });
-    auto scale_5_mem = engine.allocate_memory({ data_types::f32, format::bfyx,{ 1, 1, 1, 1 } });
-    set_values(scale_5_mem, { 5.0f });
-    auto scale_10_mem = engine.allocate_memory({ data_types::f32, format::bfyx,{ 1, 1, 1, 1 } });
-    set_values(scale_10_mem, { 10.0f });
-
-    condition::branch nested_true;
-    {
-        cldnn::topology nested_true_topology;
-        nested_true_topology.add(
-            input_layout("branch_input1", { data_types::f32, format::bfyx,{ 1, 1, 2, 1 } }),
-            data("scale_5_data", scale_5_mem),
-            eltwise("scale_5", { input_info("branch_input1"), input_info("scale_5_data") }, eltwise_mode::prod)
-        );
-        nested_true.inner_program = program::build_program(engine, nested_true_topology, config, false, false, true);
-        nested_true.input_map.insert({"pooling_when_true", "branch_input1"});
-        nested_true.output_map.insert({0, "scale_5"});
-    }
-    condition::branch nested_false;
-    {
-        cldnn::topology nested_false_topology;
-        nested_false_topology.add(
-            input_layout("branch_input2", { data_types::f32, format::bfyx,{ 1, 1, 2, 1 } }),
-            data("scale_10_data", scale_10_mem),
-            eltwise("scale_10", { input_info("branch_input2"), input_info("scale_10_data") }, eltwise_mode::prod)
-        );
-        nested_false.inner_program = program::build_program(engine, nested_false_topology, config, false, false, true);
-        nested_false.input_map.insert({"pooling_when_true", "branch_input2"});
-        nested_false.output_map.insert({0, "scale_10"});
-    }
-
-    condition::branch branch_true;
-    {
-        cldnn::topology branch_true_topology;
-        branch_true_topology.add(
-            input_layout("branch_input3", { data_types::f32, format::bfyx,{ 1, 1, 4, 1 } }),
-            pooling("pooling_when_true", input_info("branch_input3"), cldnn::pooling_mode::max, { 1, 2 }, { 1, 2 }),
-            input_layout("predicate2", predicate2->get_layout()),
-            condition( "condi_nested", {input_info("predicate2"), input_info("pooling_when_true")}, nested_true, nested_false)
-        );
-        branch_true.inner_program = program::build_program(engine, branch_true_topology, config, false, false, true);
-        branch_true.input_map.insert({"input", "branch_input3"});
-        branch_true.output_map.insert({0, "condi_nested"});
-    }
-
-    condition::branch branch_false;
-    {
-        cldnn::topology branch_false_topology;
-        branch_false_topology.add(
-            input_layout("branch_input4", { data_types::f32, format::bfyx,{ 1, 1, 4, 1 } }),
-            pooling("pooling_when_false", input_info("branch_input4"), cldnn::pooling_mode::average, { 1, 2 }, { 1, 2 })
-        );
-        branch_false.inner_program = program::build_program(engine, branch_false_topology, config, false, false, true);
-        branch_false.input_map.insert({"input", "branch_input4"});
-        branch_false.output_map.insert({0, "pooling_when_false"});
-    }
-
-    cldnn::topology topology;
-    topology.add(
-        input_layout("input", input->get_layout())
-    );
-
-    topology.add(
-        input_layout("predicate", predicate->get_layout())
-    );
-
-    topology.add(
-        condition("condi", {input_info("predicate"), input_info("input")}, branch_true, branch_false)
-    );
-
-    std::vector<float> input_data = {
-        1.0f, 2.0f, 3.0f, 4.0f
-    };
-    std::vector<float> predicate_data = {
-        1.0f
-    };
-    std::vector<float> predicate_2_data = {
-        2.0f, 4.0f
-    };
-    set_values(input, input_data);
-    set_values(predicate, predicate_data);
-    set_values(predicate2, predicate_2_data);
-
-    network net(engine, topology, config);
-    net.set_input_data("input", input);
-    net.set_input_data("predicate", predicate);
-    net.set_input_data("predicate2", predicate2);
-    auto outputs = net.execute();
-
-    auto out_data = outputs.at("condi").get_memory();
-    ASSERT_TRUE(is_output_equal(out_data, std::vector<float>({ 10.0f, 20.0f })));
+TEST_F(condition_gpu_tests, basic_range_equal_comp_cached) {
+    this->test_basic_range_equal_comp(true);
 }
 
-TEST(condition_gpu, negative_predicate_wrong_layout) {
-    auto& engine = get_test_engine();
-    ExecutionConfig config = get_test_default_config(engine);
-    config.set_property(ov::intel_gpu::optimize_data(true));
-    auto input = engine.allocate_memory({ data_types::f32, format::bfyx,{ 1, 1, 4, 1 } });
-    auto predicate = engine.allocate_memory({ data_types::f32, format::bfyx,{ 1, 1, 5, 1 } });
-
-    primitive_id input_id           = "input";
-    primitive_id pred_id            = "predicate";
-    primitive_id branch_input_id    = "branch_input";
-    primitive_id cond_id            = "condi";
-
-    condition::branch branch_true;
-    {
-        cldnn::topology branch_true_topology   = generate_simple_branch(true,  cond_id, branch_input_id, data_types::f32);
-        branch_true.inner_program = program::build_program(engine, branch_true_topology, config, false, false, true);
-        branch_true.input_map.insert({input_id, branch_input_id});
-        branch_true.output_map.insert({0, "condi_when_true"});
-    }
-    condition::branch branch_false;
-    {
-        cldnn::topology branch_false_topology  = generate_simple_branch(false, cond_id, branch_input_id, data_types::f32);
-        branch_false.inner_program = program::build_program(engine, branch_false_topology, config, false, false, true);
-        branch_false.input_map.insert({input_id, branch_input_id});
-        branch_false.output_map.insert({0, "condi_when_false"});
-    }
-
-    topology topology;
-    topology.add(
-        input_layout(input_id, input->get_layout())
-    );
-    topology.add(
-        input_layout(pred_id, predicate->get_layout())
-    );
-    topology.add(
-        condition(cond_id, {input_info(pred_id), input_info(input_id)}, branch_true, branch_false)
-    );
-
-    EXPECT_ANY_THROW(network net(engine, topology, config););
+TEST_F(condition_gpu_tests, dynamic_shapes) {
+    this->test_dynamic_shapes(false);
 }
 
-TEST(condition_gpu, negative_not_same_layouts) {
-    auto& engine = get_test_engine();
-    ExecutionConfig config = get_test_default_config(engine);
-    config.set_property(ov::intel_gpu::optimize_data(true));
-    auto input = engine.allocate_memory({ data_types::f32, format::bfyx,{ 1, 1, 4, 1 } });
-    auto predicate = engine.allocate_memory({ data_types::u8, format::bfyx,{ 1, 1, 1, 1 } });
-
-    primitive_id input_id           = "input";
-    primitive_id pred_id            = "predicate";
-    primitive_id branch_input_id    = "branch_input";
-    primitive_id cond_id            = "condi";
-
-    condition::branch branch_true;
-    {
-        primitive_id pool_id = "pooling_when_true";
-        topology branch_true_topology;
-        branch_true_topology.add(
-            input_layout(branch_input_id, { data_types::f32, format::bfyx,{ 1, 1, 4, 1 } }),
-            pooling(pool_id, input_info(branch_input_id), cldnn::pooling_mode::max, { 1, 2 }, { 1, 2 })
-        );
-        branch_true.inner_program = program::build_program(engine, branch_true_topology, config, false, false, true);
-        branch_true.input_map.insert({input_id, branch_input_id});
-        branch_true.output_map.insert({0, pool_id});
-    }
-
-    condition::branch branch_false;
-    {
-        primitive_id pool_id = "pooling_when_false";
-        topology branch_false_topology;
-        branch_false_topology.add(
-            input_layout(branch_input_id, { data_types::f32, format::bfyx,{ 1, 1, 4, 1 } }),
-            pooling(pool_id, input_info(branch_input_id), cldnn::pooling_mode::max, { 1, 4 }, { 1, 4 })
-        );
-        branch_false.inner_program = program::build_program(engine, branch_false_topology, config, false, false, true);
-        branch_false.input_map.insert({input_id, branch_input_id});
-        branch_false.output_map.insert({0, pool_id});
-    }
-
-
-    topology topology;
-    topology.add(
-        input_layout(input_id, input->get_layout())
-    );
-    topology.add(
-        input_layout(pred_id, predicate->get_layout())
-    );
-    topology.add(
-        condition(cond_id, {input_info(pred_id), input_info(input_id)}, branch_true, branch_false)
-    );
-
-    EXPECT_ANY_THROW(network net(engine, topology, config););
+TEST_F(condition_gpu_tests, dynamic_shapes_cached) {
+    this->test_dynamic_shapes(true);
 }
 
-TEST(condition_gpu, negative_same_names_within_different_networks) {
-    auto& engine = get_test_engine();
-    ExecutionConfig config = get_test_default_config(engine);
-    config.set_property(ov::intel_gpu::optimize_data(true));
-    auto input = engine.allocate_memory({ data_types::f32, format::bfyx,{ 1, 1, 4, 1 } });
-    auto predicate = engine.allocate_memory({ data_types::u8, format::bfyx,{ 1, 1, 1, 1 } });
-
-    primitive_id input_id           = "input";
-    primitive_id pred_id         = "predicate";
-    primitive_id branch_input_id    = "branch_input";
-    primitive_id cond_id            = "condi";
-    primitive_id duplicated_id      = "pooling_check_name";
-
-    condition::branch branch_true;
-    {
-        topology branch_true_topology;
-        branch_true_topology.add(
-            input_layout(branch_input_id, { data_types::f32, format::bfyx,{ 1, 1, 4, 1 } }),
-            pooling(duplicated_id, input_info(branch_input_id), cldnn::pooling_mode::max, { 2, 1 }, { 2, 1 })
-        );
-        branch_true.inner_program = program::build_program(engine, branch_true_topology, config, false, false, true);
-        branch_true.input_map.insert({input_id, branch_input_id});
-        branch_true.output_map.insert({0, duplicated_id});
-    }
-
-    condition::branch branch_false;
-    {
-        topology branch_false_topology;
-        branch_false_topology.add(
-            input_layout(branch_input_id, { data_types::f32, format::bfyx,{ 1, 1, 4, 1 } }),
-            pooling("pooling_when_false", input_info(branch_input_id), cldnn::pooling_mode::max, { 2, 1 }, { 2, 1 })
-        );
-        branch_false.inner_program = program::build_program(engine, branch_false_topology, config, false, false, true);
-        branch_false.input_map.insert({input_id, branch_input_id});
-        branch_false.output_map.insert({0, "pooling_when_false"});
-    }
-
-    topology topology;
-    topology.add(
-        input_layout(input_id, input->get_layout())
-    );
-    topology.add(
-        input_layout(pred_id, predicate->get_layout())
-    );
-    topology.add(
-        condition(cond_id, {input_info(pred_id), input_info(input_id)}, branch_true, branch_false)
-    );
-    topology.add(
-        pooling(duplicated_id, input_info(cond_id), cldnn::pooling_mode::max, { 2, 1 }, { 2, 1 })
-    );
-
-    EXPECT_ANY_THROW(network net(engine, topology, config););
+TEST_F(condition_gpu_tests, dynamic_shapes_skip_condition) {
+    this->test_dynamic_shapes_skip_condition(false);
 }
 
-TEST(condition_gpu, empty_body) {
-    auto& engine = get_test_engine();
-    ExecutionConfig config = get_test_default_config(engine);
-    config.set_property(ov::intel_gpu::optimize_data(true));
-    auto input_mem = engine.allocate_memory({ data_types::f32, format::bfyx,{ 1, 1, 4, 1 } });
-    auto predicate_mem = engine.allocate_memory({ data_types::u8, format::bfyx,{ 1, 1, 1, 1 } });
-
-    primitive_id input_id1           = "input1";
-    primitive_id input_id2           = "input2";
-    primitive_id pred_id             = "predicate";
-    primitive_id branch_input_id1    = "branch_input1";
-    primitive_id branch_input_id2    = "branch_input2";
-    primitive_id cond_id             = "condi";
-
-    condition::branch branch_true;
-    {
-        topology branch_true_topology;
-        branch_true_topology.add(
-            input_layout(branch_input_id1, { data_types::f32, format::bfyx,{ 1, 1, 4, 1 } }),
-            input_layout(branch_input_id2, { data_types::f32, format::bfyx,{ 1, 1, 4, 1 } }),
-            eltwise("eltwise", { input_info(branch_input_id1), input_info(branch_input_id2) }, eltwise_mode::sum)
-        );
-        branch_true.inner_program = program::build_program(engine, branch_true_topology, config, false, false, true);
-        branch_true.input_map.insert({input_id1, branch_input_id1});
-        branch_true.input_map.insert({input_id2, branch_input_id2});
-        branch_true.output_map.insert({0, "eltwise"});
-    }
-
-    condition::branch branch_false;
-    {
-        topology branch_false_topology;
-        branch_false_topology.add(
-            input_layout(branch_input_id2, { data_types::f32, format::bfyx, { 1, 1, 4, 1 } }),
-            reorder("result", input_info(branch_input_id2), {data_types::f32, format::bfyx, {1, 1, 4, 1}})
-        );
-        branch_false.inner_program = program::build_program(engine, branch_false_topology, config, false, false, true);
-        branch_false.input_map.insert({input_id2, branch_input_id2});
-        branch_false.output_map.insert({0, "result"});
-    }
-
-    topology topology;
-    topology.add(input_layout(input_id1, input_mem->get_layout()));
-    topology.add(input_layout(input_id2, input_mem->get_layout()));
-    topology.add(input_layout(pred_id, predicate_mem->get_layout()));
-    topology.add(condition(cond_id, {input_info(pred_id), input_info(input_id1), input_info(input_id2)}, branch_true, branch_false)
-    );
-
-    network net(engine, topology, config);
-    ASSERT_TRUE(net.get_primitive(cond_id)->get_node().as<condition>().get_branch_false().inner_program->can_be_optimized());
-    ASSERT_FALSE(net.get_primitive(cond_id)->get_node().as<condition>().get_branch_true().inner_program->can_be_optimized());
+TEST_F(condition_gpu_tests, dynamic_shapes_skip_condition_cached) {
+    this->test_dynamic_shapes_skip_condition(true);
+}
+
+TEST_F(condition_gpu_tests, basic_stacked_ifs) {
+    this->test_basic_stacked_ifs(false);
+}
+
+TEST_F(condition_gpu_tests, basic_stacked_ifs_cached) {
+    this->test_basic_stacked_ifs(true);
+}
+
+TEST_F(condition_gpu_tests, basic_nested_ifs) {
+    this->test_basic_nested_ifs(false);
+}
+
+TEST_F(condition_gpu_tests, basic_nested_ifs_cached) {
+    this->test_basic_nested_ifs(true);
+}
+
+TEST_F(condition_gpu_tests, negative_predicate_wrong_layout) {
+    this->test_negative_predicate_wrong_layout(false);
+}
+
+TEST_F(condition_gpu_tests, negative_predicate_wrong_layout_cache) {
+    this->test_negative_predicate_wrong_layout(true);
+}
+
+TEST_F(condition_gpu_tests, negative_not_same_layouts) {
+    this->test_negative_not_same_layouts(false);
+}
+
+TEST_F(condition_gpu_tests, negative_not_same_layouts_cache) {
+    this->test_negative_not_same_layouts(true);
+}
+
+TEST_F(condition_gpu_tests, negative_same_names_within_different_networks) {
+    this->test_negative_same_names_within_different_networks(false);
+}
+
+TEST_F(condition_gpu_tests, negative_same_names_within_different_networks_cache) {
+    this->test_negative_same_names_within_different_networks(true);
+}
+
+TEST_F(condition_gpu_tests, empty_body) {
+    this->test_empty_body(false);
+}
+
+TEST_F(condition_gpu_tests, empty_body_cached) {
+    this->test_empty_body(true);
 }
diff --git a/src/plugins/intel_gpu/tests/unit/test_cases/fully_connected_gpu_test.cpp b/src/plugins/intel_gpu/tests/unit/test_cases/fully_connected_gpu_test.cpp
index 2f684a40f7f..173b14e1462 100644
--- a/src/plugins/intel_gpu/tests/unit/test_cases/fully_connected_gpu_test.cpp
+++ b/src/plugins/intel_gpu/tests/unit/test_cases/fully_connected_gpu_test.cpp
@@ -659,171 +659,6 @@ TEST(fully_connected_gpu, x_f32_relu) {
     ASSERT_EQ(0.00f, output_ptr[3]);
 }
 
-TEST(fully_connected_gpu, compressed_scale_zp_bias) {
-    auto& engine = get_test_engine();
-
-    auto input_mem = engine.allocate_memory({ {1, 2, 4}, data_types::f32, format::bfyx });
-    auto weights_mem = engine.allocate_memory({ {8, 4}, data_types::u8, format::bfyx });
-    auto bias_mem = engine.allocate_memory({ {1, 1, 8}, data_types::f32, format::bfyx });
-    auto scale_mem = engine.allocate_memory({ {8, 1}, data_types::f32, format::bfyx });
-    auto zp_mem = engine.allocate_memory({ {8, 1}, data_types::f32, format::bfyx });
-
-    set_values(input_mem, { -0.5f, 2.0f, 0.5f, 1.0f,
-                            0.5f, -2.0f, -0.5f, -1.0f });
-    set_values<uint8_t>(weights_mem, { 1, 2, 3, 4,
-                                       5, 6, 7, 8,
-                                       9, 10, 11, 12,
-                                       13, 14, 15, 0,
-                                       15, 14, 13, 12,
-                                       11, 10, 9, 8,
-                                       7, 6, 5, 4,
-                                       3, 2, 1, 0});
-
-
-    set_values(bias_mem, { 1.0f, -2.0f, 3.0f, -4.0f, 5.0f, -6.0f, 7.0f, 2.0f  });
-    set_values(scale_mem, { 2.0f, 4.0f, -2.0f, -4.0f, 0.5f, -0.5f, 2.0f, 2.0f  });
-    set_values(zp_mem, { 1.0f, 2.0f, 2.0f, 1.0f, 4.0f, 1.0f, 6.0f, 2.0f });
-
-    topology topology(
-        input_layout("input", input_mem->get_layout()),
-        data("weights", weights_mem),
-        data("bias", bias_mem),
-        data("scale", scale_mem),
-        data("zp", zp_mem),
-        fully_connected("fc_prim", input_info("input"), "weights", "bias", "scale", "zp", data_types::f32, padding(), 3, 2)
-    );
-
-    auto config = get_test_default_config(engine);
-    config.set_property(ov::intel_gpu::allow_new_shape_infer(true));
-
-    network network(engine, topology, config);
-    network.set_input_data("input", input_mem);
-
-    auto outputs = network.execute();
-    ASSERT_EQ(outputs.size(), size_t(1));
-    ASSERT_EQ(outputs.begin()->first, "fc_prim");
-
-    auto output_mem = outputs.begin()->second.get_memory();
-
-    cldnn::mem_lock<float> output_ptr (output_mem, get_test_stream());
-
-    ov::PartialShape expected_shape{1, 2, 8};
-    ASSERT_EQ(expected_shape, output_mem->get_layout().get_partial_shape());
-
-    std::vector<float> expected_result = {13.f, 58.f, -51.f, -108.f, 18.5f, -18.f, 1.f, -4.f, -11.f, -62.f, 57.f, 100.f, -8.5f, 6.f, 13.f, 8.f, };
-
-    for (size_t i = 0; i < expected_result.size(); i++) {
-        ASSERT_EQ(expected_result[i], output_ptr[i]) << "i = " << i;
-    }
-}
-
-TEST(fully_connected_gpu, compressed_scale_bias) {
-    auto& engine = get_test_engine();
-
-    auto input_mem = engine.allocate_memory({ {1, 2, 4}, data_types::f32, format::bfyx });
-    auto weights_mem = engine.allocate_memory({ {8, 4}, data_types::u8, format::bfyx });
-    auto bias_mem = engine.allocate_memory({ {1, 1, 8}, data_types::f32, format::bfyx });
-    auto scale_mem = engine.allocate_memory({ {1, 1, 8}, data_types::f32, format::bfyx });
-
-    set_values(input_mem, { -0.5f, 2.0f, 0.5f, 1.0f,
-                            0.5f, -2.0f, -0.5f, -1.0f });
-    set_values<uint8_t>(weights_mem, { 1, 2, 3, 4,
-                                       5, 6, 7, 8,
-                                       9, 10, 11, 12,
-                                       13, 14, 15, 0,
-                                       15, 14, 13, 12,
-                                       11, 10, 9, 8,
-                                       7, 6, 5, 4,
-                                       3, 2, 1, 0});
-
-    set_values(bias_mem, { 1.0f, -2.0f, 3.0f, -4.0f, 5.0f, -6.0f, 7.0f, -8.0f });
-    set_values(scale_mem, { 2.0f, 4.0f, -2.0f, -4.0f, 0.5f, -0.5f, 2.0f, 1.0f });
-
-    topology topology(
-        input_layout("input", input_mem->get_layout()),
-        data("weights", weights_mem),
-        data("bias", bias_mem),
-        data("scale", scale_mem),
-        fully_connected("fc_prim", input_info("input"), "weights", "bias", "scale", "", data_types::f32, padding(), 3, 2)
-    );
-
-    auto config = get_test_default_config(engine);
-    config.set_property(ov::intel_gpu::allow_new_shape_infer(true));
-
-    network network(engine, topology, config);
-    network.set_input_data("input", input_mem);
-
-    auto outputs = network.execute();
-    ASSERT_EQ(outputs.size(), size_t(1));
-    ASSERT_EQ(outputs.begin()->first, "fc_prim");
-
-    auto output_mem = outputs.begin()->second.get_memory();
-
-    cldnn::mem_lock<float> output_ptr (output_mem, get_test_stream());
-
-    ov::PartialShape expected_shape{1, 2, 8};
-    ASSERT_EQ(expected_shape, output_mem->get_layout().get_partial_shape());
-
-    std::vector<float> expected_result = {19.f, 40.f, 69.f, 54.f, 83.f, 48.f, 37.f, -2.f, -17.f, -44.f, -63.f, -62.f, -73.f, -60.f, -23.f, -14.f };
-
-    for (size_t i = 0; i < expected_result.size(); i++) {
-        ASSERT_EQ(expected_result[i], output_ptr[i]) << "i = " << i;
-    }
-}
-
-TEST(fully_connected_gpu, compressed_scale_fp16) {
-    auto& engine = get_test_engine();
-
-    auto input_mem = engine.allocate_memory({ { 2, 4}, data_types::f16, format::bfyx });
-    auto weights_mem = engine.allocate_memory({ {8, 4}, data_types::u8, format::bfyx });
-    auto scale_mem = engine.allocate_memory({ {8, 1}, data_types::f16, format::bfyx });
-
-    set_values<ov::float16>(input_mem, { ov::float16(-0.5f), ov::float16(2.0f),  ov::float16(0.5f),  ov::float16(1.0f),
-                                     ov::float16(0.5f),  ov::float16(-2.0f), ov::float16(-0.5f), ov::float16(-1.0f) });
-    set_values<uint8_t>(weights_mem, { 1, 2, 3, 4,
-                                       5, 6, 7, 8,
-                                       9, 10, 11, 12,
-                                       13, 14, 15, 0,
-                                       15, 14, 13, 12,
-                                       11, 10, 9, 8,
-                                       7, 6, 5, 4,
-                                       3, 2, 1, 0});
-
-    set_values<ov::float16>(scale_mem, {ov::float16(2.0f), ov::float16(4.0f), ov::float16(-2.0f), ov::float16(-4.0f), ov::float16(0.5f), ov::float16(-0.5f), ov::float16(2.0f), ov::float16(2.0f)});
-
-    topology topology(
-        input_layout("input", input_mem->get_layout()),
-        data("weights", weights_mem),
-        data("scale", scale_mem),
-        fully_connected("fc_prim", input_info("input"), "weights", "", "scale", "", data_types::f32, padding(), 2, 2)
-    );
-
-    auto config = get_test_default_config(engine);
-    config.set_property(ov::intel_gpu::allow_new_shape_infer(true));
-
-    network network(engine, topology, config);
-    network.set_input_data("input", input_mem);
-
-    auto outputs = network.execute();
-    ASSERT_EQ(outputs.size(), size_t(1));
-    ASSERT_EQ(outputs.begin()->first, "fc_prim");
-
-    auto output_mem = outputs.begin()->second.get_memory();
-
-    cldnn::mem_lock<ov::float16> output_ptr (output_mem, get_test_stream());
-
-    ov::PartialShape expected_shape{2, 8};
-    ASSERT_EQ(expected_shape, output_mem->get_layout().get_partial_shape());
-
-   std::vector<ov::float16> expected_result = {
-       ov::float16(18), ov::float16(84), ov::float16(-66), ov::float16(-116), ov::float16(19.5), ov::float16(-13.5), ov::float16(30), ov::float16(6),
-       ov::float16(-18), ov::float16(-84), ov::float16(66), ov::float16(116), ov::float16(-19.5), ov::float16(13.5), ov::float16(-30), ov::float16(-6) };
-
-    for (size_t i = 0; i < expected_result.size(); i++) {
-        ASSERT_FLOAT_EQ(expected_result[i], output_ptr[i]) << "i = " << i;
-    }
-}
-
 TEST(fully_connected_gpu, x_f32_relu_with_negative_slope) {
     //  Input  : 3x1
     //  Output : 4x1
@@ -1148,6 +983,688 @@ TEST(fully_connected_gpu, DISABLED_fs_byx_fsv32_b34)
     }
 }
 
+class fully_connected_gpu_tests: public ::testing::Test {
+public:
+    void test_compressed_scale_zp_bias(bool is_caching_test) {
+        auto& engine = get_test_engine();
+
+        auto input_mem = engine.allocate_memory({ {1, 2, 4}, data_types::f32, format::bfyx });
+        auto weights_mem = engine.allocate_memory({ {8, 4}, data_types::u8, format::bfyx });
+        auto bias_mem = engine.allocate_memory({ {1, 1, 8}, data_types::f32, format::bfyx });
+        auto scale_mem = engine.allocate_memory({ {8, 1}, data_types::f32, format::bfyx });
+        auto zp_mem = engine.allocate_memory({ {8, 1}, data_types::f32, format::bfyx });
+
+        set_values(input_mem, { -0.5f, 2.0f, 0.5f, 1.0f,
+                                0.5f, -2.0f, -0.5f, -1.0f });
+        set_values<uint8_t>(weights_mem, { 1, 2, 3, 4,
+                                        5, 6, 7, 8,
+                                        9, 10, 11, 12,
+                                        13, 14, 15, 0,
+                                        15, 14, 13, 12,
+                                        11, 10, 9, 8,
+                                        7, 6, 5, 4,
+                                        3, 2, 1, 0});
+
+
+        set_values(bias_mem, { 1.0f, -2.0f, 3.0f, -4.0f, 5.0f, -6.0f, 7.0f, 2.0f  });
+        set_values(scale_mem, { 2.0f, 4.0f, -2.0f, -4.0f, 0.5f, -0.5f, 2.0f, 2.0f  });
+        set_values(zp_mem, { 1.0f, 2.0f, 2.0f, 1.0f, 4.0f, 1.0f, 6.0f, 2.0f });
+
+        topology topology(
+            input_layout("input", input_mem->get_layout()),
+            data("weights", weights_mem),
+            data("bias", bias_mem),
+            data("scale", scale_mem),
+            data("zp", zp_mem),
+            fully_connected("fc_prim", input_info("input"), "weights", "bias", "scale", "zp", data_types::f32, padding(), 3, 2)
+        );
+
+        auto config = get_test_default_config(engine);
+        config.set_property(ov::intel_gpu::allow_new_shape_infer(true));
+
+        network::ptr network = get_network(engine, topology, config, get_test_stream_ptr(), is_caching_test);
+        network->set_input_data("input", input_mem);
+
+        auto outputs = network->execute();
+        ASSERT_EQ(outputs.size(), size_t(1));
+        ASSERT_EQ(outputs.begin()->first, "fc_prim");
+
+        auto output_mem = outputs.begin()->second.get_memory();
+
+        cldnn::mem_lock<float> output_ptr (output_mem, get_test_stream());
+
+        ov::PartialShape expected_shape{1, 2, 8};
+        ASSERT_EQ(expected_shape, output_mem->get_layout().get_partial_shape());
+
+        std::vector<float> expected_result = {13.f, 58.f, -51.f, -108.f, 18.5f, -18.f, 1.f, -4.f, -11.f, -62.f, 57.f, 100.f, -8.5f, 6.f, 13.f, 8.f, };
+
+        for (size_t i = 0; i < expected_result.size(); i++) {
+            ASSERT_EQ(expected_result[i], output_ptr[i]) << "i = " << i;
+        }
+    }
+
+    void test_compressed_scale_bias(bool is_caching_test) {
+        auto& engine = get_test_engine();
+
+        auto input_mem = engine.allocate_memory({ {1, 2, 4}, data_types::f32, format::bfyx });
+        auto weights_mem = engine.allocate_memory({ {8, 4}, data_types::u8, format::bfyx });
+        auto bias_mem = engine.allocate_memory({ {1, 1, 8}, data_types::f32, format::bfyx });
+        auto scale_mem = engine.allocate_memory({ {1, 1, 8}, data_types::f32, format::bfyx });
+
+        set_values(input_mem, { -0.5f, 2.0f, 0.5f, 1.0f,
+                                0.5f, -2.0f, -0.5f, -1.0f });
+        set_values<uint8_t>(weights_mem, { 1, 2, 3, 4,
+                                        5, 6, 7, 8,
+                                        9, 10, 11, 12,
+                                        13, 14, 15, 0,
+                                        15, 14, 13, 12,
+                                        11, 10, 9, 8,
+                                        7, 6, 5, 4,
+                                        3, 2, 1, 0});
+
+        set_values(bias_mem, { 1.0f, -2.0f, 3.0f, -4.0f, 5.0f, -6.0f, 7.0f, -8.0f });
+        set_values(scale_mem, { 2.0f, 4.0f, -2.0f, -4.0f, 0.5f, -0.5f, 2.0f, 1.0f });
+
+        topology topology(
+            input_layout("input", input_mem->get_layout()),
+            data("weights", weights_mem),
+            data("bias", bias_mem),
+            data("scale", scale_mem),
+            fully_connected("fc_prim", input_info("input"), "weights", "bias", "scale", "", data_types::f32, padding(), 3, 2)
+        );
+
+        auto config = get_test_default_config(engine);
+        config.set_property(ov::intel_gpu::allow_new_shape_infer(true));
+
+        network::ptr network = get_network(engine, topology, config, get_test_stream_ptr(), is_caching_test);
+        network->set_input_data("input", input_mem);
+
+        auto outputs = network->execute();
+        ASSERT_EQ(outputs.size(), size_t(1));
+        ASSERT_EQ(outputs.begin()->first, "fc_prim");
+
+        auto output_mem = outputs.begin()->second.get_memory();
+
+        cldnn::mem_lock<float> output_ptr (output_mem, get_test_stream());
+
+        ov::PartialShape expected_shape{1, 2, 8};
+        ASSERT_EQ(expected_shape, output_mem->get_layout().get_partial_shape());
+
+        std::vector<float> expected_result = {19.f, 40.f, 69.f, 54.f, 83.f, 48.f, 37.f, -2.f, -17.f, -44.f, -63.f, -62.f, -73.f, -60.f, -23.f, -14.f };
+
+        for (size_t i = 0; i < expected_result.size(); i++) {
+            ASSERT_EQ(expected_result[i], output_ptr[i]) << "i = " << i;
+        }
+    }
+
+    void test_compressed_scale_fp16(bool is_caching_test) {
+        auto& engine = get_test_engine();
+
+        auto input_mem = engine.allocate_memory({ { 2, 4}, data_types::f16, format::bfyx });
+        auto weights_mem = engine.allocate_memory({ {8, 4}, data_types::u8, format::bfyx });
+        auto scale_mem = engine.allocate_memory({ {8, 1}, data_types::f16, format::bfyx });
+
+        set_values<ov::float16>(input_mem, { ov::float16(-0.5f), ov::float16(2.0f),  ov::float16(0.5f),  ov::float16(1.0f),
+                                        ov::float16(0.5f),  ov::float16(-2.0f), ov::float16(-0.5f), ov::float16(-1.0f) });
+        set_values<uint8_t>(weights_mem, { 1, 2, 3, 4,
+                                        5, 6, 7, 8,
+                                        9, 10, 11, 12,
+                                        13, 14, 15, 0,
+                                        15, 14, 13, 12,
+                                        11, 10, 9, 8,
+                                        7, 6, 5, 4,
+                                        3, 2, 1, 0});
+
+        set_values<ov::float16>(scale_mem, {ov::float16(2.0f), ov::float16(4.0f), ov::float16(-2.0f), ov::float16(-4.0f), ov::float16(0.5f), ov::float16(-0.5f), ov::float16(2.0f), ov::float16(2.0f)});
+
+        topology topology(
+            input_layout("input", input_mem->get_layout()),
+            data("weights", weights_mem),
+            data("scale", scale_mem),
+            fully_connected("fc_prim", input_info("input"), "weights", "", "scale", "", data_types::f32, padding(), 2, 2)
+        );
+
+        auto config = get_test_default_config(engine);
+        config.set_property(ov::intel_gpu::allow_new_shape_infer(true));
+
+        network::ptr network = get_network(engine, topology, config, get_test_stream_ptr(), is_caching_test);
+        network->set_input_data("input", input_mem);
+
+        auto outputs = network->execute();
+        ASSERT_EQ(outputs.size(), size_t(1));
+        ASSERT_EQ(outputs.begin()->first, "fc_prim");
+
+        auto output_mem = outputs.begin()->second.get_memory();
+
+        cldnn::mem_lock<ov::float16> output_ptr (output_mem, get_test_stream());
+
+        ov::PartialShape expected_shape{2, 8};
+        ASSERT_EQ(expected_shape, output_mem->get_layout().get_partial_shape());
+
+    std::vector<ov::float16> expected_result = {
+        ov::float16(18), ov::float16(84), ov::float16(-66), ov::float16(-116), ov::float16(19.5), ov::float16(-13.5), ov::float16(30), ov::float16(6),
+        ov::float16(-18), ov::float16(-84), ov::float16(66), ov::float16(116), ov::float16(-19.5), ov::float16(13.5), ov::float16(-30), ov::float16(-6) };
+
+        for (size_t i = 0; i < expected_result.size(); i++) {
+            ASSERT_FLOAT_EQ(expected_result[i], output_ptr[i]) << "i = " << i;
+        }
+    }
+
+    void test_dynamic(bool is_caching_test) {
+        auto& engine = get_test_engine();
+
+        const int32_t input_f = 3, input_b = 1, weight_b = 4;
+
+        auto fake_alignment_size = engine.get_device_info().supports_immad ? 8 : 16;
+        auto input_dyn_layout = layout{ ov::PartialShape{ ov::Dimension(1, 10), input_f }, data_types::f32,format::bfyx };
+        auto input_data = engine.allocate_memory(layout{ ov::PartialShape{ input_b, input_f }, data_types::f32,format::bfyx });
+        auto weights_data = engine.allocate_memory({ ov::PartialShape{ weight_b, input_f }, data_types::f32,format::bfyx });
+
+        set_values(input_data, { -0.5f, 2.0f, 0.5f });
+        set_values(weights_data, { 1.5f, 1.0f, 0.5f, -1.0f, 0.0f, 0.5f, 0.5f, -0.5f, -2.0f, -0.5f, 1.0f, 1.5f });
+
+        cldnn::topology topology{
+            input_layout("input", input_dyn_layout),
+            data("weights", weights_data),
+            fully_connected("fc", input_info("input"), "weights")
+        };
+
+        ExecutionConfig config = get_test_default_config(engine);
+        config.set_property(ov::intel_gpu::optimize_data(true));
+        config.set_property(ov::intel_gpu::allow_new_shape_infer(true));
+        network::ptr network = get_network(engine, topology, config, get_test_stream_ptr(), is_caching_test);
+        network->set_input_data("input", input_data);
+
+        auto outputs = network->execute();
+        ASSERT_EQ(outputs.size(), size_t(1));
+        ASSERT_EQ(outputs.begin()->first, "fc");
+
+        auto output_prim_mem = outputs.begin()->second.get_memory();
+
+        auto out_l = network->get_output_layout(outputs.begin()->first);
+        ASSERT_EQ(output_prim_mem->get_layout().batch(), align_to(input_b, fake_alignment_size)); // fake_alignment
+        ASSERT_EQ(out_l.batch(), input_b);
+        ASSERT_EQ(out_l.feature(), weight_b);
+        ASSERT_EQ(out_l.spatial(0), 1);
+        ASSERT_EQ(out_l.spatial(1), 1);
+
+        cldnn::mem_lock<float> output_ptr (output_prim_mem, get_test_stream());
+
+        ASSERT_EQ(1.5f, output_ptr[0]);
+        ASSERT_EQ(0.75f, output_ptr[1]);
+        ASSERT_EQ(-2.25f, output_ptr[2]);
+        ASSERT_EQ(3.0f, output_ptr[3]);
+    }
+
+    void test_dynamic_6d_input(bool is_caching_test) {
+        auto& engine = get_test_engine();
+
+        const int32_t input_b = 1, input_f = 3, input_w = 2, input_z = 1, input_y = 1, input_x = 4;
+        const int32_t weight_b = 2;
+
+        auto input_dyn_layout = layout{ov::PartialShape{ov::Dimension(-1), input_f, input_w, input_z, input_y, input_x}, data_types::f32, format::bfwzyx};
+        auto input_data = engine.allocate_memory(layout{ov::PartialShape{input_b, input_f, input_w, input_z, input_y, input_x}, data_types::f32, format::bfwzyx});
+        auto weights_data = engine.allocate_memory({ov::PartialShape{weight_b, input_x}, data_types::f32, format::bfyx });
+
+        set_values(input_data, {-0.5f, 2.0f, 0.5f, 1.f,  -1.5f, 2.0f, 0.5f, 1.f,
+                                -0.5f, 2.5f, 0.5f, 1.f,  -0.5f, 3.0f, 0.5f, 1.f,
+                                -0.5f, 2.0f, 0.5f, 1.f,  -0.5f, 2.0f, 2.5f, 1.f});
+        set_values(weights_data, {1.5f, 1.0f, -1.0f, 0.0f,
+                                0.5f, -0.5f, -0.5f, 1.0f, });
+
+        cldnn::topology topology{
+            input_layout("input", input_dyn_layout),
+            data("weights", weights_data),
+            fully_connected("fc", input_info("input"), "weights", "", cldnn::padding(), input_dyn_layout.get_rank())
+        };
+
+        ExecutionConfig config = get_test_default_config(engine);
+        config.set_property(ov::intel_gpu::optimize_data(true));
+        config.set_property(ov::intel_gpu::allow_new_shape_infer(true));
+        network::ptr network = get_network(engine, topology, config, get_test_stream_ptr(), is_caching_test);
+        network->set_input_data("input", input_data);
+
+        auto outputs = network->execute();
+        ASSERT_EQ(outputs.size(), size_t(1));
+        ASSERT_EQ(outputs.begin()->first, "fc");
+
+        auto output_prim_mem = outputs.begin()->second.get_memory();
+
+        auto out_l = network->get_output_layout(outputs.begin()->first);
+        ASSERT_EQ(output_prim_mem->get_layout().batch(), 1);
+        ASSERT_EQ(out_l.batch(), 1);
+        ASSERT_EQ(out_l.feature(), 3);
+        ASSERT_EQ(out_l.spatial(0), 2);
+        ASSERT_EQ(out_l.spatial(1), 1);
+        ASSERT_EQ(out_l.spatial(2), 1);
+        ASSERT_EQ(out_l.spatial(3), 2);
+
+        std::vector<float> expected_output = {
+            0.75, -0.5, -0.75, -1, 1.25, -0.75, 1.75, -1, 0.75, -0.5, -1.25, -1.5
+        };
+
+        cldnn::mem_lock<float> output_ptr(output_prim_mem, get_test_stream());
+
+        for (size_t i = 0 ; i < out_l.get_linear_size(); i++) {
+            ASSERT_EQ(expected_output[i], output_ptr[i]);
+        }
+    }
+
+    void test_static_6d_input(bool is_caching_test) {
+        auto& engine = get_test_engine();
+
+        const int32_t input_b = 1, input_f = 3, input_w = 2, input_z = 1, input_y = 1, input_x = 4;
+        const int32_t weight_b = 2;
+
+        auto input_dyn_layout = layout{ov::PartialShape{input_b, input_f, input_w, input_z, input_y, input_x}, data_types::f32, format::bfwzyx};
+        auto input_data = engine.allocate_memory(input_dyn_layout);
+        auto weights_data = engine.allocate_memory({ov::PartialShape{weight_b, input_x}, data_types::f32, format::bfyx });
+
+        set_values(input_data, {-0.5f, 2.0f, 0.5f, 1.f,  -1.5f, 2.0f, 0.5f, 1.f,
+                                -0.5f, 2.5f, 0.5f, 1.f,  -0.5f, 3.0f, 0.5f, 1.f,
+                                -0.5f, 2.0f, 0.5f, 1.f,  -0.5f, 2.0f, 2.5f, 1.f});
+        set_values(weights_data, {1.5f, 1.0f, -1.0f, 0.0f,
+                                0.5f, -0.5f, -0.5f, 1.0f, });
+
+        cldnn::topology topology{
+            input_layout("input", input_dyn_layout),
+            data("weights", weights_data),
+            fully_connected("fc", input_info("input"), "weights", "", cldnn::padding(), input_dyn_layout.get_rank()),
+        };
+
+        ExecutionConfig config = get_test_default_config(engine);
+        config.set_property(ov::intel_gpu::optimize_data(true));
+        network::ptr network = get_network(engine, topology, config, get_test_stream_ptr(), is_caching_test);
+        network->set_input_data("input", input_data);
+
+        auto outputs = network->execute();
+        ASSERT_EQ(outputs.size(), size_t(1));
+        ASSERT_EQ(outputs.begin()->first, "fc");
+
+        auto output_prim_mem = outputs.begin()->second.get_memory();
+
+        auto out_l = network->get_output_layout(outputs.begin()->first);
+        ASSERT_EQ(output_prim_mem->get_layout().batch(), 6);
+        ASSERT_EQ(out_l.batch(), 6);
+        ASSERT_EQ(out_l.feature(), 2);
+        ASSERT_EQ(out_l.spatial(0), 1);
+        ASSERT_EQ(out_l.spatial(1), 1);
+
+        std::vector<float> expected_output = {
+            0.75, -0.5, -0.75, -1, 1.25, -0.75, 1.75, -1, 0.75, -0.5, -1.25, -1.5
+        };
+
+        cldnn::mem_lock<float> output_ptr(output_prim_mem, get_test_stream());
+
+        for (size_t i = 0 ; i < out_l.get_linear_size(); i++) {
+            ASSERT_EQ(expected_output[i], output_ptr[i]);
+        }
+    }
+
+    void test_dynamic_multi_inference_same_shape(bool is_caching_test) {
+        auto& engine = get_test_engine();
+        const int32_t input_f = 3, input_b = 1, weight_b = 4;
+
+        auto input_dyn_layout = layout{ ov::PartialShape{ ov::Dimension(1, 10), input_f }, data_types::f32,format::bfyx };
+        auto input_actual_layout = layout{ ov::PartialShape{ input_b, input_f }, data_types::f32,format::bfyx };
+        auto input_data1 = engine.allocate_memory(input_actual_layout);
+        auto input_data2 = engine.allocate_memory(input_actual_layout);
+        auto weights_data = engine.allocate_memory({ ov::PartialShape{ weight_b, input_f }, data_types::f32,format::bfyx });
+        auto fake_alignment_size = engine.get_device_info().supports_immad ? 8 : 16;
+        set_values(input_data1, { 0.5f, -2.0f, -0.5f });
+        set_values(input_data2, { -0.5f, 2.0f, 0.5f });
+        set_values(weights_data, { 1.5f, 1.0f, 0.5f,
+                                -1.0f, 0.0f, 0.5f,
+                                0.5f, -0.5f, -2.0f,
+                                -0.5f, 1.0f, 1.5f });
+
+        cldnn::topology topology{
+            input_layout("input", input_dyn_layout),
+            data("weights", weights_data),
+            fully_connected("fc", input_info("input"), "weights")
+        };
+
+        ExecutionConfig config = get_test_default_config(engine);
+        config.set_property(ov::intel_gpu::optimize_data(true));
+        config.set_property(ov::intel_gpu::allow_new_shape_infer(true));
+        network::ptr network = get_network(engine, topology, config, get_test_stream_ptr(), is_caching_test);
+
+        {
+            network->set_input_data("input", input_data1);
+
+            auto outputs = network->execute();
+            ASSERT_EQ(outputs.size(), size_t(1));
+            ASSERT_EQ(outputs.begin()->first, "fc");
+
+            auto output_prim_mem = outputs.begin()->second.get_memory();
+
+            auto out_l = network->get_output_layout(outputs.begin()->first);
+            ASSERT_EQ(output_prim_mem->get_layout().batch(), align_to(input_b, fake_alignment_size)); // fake_alignment
+            ASSERT_EQ(out_l.batch(), input_b);
+            ASSERT_EQ(out_l.feature(), weight_b);
+            ASSERT_EQ(out_l.spatial(0), 1);
+            ASSERT_EQ(out_l.spatial(1), 1);
+
+            cldnn::mem_lock<float> output_ptr (output_prim_mem, get_test_stream());
+
+            ASSERT_EQ(-1.5f, output_ptr[0]);
+            ASSERT_EQ(-0.75f, output_ptr[1]);
+            ASSERT_EQ(2.25f, output_ptr[2]);
+            ASSERT_EQ(-3.0f, output_ptr[3]);
+        }
+
+        {
+            network->set_input_data("input", input_data2);
+
+            auto outputs = network->execute();
+            ASSERT_EQ(outputs.size(), size_t(1));
+            ASSERT_EQ(outputs.begin()->first, "fc");
+
+            auto output_prim_mem = outputs.begin()->second.get_memory();
+
+            auto out_l = network->get_output_layout(outputs.begin()->first);
+            ASSERT_EQ(output_prim_mem->get_layout().batch(), align_to(input_b, fake_alignment_size)); // fake_alignment
+            ASSERT_EQ(out_l.batch(), input_b);
+            ASSERT_EQ(out_l.feature(), weight_b);
+            ASSERT_EQ(out_l.spatial(0), 1);
+            ASSERT_EQ(out_l.spatial(1), 1);
+
+            cldnn::mem_lock<float> output_ptr (output_prim_mem, get_test_stream());
+
+            ASSERT_EQ(1.5f, output_ptr[0]);
+            ASSERT_EQ(0.75f, output_ptr[1]);
+            ASSERT_EQ(-2.25f, output_ptr[2]);
+            ASSERT_EQ(3.0f, output_ptr[3]);
+        }
+    }
+
+    void test_dynamic_multi_inference_different_shape(bool is_caching_test) {
+        auto& engine = get_test_engine();
+
+        const int32_t input_f = 3, weight_b = 4;
+
+        auto fake_alignment_size = engine.get_device_info().supports_immad ? 8 : 16;
+        auto input_dyn_layout = layout{ ov::PartialShape{ ov::Dimension(1, 10), input_f }, data_types::f32,format::bfyx };
+        auto input_actual_layout1 = layout{ ov::PartialShape{ 2, input_f }, data_types::f32,format::bfyx};
+        auto input_actual_layout2 = layout{ ov::PartialShape{ 1, input_f }, data_types::f32,format::bfyx};
+        auto input_data1 = engine.allocate_memory(input_actual_layout1);
+        auto input_data2 = engine.allocate_memory(input_actual_layout2);
+        auto weights_data = engine.allocate_memory({ ov::PartialShape{ weight_b, input_f }, data_types::f32,format::bfyx});
+
+        set_values(input_data1, { 0.5f, -2.0f, -0.5f,
+                                -0.5f, 2.0f, 0.5f });
+        set_values(input_data2, { -0.5f, 2.0f, 0.5f });
+        set_values(weights_data, { 1.5f, 1.0f, 0.5f,
+                                -1.0f, 0.0f, 0.5f,
+                                0.5f, -0.5f, -2.0f,
+                                -0.5f, 1.0f, 1.5f });
+
+        cldnn::topology topology{
+            input_layout("input", input_dyn_layout),
+            data("weights", weights_data),
+            fully_connected("fc", input_info("input"), "weights")
+        };
+
+        ExecutionConfig config = get_test_default_config(engine);
+        config.set_property(ov::intel_gpu::optimize_data(true));
+        config.set_property(ov::intel_gpu::allow_new_shape_infer(true));
+        network::ptr network = get_network(engine, topology, config, get_test_stream_ptr(), is_caching_test);
+
+        auto inst = network->get_primitive("fc");
+        ASSERT_TRUE(inst->is_dynamic());
+
+        {
+            network->set_input_data("input", input_data1);
+
+            auto outputs = network->execute();
+            ASSERT_EQ(outputs.size(), size_t(1));
+            ASSERT_EQ(outputs.begin()->first, "fc");
+
+            auto output_prim_mem = outputs.begin()->second.get_memory();
+
+            auto out_l = network->get_output_layout(outputs.begin()->first);
+            ASSERT_EQ(output_prim_mem->get_layout().batch(), align_to(2, fake_alignment_size)); // fake_alignment
+            ASSERT_EQ(out_l.batch(), 2);
+            ASSERT_EQ(out_l.feature(), weight_b);
+            ASSERT_EQ(out_l.spatial(0), 1);
+            ASSERT_EQ(out_l.spatial(1), 1);
+
+            cldnn::mem_lock<float> output_ptr (output_prim_mem, get_test_stream());
+
+            ASSERT_EQ(-1.5f, output_ptr[0]);
+            ASSERT_EQ(-0.75f, output_ptr[1]);
+            ASSERT_EQ(2.25f, output_ptr[2]);
+            ASSERT_EQ(-3.0f, output_ptr[3]);
+
+            ASSERT_EQ(1.5f, output_ptr[4]);
+            ASSERT_EQ(0.75f, output_ptr[5]);
+            ASSERT_EQ(-2.25f, output_ptr[6]);
+            ASSERT_EQ(3.0f, output_ptr[7]);
+        }
+
+        {
+            network->set_input_data("input", input_data2);
+
+            auto outputs = network->execute();
+            ASSERT_EQ(outputs.size(), size_t(1));
+            ASSERT_EQ(outputs.begin()->first, "fc");
+
+            auto output_prim_mem = outputs.begin()->second.get_memory();
+
+            auto out_l = network->get_output_layout(outputs.begin()->first);
+            ASSERT_EQ(output_prim_mem->get_layout().batch(), align_to(1, fake_alignment_size)); // fake_alignment
+            ASSERT_EQ(out_l.batch(), 1);
+            ASSERT_EQ(out_l.feature(), weight_b);
+            ASSERT_EQ(out_l.spatial(0), 1);
+            ASSERT_EQ(out_l.spatial(1), 1);
+
+            cldnn::mem_lock<float> output_ptr (output_prim_mem, get_test_stream());
+
+            ASSERT_EQ(1.5f, output_ptr[0]);
+            ASSERT_EQ(0.75f, output_ptr[1]);
+            ASSERT_EQ(-2.25f, output_ptr[2]);
+            ASSERT_EQ(3.0f, output_ptr[3]);
+        }
+    }
+
+    void test_dynamic_multi_inference_multiple_shapes(bool is_caching_test) {
+        auto& engine = get_test_engine();
+
+        const int32_t input_f = 3, weight_b = 4;
+
+        auto fake_alignment_size = engine.get_device_info().supports_immad ? 8 : 16;
+        auto input_dyn_layout = layout{ ov::PartialShape{ ov::Dimension(1, 10), input_f }, data_types::f32,format::bfyx };
+        auto input_actual_layout1 = layout{ ov::PartialShape{ 2, input_f }, data_types::f32,format::bfyx};
+        auto input_actual_layout2 = layout{ ov::PartialShape{ 1, input_f }, data_types::f32,format::bfyx};
+        auto input_data1 = engine.allocate_memory(input_actual_layout1);
+        auto input_data2 = engine.allocate_memory(input_actual_layout2);
+        auto weights_data = engine.allocate_memory({ ov::PartialShape{ weight_b, input_f }, data_types::f32,format::bfyx});
+
+        set_values(input_data1, { 0.5f, -2.0f, -0.5f,
+                                -0.5f, 2.0f, 0.5f });
+        set_values(input_data2, { -0.5f, 2.0f, 0.5f });
+        set_values(weights_data, { 1.5f, 1.0f, 0.5f,
+                                -1.0f, 0.0f, 0.5f,
+                                0.5f, -0.5f, -2.0f,
+                                -0.5f, 1.0f, 1.5f });
+
+        cldnn::topology topology{
+            input_layout("input", input_dyn_layout),
+            data("weights", weights_data),
+            fully_connected("fc", input_info("input"), "weights")
+        };
+
+        ExecutionConfig config = get_test_default_config(engine);
+        config.set_property(ov::intel_gpu::optimize_data(true));
+        config.set_property(ov::intel_gpu::allow_new_shape_infer(true));
+        network::ptr network = get_network(engine, topology, config, get_test_stream_ptr(), is_caching_test);
+
+        // Call different shape multiple times to ensure caching works fine
+        for (size_t i = 0; i < 2; i++) {
+            {
+                network->set_input_data("input", input_data1);
+
+                auto outputs = network->execute();
+                ASSERT_EQ(outputs.size(), size_t(1));
+                ASSERT_EQ(outputs.begin()->first, "fc");
+
+                auto output_prim_mem = outputs.begin()->second.get_memory();
+
+                auto out_l = network->get_output_layout(outputs.begin()->first);
+                ASSERT_EQ(output_prim_mem->get_layout().batch(), align_to(2, fake_alignment_size)); // fake_alignment
+                ASSERT_EQ(out_l.batch(), 2); // fake_alignment
+                ASSERT_EQ(out_l.feature(), weight_b);
+                ASSERT_EQ(out_l.spatial(0), 1);
+                ASSERT_EQ(out_l.spatial(1), 1);
+
+                cldnn::mem_lock<float> output_ptr (output_prim_mem, get_test_stream());
+
+                ASSERT_EQ(-1.5f, output_ptr[0]);
+                ASSERT_EQ(-0.75f, output_ptr[1]);
+                ASSERT_EQ(2.25f, output_ptr[2]);
+                ASSERT_EQ(-3.0f, output_ptr[3]);
+
+                ASSERT_EQ(1.5f, output_ptr[4]);
+                ASSERT_EQ(0.75f, output_ptr[5]);
+                ASSERT_EQ(-2.25f, output_ptr[6]);
+                ASSERT_EQ(3.0f, output_ptr[7]);
+            }
+
+            {
+                network->set_input_data("input", input_data2);
+
+                auto outputs = network->execute();
+                ASSERT_EQ(outputs.size(), size_t(1));
+                ASSERT_EQ(outputs.begin()->first, "fc");
+
+                auto output_prim_mem = outputs.begin()->second.get_memory();
+
+                auto out_l = network->get_output_layout(outputs.begin()->first);
+                ASSERT_EQ(output_prim_mem->get_layout().batch(), align_to(1, fake_alignment_size)); // fake_alignment
+                ASSERT_EQ(out_l.batch(), 1); // fake_alignment
+                ASSERT_EQ(out_l.feature(), weight_b);
+                ASSERT_EQ(out_l.spatial(0), 1);
+                ASSERT_EQ(out_l.spatial(1), 1);
+
+                cldnn::mem_lock<float> output_ptr (output_prim_mem, get_test_stream());
+
+                ASSERT_EQ(1.5f, output_ptr[0]);
+                ASSERT_EQ(0.75f, output_ptr[1]);
+                ASSERT_EQ(-2.25f, output_ptr[2]);
+                ASSERT_EQ(3.0f, output_ptr[3]);
+            }
+        }
+    }
+
+    void test_has_cached_weights_reorder(bool is_caching_test) {
+        auto& engine = get_test_engine();
+
+        const int32_t input_f = 3, input_b = 1, weight_b = 4;
+
+        auto fake_alignment_size = engine.get_device_info().supports_immad ? 8 : 16;
+        auto input_dyn_layout = layout{ ov::PartialShape{ ov::Dimension(1, 10), input_f }, data_types::f32,format::bfyx };
+        auto input_data = engine.allocate_memory(layout{ ov::PartialShape{ input_b, input_f }, data_types::f32,format::bfyx });
+        auto weights_data = engine.allocate_memory({ ov::PartialShape{ weight_b, input_f }, data_types::f32,format::bfyx });
+
+        set_values(input_data, { -0.5f, 2.0f, 0.5f });
+        set_values(weights_data, { 1.5f, 1.0f, 0.5f, -1.0f, 0.0f, 0.5f, 0.5f, -0.5f, -2.0f, -0.5f, 1.0f, 1.5f });
+
+        cldnn::topology topology{
+            input_layout("input", input_dyn_layout),
+            data("weights", weights_data),
+            fully_connected("fc", input_info("input"), "weights")
+        };
+
+        ov::intel_gpu::ImplementationDesc fc_impl_desc = { format::bfyx, "fully_connected_gpu_bf_tiled", impl_types::ocl };
+        ExecutionConfig config = get_test_default_config(engine);
+        config.set_property(ov::intel_gpu::optimize_data(true));
+        config.set_property(ov::intel_gpu::force_implementations(ov::intel_gpu::ImplForcingMap{ {"fc", fc_impl_desc} })),
+        config.set_property(ov::intel_gpu::allow_new_shape_infer(true));
+        network::ptr network = get_network(engine, topology, config, get_test_stream_ptr(), is_caching_test);
+        network->set_input_data("input", input_data);
+
+        auto outputs = network->execute();
+        ASSERT_EQ(outputs.size(), size_t(1));
+        ASSERT_EQ(outputs.begin()->first, "fc");
+
+        auto output_prim_mem = outputs.begin()->second.get_memory();
+
+        auto inst = network->get_primitive("fc");
+        auto impl = inst->get_impl();
+        ASSERT_TRUE(impl != nullptr);
+        ASSERT_TRUE(impl->is_dynamic());
+
+        auto reorder_kernel_params = impl->get_weights_reorder_kernel_params();
+        ASSERT_TRUE(reorder_kernel_params != nullptr);
+        auto reorder_impl = network->get_program()->get_implementations_cache().get(*reorder_kernel_params);
+        // cldnn shape agnostic kernel reorder is done in build time
+        // therefore the reorder is no longer in cache, but the program_node of weight data is in the preferred format
+        ASSERT_TRUE(reorder_impl == nullptr);
+
+        auto out_l = network->get_output_layout(outputs.begin()->first);
+        ASSERT_EQ(output_prim_mem->get_layout().batch(), align_to(input_b, fake_alignment_size)); // fake_alignment
+        ASSERT_EQ(out_l.batch(), input_b);
+        ASSERT_EQ(out_l.feature(), weight_b);
+        ASSERT_EQ(out_l.spatial(0), 1);
+        ASSERT_EQ(out_l.spatial(1), 1);
+
+        cldnn::mem_lock<float> output_ptr (output_prim_mem, get_test_stream());
+
+        ASSERT_EQ(1.5f, output_ptr[0]);
+        ASSERT_EQ(0.75f, output_ptr[1]);
+        ASSERT_EQ(-2.25f, output_ptr[2]);
+        ASSERT_EQ(3.0f, output_ptr[3]);
+    }
+
+    void test_weights_reorder_shapes_update(bool is_caching_test) {
+        auto& engine = get_test_engine();
+
+        const int32_t input_f = 3, input_b = 1, weight_b = 4;
+
+        auto input_dyn_layout = layout{ ov::PartialShape{ ov::Dimension(1, 10), input_f }, data_types::f32, format::bfyx };
+        auto input_data = engine.allocate_memory(layout{ ov::PartialShape{ input_b, input_f }, data_types::f32, format::bfyx });
+        auto weights_data = engine.allocate_memory({ ov::PartialShape{ weight_b, input_f }, data_types::f32, format::bfyx });
+
+        set_values(input_data, { -0.5f, 2.0f, 0.5f });
+        set_values(weights_data, { 1.5f, 1.0f, 0.5f, -1.0f, 0.0f, 0.5f, 0.5f, -0.5f, -2.0f, -0.5f, 1.0f, 1.5f });
+
+        cldnn::topology topology{
+            input_layout("input", input_dyn_layout),
+            data("weights", weights_data),
+            fully_connected("fc", input_info("input"), "weights")
+        };
+
+        ExecutionConfig config = get_test_default_config(engine);
+        config.set_property(ov::intel_gpu::optimize_data(true));
+        config.set_property(ov::intel_gpu::allow_new_shape_infer(true));
+        network::ptr network = get_network(engine, topology, config, get_test_stream_ptr(), is_caching_test);
+        network->set_input_data("input", input_data);
+
+        auto outputs = network->execute();
+        ASSERT_EQ(outputs.size(), size_t(1));
+        ASSERT_EQ(outputs.begin()->first, "fc");
+
+        auto inst = network->get_primitive("fc");
+        auto impl = inst->get_impl();
+        ASSERT_TRUE(impl != nullptr);
+        ASSERT_TRUE(impl->is_dynamic());
+
+        ASSERT_TRUE(impl->need_weights_reorder());
+        auto weights_reorder_params = impl->get_weights_reorder_params();
+        auto out_weights_reorder_layout = weights_reorder_params->get_output_layout();
+        auto out_weights_reorder_pshape = out_weights_reorder_layout.get_partial_shape();
+        ASSERT_EQ(weights_data->get_layout().get_partial_shape(), out_weights_reorder_pshape);
+
+        auto output_prim_mem = outputs.begin()->second.get_memory();
+        cldnn::mem_lock<float> output_ptr (output_prim_mem, get_test_stream());
+
+        ASSERT_EQ(1.5f, output_ptr[0]);
+        ASSERT_EQ(0.75f, output_ptr[1]);
+        ASSERT_EQ(-2.25f, output_ptr[2]);
+        ASSERT_EQ(3.0f, output_ptr[3]);
+    }
+};
+
 using shared_dims = std::tuple<size_t, size_t, size_t>;
 using fully_connected_test_params = std::tuple<
     size_t,        // batch_num
@@ -1155,8 +1672,7 @@ using fully_connected_test_params = std::tuple<
     size_t,        // output_f
     format::type,  // input format
     format::type,  // output format
-    std::string,   // kernel
-    bool           // is_caching_test
+    std::string   // kernel
 >;
 
 template <typename InputT, typename WeightsT, typename BiasT, typename OutputT>
@@ -1167,14 +1683,13 @@ struct fully_connected_random_test : ::testing::TestWithParam<fully_connected_te
         rg.set_seed(GET_SUITE_NAME);
     }
 
-    void run_test() {
+    void run_test(bool is_caching_test = false) {
         shared_dims dims;
         size_t batch, input_f, input_x, input_y, output_f;
         format::type input_format, output_format;
         std::string kernel;
-        bool is_caching_test;
 
-        std::tie(batch, dims, output_f, input_format, output_format, kernel, is_caching_test) = GetParam();
+        std::tie(batch, dims, output_f, input_format, output_format, kernel) = GetParam();
         std::tie(input_f, input_x, input_y) = dims;
 
         auto input_data = rg.generate_random_4d<InputT>(batch, input_f, input_y, input_x, type_test_ranges<InputT>::min, type_test_ranges<InputT>::max, type_test_ranges<InputT>::k);
@@ -1209,8 +1724,7 @@ INSTANTIATE_TEST_SUITE_P(
         ::testing::Values(3, 32),
         ::testing::Values(format::bfyx, format::yxfb),
         ::testing::Values(format::any),
-        ::testing::Values(""),
-        ::testing::Values(false))
+        ::testing::Values(""))
 );
 
 INSTANTIATE_TEST_SUITE_P(
@@ -1223,8 +1737,7 @@ INSTANTIATE_TEST_SUITE_P(
         ::testing::Values(3, 32),
         ::testing::Values(format::bfyx),
         ::testing::Values(format::bfyx),
-        ::testing::Values(""),
-        ::testing::Values(false))
+        ::testing::Values(""))
 );
 
 TEST_P(fully_connected_random_test_f16, basic) {
@@ -1243,8 +1756,7 @@ INSTANTIATE_TEST_SUITE_P(
         ::testing::Values(3, 32),
         ::testing::Values(format::bfyx),
         ::testing::Values(format::any),
-        ::testing::Values(""),
-        ::testing::Values(false))
+        ::testing::Values(""))
 );
 
 INSTANTIATE_TEST_SUITE_P(
@@ -1257,8 +1769,7 @@ INSTANTIATE_TEST_SUITE_P(
         ::testing::Values(3, 32),
         ::testing::Values(format::bfyx),
         ::testing::Values(format::any),
-        ::testing::Values("fully_connected_gpu_bs_f_bsv16_af8_vload"),
-        ::testing::Values(false))
+        ::testing::Values("fully_connected_gpu_bs_f_bsv16_af8_vload"))
 );
 
 INSTANTIATE_TEST_SUITE_P(
@@ -1271,8 +1782,7 @@ INSTANTIATE_TEST_SUITE_P(
         ::testing::Values(3, 32),
         ::testing::Values(format::yxfb),
         ::testing::Values(format::any),
-        ::testing::Values(""),
-        ::testing::Values(false))
+        ::testing::Values(""))
 );
 
 INSTANTIATE_TEST_SUITE_P(
@@ -1285,8 +1795,7 @@ INSTANTIATE_TEST_SUITE_P(
         ::testing::Values(3, 32),
         ::testing::Values(format::bfyx),
         ::testing::Values(format::bfyx),
-        ::testing::Values(""),
-        ::testing::Values(false))
+        ::testing::Values(""))
 );
 
 INSTANTIATE_TEST_SUITE_P(
@@ -1298,8 +1807,7 @@ INSTANTIATE_TEST_SUITE_P(
         ::testing::Values(32),
         ::testing::Values(format::bfyx),
         ::testing::Values(format::bfyx),
-        ::testing::Values(""),
-        ::testing::Values(true))
+        ::testing::Values(""))
 );
 
 template <typename InputT, typename WeightsT, typename BiasT, typename OutputT>
@@ -1310,14 +1818,13 @@ struct fully_connected_random_test_3d : ::testing::TestWithParam<fully_connected
         rg.set_seed(GET_SUITE_NAME);
     }
 
-    void run_test() {
+    void run_test(bool is_caching_test = false) {
         shared_dims dims;
         size_t batch, input_f, input_x, input_y, output_y;
         format::type input_format, output_format;
         std::string kernel;
-        bool is_caching_test;
 
-        std::tie(batch, dims, output_y, input_format, output_format, kernel, is_caching_test) = GetParam();
+        std::tie(batch, dims, output_y, input_format, output_format, kernel) = GetParam();
         std::tie(input_f, input_x, input_y) = dims;
 
         auto input_data = rg.generate_random_4d<InputT>(batch, input_f, input_y, input_x, type_test_ranges<InputT>::min, type_test_ranges<InputT>::max, type_test_ranges<InputT>::k);
@@ -1359,8 +1866,7 @@ INSTANTIATE_TEST_SUITE_P(
         ::testing::Values(1, 3, 16),
         ::testing::Values(format::bfyx),
         ::testing::Values(format::any),
-        ::testing::Values(""),
-        ::testing::Values(false))
+        ::testing::Values(""))
 );
 
 INSTANTIATE_TEST_SUITE_P(
@@ -1375,8 +1881,7 @@ INSTANTIATE_TEST_SUITE_P(
         ::testing::Values(1, 32, 64),
         ::testing::Values(format::bfyx),
         ::testing::Values(format::any),
-        ::testing::Values(""),
-        ::testing::Values(false))
+        ::testing::Values(""))
 );
 
 INSTANTIATE_TEST_SUITE_P(
@@ -1391,8 +1896,7 @@ INSTANTIATE_TEST_SUITE_P(
         ::testing::Values(17, 32),
         ::testing::Values(format::bfyx),
         ::testing::Values(format::any),
-        ::testing::Values(""),
-        ::testing::Values(false))
+        ::testing::Values(""))
 );
 
 TEST_P(fully_connected_random_test_f16_3d, basic) {
@@ -1411,8 +1915,7 @@ INSTANTIATE_TEST_SUITE_P(
         ::testing::Values(1, 3, 16),
         ::testing::Values(format::bfyx),
         ::testing::Values(format::any),
-        ::testing::Values(""),
-        ::testing::Values(false))
+        ::testing::Values(""))
 );
 
 TEST_P(fully_connected_random_test_i8_3d, basic) {
@@ -1431,8 +1934,7 @@ INSTANTIATE_TEST_SUITE_P(
         ::testing::Values(1, 3, 16),
         ::testing::Values(format::bfyx),
         ::testing::Values(format::any),
-        ::testing::Values(""),
-        ::testing::Values(false))
+        ::testing::Values(""))
 );
 
 INSTANTIATE_TEST_SUITE_P(
@@ -1447,8 +1949,7 @@ INSTANTIATE_TEST_SUITE_P(
         ::testing::Values(1, 32, 64),
         ::testing::Values(format::bfyx),
         ::testing::Values(format::any),
-        ::testing::Values(""),
-        ::testing::Values(false))
+        ::testing::Values(""))
 );
 
 INSTANTIATE_TEST_SUITE_P(
@@ -1463,8 +1964,7 @@ INSTANTIATE_TEST_SUITE_P(
         ::testing::Values(17, 32),
         ::testing::Values(format::bfyx),
         ::testing::Values(format::any),
-        ::testing::Values(""),
-        ::testing::Values(false))
+        ::testing::Values(""))
 );
 
 
@@ -2039,410 +2539,76 @@ TEST(fully_connected_3d_onednn_gpu, no_biases_int8) {
 }
 #endif
 
-TEST(fully_connected_gpu, dynamic) {
-    auto& engine = get_test_engine();
-
-    const int32_t input_f = 3, input_b = 1, weight_b = 4;
-
-    auto fake_alignment_size = engine.get_device_info().supports_immad ? 8 : 16;
-    auto input_dyn_layout = layout{ ov::PartialShape{ ov::Dimension(1, 10), input_f }, data_types::f32,format::bfyx };
-    auto input_data = engine.allocate_memory(layout{ ov::PartialShape{ input_b, input_f }, data_types::f32,format::bfyx });
-    auto weights_data = engine.allocate_memory({ ov::PartialShape{ weight_b, input_f }, data_types::f32,format::bfyx });
-
-    set_values(input_data, { -0.5f, 2.0f, 0.5f });
-    set_values(weights_data, { 1.5f, 1.0f, 0.5f, -1.0f, 0.0f, 0.5f, 0.5f, -0.5f, -2.0f, -0.5f, 1.0f, 1.5f });
-
-    cldnn::topology topology{
-        input_layout("input", input_dyn_layout),
-        data("weights", weights_data),
-        fully_connected("fc", input_info("input"), "weights")
-    };
-
-    ExecutionConfig config = get_test_default_config(engine);
-    config.set_property(ov::intel_gpu::optimize_data(true));
-    config.set_property(ov::intel_gpu::allow_new_shape_infer(true));
-    network network(engine, topology, config);
-    network.set_input_data("input", input_data);
-
-    auto outputs = network.execute();
-    ASSERT_EQ(outputs.size(), size_t(1));
-    ASSERT_EQ(outputs.begin()->first, "fc");
-
-    auto output_prim_mem = outputs.begin()->second.get_memory();
-
-    auto out_l = network.get_output_layout(outputs.begin()->first);
-    ASSERT_EQ(output_prim_mem->get_layout().batch(), align_to(input_b, fake_alignment_size)); // fake_alignment
-    ASSERT_EQ(out_l.batch(), input_b);
-    ASSERT_EQ(out_l.feature(), weight_b);
-    ASSERT_EQ(out_l.spatial(0), 1);
-    ASSERT_EQ(out_l.spatial(1), 1);
-
-    cldnn::mem_lock<float> output_ptr (output_prim_mem, get_test_stream());
-
-    ASSERT_EQ(1.5f, output_ptr[0]);
-    ASSERT_EQ(0.75f, output_ptr[1]);
-    ASSERT_EQ(-2.25f, output_ptr[2]);
-    ASSERT_EQ(3.0f, output_ptr[3]);
+TEST_F(fully_connected_gpu_tests, compressed_scale_zp_bias) {
+    this->test_compressed_scale_zp_bias(false);
 }
 
-TEST(fully_connected_gpu, dynamic_6d_input) {
-    auto& engine = get_test_engine();
-
-    const int32_t input_b = 1, input_f = 3, input_w = 2, input_z = 1, input_y = 1, input_x = 4;
-    const int32_t weight_b = 2;
-
-    auto input_dyn_layout = layout{ov::PartialShape{ov::Dimension(-1), input_f, input_w, input_z, input_y, input_x}, data_types::f32, format::bfwzyx};
-    auto input_data = engine.allocate_memory(layout{ov::PartialShape{input_b, input_f, input_w, input_z, input_y, input_x}, data_types::f32, format::bfwzyx});
-    auto weights_data = engine.allocate_memory({ov::PartialShape{weight_b, input_x}, data_types::f32, format::bfyx });
-
-    set_values(input_data, {-0.5f, 2.0f, 0.5f, 1.f,  -1.5f, 2.0f, 0.5f, 1.f,
-                            -0.5f, 2.5f, 0.5f, 1.f,  -0.5f, 3.0f, 0.5f, 1.f,
-                            -0.5f, 2.0f, 0.5f, 1.f,  -0.5f, 2.0f, 2.5f, 1.f});
-    set_values(weights_data, {1.5f, 1.0f, -1.0f, 0.0f,
-                              0.5f, -0.5f, -0.5f, 1.0f, });
-
-    cldnn::topology topology{
-        input_layout("input", input_dyn_layout),
-        data("weights", weights_data),
-        fully_connected("fc", input_info("input"), "weights", "", cldnn::padding(), input_dyn_layout.get_rank())
-    };
-
-    ExecutionConfig config = get_test_default_config(engine);
-    config.set_property(ov::intel_gpu::optimize_data(true));
-    config.set_property(ov::intel_gpu::allow_new_shape_infer(true));
-    network network(engine, topology, config);
-    network.set_input_data("input", input_data);
-
-    auto outputs = network.execute();
-    ASSERT_EQ(outputs.size(), size_t(1));
-    ASSERT_EQ(outputs.begin()->first, "fc");
-
-    auto output_prim_mem = outputs.begin()->second.get_memory();
-
-    auto out_l = network.get_output_layout(outputs.begin()->first);
-    ASSERT_EQ(output_prim_mem->get_layout().batch(), 1);
-    ASSERT_EQ(out_l.batch(), 1);
-    ASSERT_EQ(out_l.feature(), 3);
-    ASSERT_EQ(out_l.spatial(0), 2);
-    ASSERT_EQ(out_l.spatial(1), 1);
-    ASSERT_EQ(out_l.spatial(2), 1);
-    ASSERT_EQ(out_l.spatial(3), 2);
-
-    std::vector<float> expected_output = {
-        0.75, -0.5, -0.75, -1, 1.25, -0.75, 1.75, -1, 0.75, -0.5, -1.25, -1.5
-    };
-
-    cldnn::mem_lock<float> output_ptr(output_prim_mem, get_test_stream());
-
-    for (size_t i = 0 ; i < out_l.get_linear_size(); i++) {
-        ASSERT_EQ(expected_output[i], output_ptr[i]);
-    }
+TEST_F(fully_connected_gpu_tests, compressed_scale_zp_bias_cached) {
+    this->test_compressed_scale_zp_bias(true);
 }
 
-TEST(fully_connected_gpu, static_6d_input) {
-    auto& engine = get_test_engine();
-
-    const int32_t input_b = 1, input_f = 3, input_w = 2, input_z = 1, input_y = 1, input_x = 4;
-    const int32_t weight_b = 2;
-
-    auto input_dyn_layout = layout{ov::PartialShape{input_b, input_f, input_w, input_z, input_y, input_x}, data_types::f32, format::bfwzyx};
-    auto input_data = engine.allocate_memory(input_dyn_layout);
-    auto weights_data = engine.allocate_memory({ov::PartialShape{weight_b, input_x}, data_types::f32, format::bfyx });
-
-    set_values(input_data, {-0.5f, 2.0f, 0.5f, 1.f,  -1.5f, 2.0f, 0.5f, 1.f,
-                            -0.5f, 2.5f, 0.5f, 1.f,  -0.5f, 3.0f, 0.5f, 1.f,
-                            -0.5f, 2.0f, 0.5f, 1.f,  -0.5f, 2.0f, 2.5f, 1.f});
-    set_values(weights_data, {1.5f, 1.0f, -1.0f, 0.0f,
-                              0.5f, -0.5f, -0.5f, 1.0f, });
-
-    cldnn::topology topology{
-        input_layout("input", input_dyn_layout),
-        data("weights", weights_data),
-        fully_connected("fc", input_info("input"), "weights", "", cldnn::padding(), input_dyn_layout.get_rank()),
-    };
-
-    ExecutionConfig config = get_test_default_config(engine);
-    config.set_property(ov::intel_gpu::optimize_data(true));
-    network network(engine, topology, config);
-    network.set_input_data("input", input_data);
-
-    auto outputs = network.execute();
-    ASSERT_EQ(outputs.size(), size_t(1));
-    ASSERT_EQ(outputs.begin()->first, "fc");
-
-    auto output_prim_mem = outputs.begin()->second.get_memory();
-
-    auto out_l = network.get_output_layout(outputs.begin()->first);
-    ASSERT_EQ(output_prim_mem->get_layout().batch(), 6);
-    ASSERT_EQ(out_l.batch(), 6);
-    ASSERT_EQ(out_l.feature(), 2);
-    ASSERT_EQ(out_l.spatial(0), 1);
-    ASSERT_EQ(out_l.spatial(1), 1);
-
-    std::vector<float> expected_output = {
-        0.75, -0.5, -0.75, -1, 1.25, -0.75, 1.75, -1, 0.75, -0.5, -1.25, -1.5
-    };
-
-    cldnn::mem_lock<float> output_ptr(output_prim_mem, get_test_stream());
-
-    for (size_t i = 0 ; i < out_l.get_linear_size(); i++) {
-        ASSERT_EQ(expected_output[i], output_ptr[i]);
-    }
+TEST_F(fully_connected_gpu_tests, compressed_scale_bias) {
+    this->test_compressed_scale_bias(false);
 }
 
-TEST(fully_connected_gpu, dynamic_multi_inference_same_shape) {
-    auto& engine = get_test_engine();
-    const int32_t input_f = 3, input_b = 1, weight_b = 4;
-
-    auto input_dyn_layout = layout{ ov::PartialShape{ ov::Dimension(1, 10), input_f }, data_types::f32,format::bfyx };
-    auto input_actual_layout = layout{ ov::PartialShape{ input_b, input_f }, data_types::f32,format::bfyx };
-    auto input_data1 = engine.allocate_memory(input_actual_layout);
-    auto input_data2 = engine.allocate_memory(input_actual_layout);
-    auto weights_data = engine.allocate_memory({ ov::PartialShape{ weight_b, input_f }, data_types::f32,format::bfyx });
-    auto fake_alignment_size = engine.get_device_info().supports_immad ? 8 : 16;
-    set_values(input_data1, { 0.5f, -2.0f, -0.5f });
-    set_values(input_data2, { -0.5f, 2.0f, 0.5f });
-    set_values(weights_data, { 1.5f, 1.0f, 0.5f,
-                              -1.0f, 0.0f, 0.5f,
-                              0.5f, -0.5f, -2.0f,
-                              -0.5f, 1.0f, 1.5f });
-
-    cldnn::topology topology{
-        input_layout("input", input_dyn_layout),
-        data("weights", weights_data),
-        fully_connected("fc", input_info("input"), "weights")
-    };
-
-    ExecutionConfig config = get_test_default_config(engine);
-    config.set_property(ov::intel_gpu::optimize_data(true));
-    config.set_property(ov::intel_gpu::allow_new_shape_infer(true));
-    network network(engine, topology, config);
-
-    {
-        network.set_input_data("input", input_data1);
-
-        auto outputs = network.execute();
-        ASSERT_EQ(outputs.size(), size_t(1));
-        ASSERT_EQ(outputs.begin()->first, "fc");
-
-        auto output_prim_mem = outputs.begin()->second.get_memory();
-
-        auto out_l = network.get_output_layout(outputs.begin()->first);
-        ASSERT_EQ(output_prim_mem->get_layout().batch(), align_to(input_b, fake_alignment_size)); // fake_alignment
-        ASSERT_EQ(out_l.batch(), input_b);
-        ASSERT_EQ(out_l.feature(), weight_b);
-        ASSERT_EQ(out_l.spatial(0), 1);
-        ASSERT_EQ(out_l.spatial(1), 1);
-
-        cldnn::mem_lock<float> output_ptr (output_prim_mem, get_test_stream());
-
-        ASSERT_EQ(-1.5f, output_ptr[0]);
-        ASSERT_EQ(-0.75f, output_ptr[1]);
-        ASSERT_EQ(2.25f, output_ptr[2]);
-        ASSERT_EQ(-3.0f, output_ptr[3]);
-    }
-
-    {
-        network.set_input_data("input", input_data2);
-
-        auto outputs = network.execute();
-        ASSERT_EQ(outputs.size(), size_t(1));
-        ASSERT_EQ(outputs.begin()->first, "fc");
-
-        auto output_prim_mem = outputs.begin()->second.get_memory();
-
-        auto out_l = network.get_output_layout(outputs.begin()->first);
-        ASSERT_EQ(output_prim_mem->get_layout().batch(), align_to(input_b, fake_alignment_size)); // fake_alignment
-        ASSERT_EQ(out_l.batch(), input_b);
-        ASSERT_EQ(out_l.feature(), weight_b);
-        ASSERT_EQ(out_l.spatial(0), 1);
-        ASSERT_EQ(out_l.spatial(1), 1);
-
-        cldnn::mem_lock<float> output_ptr (output_prim_mem, get_test_stream());
-
-        ASSERT_EQ(1.5f, output_ptr[0]);
-        ASSERT_EQ(0.75f, output_ptr[1]);
-        ASSERT_EQ(-2.25f, output_ptr[2]);
-        ASSERT_EQ(3.0f, output_ptr[3]);
-    }
+TEST_F(fully_connected_gpu_tests, compressed_scale_bias_cached) {
+    this->test_compressed_scale_bias(true);
 }
 
-TEST(fully_connected_gpu, dynamic_multi_inference_different_shape) {
-    auto& engine = get_test_engine();
-
-    const int32_t input_f = 3, weight_b = 4;
-
-    auto fake_alignment_size = engine.get_device_info().supports_immad ? 8 : 16;
-    auto input_dyn_layout = layout{ ov::PartialShape{ ov::Dimension(1, 10), input_f }, data_types::f32,format::bfyx };
-    auto input_actual_layout1 = layout{ ov::PartialShape{ 2, input_f }, data_types::f32,format::bfyx};
-    auto input_actual_layout2 = layout{ ov::PartialShape{ 1, input_f }, data_types::f32,format::bfyx};
-    auto input_data1 = engine.allocate_memory(input_actual_layout1);
-    auto input_data2 = engine.allocate_memory(input_actual_layout2);
-    auto weights_data = engine.allocate_memory({ ov::PartialShape{ weight_b, input_f }, data_types::f32,format::bfyx});
-
-    set_values(input_data1, { 0.5f, -2.0f, -0.5f,
-                              -0.5f, 2.0f, 0.5f });
-    set_values(input_data2, { -0.5f, 2.0f, 0.5f });
-    set_values(weights_data, { 1.5f, 1.0f, 0.5f,
-                              -1.0f, 0.0f, 0.5f,
-                              0.5f, -0.5f, -2.0f,
-                              -0.5f, 1.0f, 1.5f });
-
-    cldnn::topology topology{
-        input_layout("input", input_dyn_layout),
-        data("weights", weights_data),
-        fully_connected("fc", input_info("input"), "weights")
-    };
-
-    ExecutionConfig config = get_test_default_config(engine);
-    config.set_property(ov::intel_gpu::optimize_data(true));
-    config.set_property(ov::intel_gpu::allow_new_shape_infer(true));
-    network network(engine, topology, config);
-
-    auto inst = network.get_primitive("fc");
-    ASSERT_TRUE(inst->is_dynamic());
-
-    {
-        network.set_input_data("input", input_data1);
-
-        auto outputs = network.execute();
-        ASSERT_EQ(outputs.size(), size_t(1));
-        ASSERT_EQ(outputs.begin()->first, "fc");
-
-        auto output_prim_mem = outputs.begin()->second.get_memory();
-
-        auto out_l = network.get_output_layout(outputs.begin()->first);
-        ASSERT_EQ(output_prim_mem->get_layout().batch(), align_to(2, fake_alignment_size)); // fake_alignment
-        ASSERT_EQ(out_l.batch(), 2);
-        ASSERT_EQ(out_l.feature(), weight_b);
-        ASSERT_EQ(out_l.spatial(0), 1);
-        ASSERT_EQ(out_l.spatial(1), 1);
-
-        cldnn::mem_lock<float> output_ptr (output_prim_mem, get_test_stream());
-
-        ASSERT_EQ(-1.5f, output_ptr[0]);
-        ASSERT_EQ(-0.75f, output_ptr[1]);
-        ASSERT_EQ(2.25f, output_ptr[2]);
-        ASSERT_EQ(-3.0f, output_ptr[3]);
-
-        ASSERT_EQ(1.5f, output_ptr[4]);
-        ASSERT_EQ(0.75f, output_ptr[5]);
-        ASSERT_EQ(-2.25f, output_ptr[6]);
-        ASSERT_EQ(3.0f, output_ptr[7]);
-    }
-
-    {
-        network.set_input_data("input", input_data2);
-
-        auto outputs = network.execute();
-        ASSERT_EQ(outputs.size(), size_t(1));
-        ASSERT_EQ(outputs.begin()->first, "fc");
-
-        auto output_prim_mem = outputs.begin()->second.get_memory();
-
-        auto out_l = network.get_output_layout(outputs.begin()->first);
-        ASSERT_EQ(output_prim_mem->get_layout().batch(), align_to(1, fake_alignment_size)); // fake_alignment
-        ASSERT_EQ(out_l.batch(), 1);
-        ASSERT_EQ(out_l.feature(), weight_b);
-        ASSERT_EQ(out_l.spatial(0), 1);
-        ASSERT_EQ(out_l.spatial(1), 1);
-
-        cldnn::mem_lock<float> output_ptr (output_prim_mem, get_test_stream());
-
-        ASSERT_EQ(1.5f, output_ptr[0]);
-        ASSERT_EQ(0.75f, output_ptr[1]);
-        ASSERT_EQ(-2.25f, output_ptr[2]);
-        ASSERT_EQ(3.0f, output_ptr[3]);
-    }
+TEST_F(fully_connected_gpu_tests, compressed_scale_fp16) {
+    this->test_compressed_scale_fp16(false);
 }
 
-TEST(fully_connected_gpu, dynamic_multi_inference_multiple_shapes) {
-    auto& engine = get_test_engine();
+TEST_F(fully_connected_gpu_tests, compressed_scale_fp16_cached) {
+    this->test_compressed_scale_fp16(false);
+}
 
-    const int32_t input_f = 3, weight_b = 4;
+TEST_F(fully_connected_gpu_tests, dynamic) {
+    this->test_dynamic(false);
+}
 
-    auto fake_alignment_size = engine.get_device_info().supports_immad ? 8 : 16;
-    auto input_dyn_layout = layout{ ov::PartialShape{ ov::Dimension(1, 10), input_f }, data_types::f32,format::bfyx };
-    auto input_actual_layout1 = layout{ ov::PartialShape{ 2, input_f }, data_types::f32,format::bfyx};
-    auto input_actual_layout2 = layout{ ov::PartialShape{ 1, input_f }, data_types::f32,format::bfyx};
-    auto input_data1 = engine.allocate_memory(input_actual_layout1);
-    auto input_data2 = engine.allocate_memory(input_actual_layout2);
-    auto weights_data = engine.allocate_memory({ ov::PartialShape{ weight_b, input_f }, data_types::f32,format::bfyx});
+TEST_F(fully_connected_gpu_tests, dynamic_cached) {
+    this->test_dynamic(true);
+}
 
-    set_values(input_data1, { 0.5f, -2.0f, -0.5f,
-                              -0.5f, 2.0f, 0.5f });
-    set_values(input_data2, { -0.5f, 2.0f, 0.5f });
-    set_values(weights_data, { 1.5f, 1.0f, 0.5f,
-                              -1.0f, 0.0f, 0.5f,
-                              0.5f, -0.5f, -2.0f,
-                              -0.5f, 1.0f, 1.5f });
+TEST_F(fully_connected_gpu_tests, dynamic_6d_input) {
+    this->test_dynamic_6d_input(false);
+}
 
-    cldnn::topology topology{
-        input_layout("input", input_dyn_layout),
-        data("weights", weights_data),
-        fully_connected("fc", input_info("input"), "weights")
-    };
+TEST_F(fully_connected_gpu_tests, dynamic_6d_input_cached) {
+    this->test_dynamic_6d_input(true);
+}
 
-    ExecutionConfig config = get_test_default_config(engine);
-    config.set_property(ov::intel_gpu::optimize_data(true));
-    config.set_property(ov::intel_gpu::allow_new_shape_infer(true));
-    network network(engine, topology, config);
+TEST_F(fully_connected_gpu_tests, static_6d_input) {
+    this->test_static_6d_input(false);
+}
 
-    // Call different shape multiple times to ensure caching works fine
-    for (size_t i = 0; i < 2; i++) {
-        {
-            network.set_input_data("input", input_data1);
+TEST_F(fully_connected_gpu_tests, static_6d_input_cached) {
+    this->test_static_6d_input(true);
+}
 
-            auto outputs = network.execute();
-            ASSERT_EQ(outputs.size(), size_t(1));
-            ASSERT_EQ(outputs.begin()->first, "fc");
+TEST_F(fully_connected_gpu_tests, dynamic_multi_inference_same_shape) {
+    this->test_dynamic_multi_inference_same_shape(false);
+}
 
-            auto output_prim_mem = outputs.begin()->second.get_memory();
+TEST_F(fully_connected_gpu_tests, dynamic_multi_inference_same_shape_cached) {
+    this->test_dynamic_multi_inference_same_shape(true);
+}
 
-            auto out_l = network.get_output_layout(outputs.begin()->first);
-            ASSERT_EQ(output_prim_mem->get_layout().batch(), align_to(2, fake_alignment_size)); // fake_alignment
-            ASSERT_EQ(out_l.batch(), 2); // fake_alignment
-            ASSERT_EQ(out_l.feature(), weight_b);
-            ASSERT_EQ(out_l.spatial(0), 1);
-            ASSERT_EQ(out_l.spatial(1), 1);
+TEST_F(fully_connected_gpu_tests, dynamic_multi_inference_different_shape) {
+    this->test_dynamic_multi_inference_different_shape(false);
+}
 
-            cldnn::mem_lock<float> output_ptr (output_prim_mem, get_test_stream());
+TEST_F(fully_connected_gpu_tests, dynamic_multi_inference_different_shape_cached) {
+    this->test_dynamic_multi_inference_different_shape(true);
+}
 
-            ASSERT_EQ(-1.5f, output_ptr[0]);
-            ASSERT_EQ(-0.75f, output_ptr[1]);
-            ASSERT_EQ(2.25f, output_ptr[2]);
-            ASSERT_EQ(-3.0f, output_ptr[3]);
+TEST_F(fully_connected_gpu_tests, dynamic_multi_inference_multiple_shapes) {
+    this->test_dynamic_multi_inference_multiple_shapes(false);
+}
 
-            ASSERT_EQ(1.5f, output_ptr[4]);
-            ASSERT_EQ(0.75f, output_ptr[5]);
-            ASSERT_EQ(-2.25f, output_ptr[6]);
-            ASSERT_EQ(3.0f, output_ptr[7]);
-        }
-
-        {
-            network.set_input_data("input", input_data2);
-
-            auto outputs = network.execute();
-            ASSERT_EQ(outputs.size(), size_t(1));
-            ASSERT_EQ(outputs.begin()->first, "fc");
-
-            auto output_prim_mem = outputs.begin()->second.get_memory();
-
-            auto out_l = network.get_output_layout(outputs.begin()->first);
-            ASSERT_EQ(output_prim_mem->get_layout().batch(), align_to(1, fake_alignment_size)); // fake_alignment
-            ASSERT_EQ(out_l.batch(), 1); // fake_alignment
-            ASSERT_EQ(out_l.feature(), weight_b);
-            ASSERT_EQ(out_l.spatial(0), 1);
-            ASSERT_EQ(out_l.spatial(1), 1);
-
-            cldnn::mem_lock<float> output_ptr (output_prim_mem, get_test_stream());
-
-            ASSERT_EQ(1.5f, output_ptr[0]);
-            ASSERT_EQ(0.75f, output_ptr[1]);
-            ASSERT_EQ(-2.25f, output_ptr[2]);
-            ASSERT_EQ(3.0f, output_ptr[3]);
-        }
-    }
+TEST_F(fully_connected_gpu_tests, dynamic_multi_inference_multiple_shapes_cached) {
+    this->test_dynamic_multi_inference_multiple_shapes(true);
 }
 
 namespace {
@@ -2487,7 +2653,7 @@ struct dynamic_fully_connected_gpu : ::testing::TestWithParam<fully_connected_dy
         rg.set_seed(GET_SUITE_NAME);
     }
 
-    void run_test() {
+    void run_test(bool is_caching_test = false) {
         std::vector<ov::Dimension::value_type> batch_sizes;
         ov::Dimension::value_type input_f;
         ov::Dimension::value_type output_f;
@@ -2527,7 +2693,7 @@ struct dynamic_fully_connected_gpu : ::testing::TestWithParam<fully_connected_dy
         ExecutionConfig config = get_test_default_config(engine);
         config.set_property(ov::intel_gpu::optimize_data(true));
         config.set_property(ov::intel_gpu::allow_new_shape_infer(true));
-        network network(engine, topology, config);
+        network::ptr network = get_network(engine, topology, config, get_test_stream_ptr(), is_caching_test);
 
         for (const auto& batch_size : batch_sizes) {
             auto input_actual_layout = layout{ ov::PartialShape{ batch_size, input_f }, input_dt, format::bfyx };
@@ -2536,15 +2702,15 @@ struct dynamic_fully_connected_gpu : ::testing::TestWithParam<fully_connected_dy
             cldnn::memory_ptr input_mem = engine.allocate_memory(input_actual_layout);
             std::vector<InputT> input_data_vec = rg.generate_random_1d<InputT>(batch_size * input_f, 0, 1);
             set_values(input_mem, input_data_vec);
-            network.set_input_data("input", input_mem);
+            network->set_input_data("input", input_mem);
 
-            auto outputs = network.execute();
+            auto outputs = network->execute();
             ASSERT_EQ(outputs.size(), size_t(1));
             ASSERT_EQ(outputs.begin()->first, "fc");
 
             auto output_prim_mem = outputs.begin()->second.get_memory();
 
-            auto out_l = network.get_output_layout(outputs.begin()->first);
+            auto out_l = network->get_output_layout(outputs.begin()->first);
             ASSERT_EQ(out_l.batch(), fc_3d ? 1 : batch_size);
             ASSERT_EQ(out_l.feature(), fc_3d ? batch_size : output_f);
             ASSERT_EQ(out_l.spatial(0), 1);
@@ -2658,64 +2824,12 @@ INSTANTIATE_TEST_SUITE_P(
         ::testing::Values(false, true))
 );
 
-TEST(fully_connected_gpu, has_cached_weights_reorder) {
-    auto& engine = get_test_engine();
+TEST_F(fully_connected_gpu_tests, has_cached_weights_reorder) {
+    this->test_has_cached_weights_reorder(false);
+}
 
-    const int32_t input_f = 3, input_b = 1, weight_b = 4;
-
-    auto fake_alignment_size = engine.get_device_info().supports_immad ? 8 : 16;
-    auto input_dyn_layout = layout{ ov::PartialShape{ ov::Dimension(1, 10), input_f }, data_types::f32,format::bfyx };
-    auto input_data = engine.allocate_memory(layout{ ov::PartialShape{ input_b, input_f }, data_types::f32,format::bfyx });
-    auto weights_data = engine.allocate_memory({ ov::PartialShape{ weight_b, input_f }, data_types::f32,format::bfyx });
-
-    set_values(input_data, { -0.5f, 2.0f, 0.5f });
-    set_values(weights_data, { 1.5f, 1.0f, 0.5f, -1.0f, 0.0f, 0.5f, 0.5f, -0.5f, -2.0f, -0.5f, 1.0f, 1.5f });
-
-    cldnn::topology topology{
-        input_layout("input", input_dyn_layout),
-        data("weights", weights_data),
-        fully_connected("fc", input_info("input"), "weights")
-    };
-
-    ov::intel_gpu::ImplementationDesc fc_impl_desc = { format::bfyx, "fully_connected_gpu_bf_tiled", impl_types::ocl };
-    ExecutionConfig config = get_test_default_config(engine);
-    config.set_property(ov::intel_gpu::optimize_data(true));
-    config.set_property(ov::intel_gpu::force_implementations(ov::intel_gpu::ImplForcingMap{ {"fc", fc_impl_desc} })),
-    config.set_property(ov::intel_gpu::allow_new_shape_infer(true));
-    network network(engine, topology, config);
-    network.set_input_data("input", input_data);
-
-    auto outputs = network.execute();
-    ASSERT_EQ(outputs.size(), size_t(1));
-    ASSERT_EQ(outputs.begin()->first, "fc");
-
-    auto output_prim_mem = outputs.begin()->second.get_memory();
-
-    auto inst = network.get_primitive("fc");
-    auto impl = inst->get_impl();
-    ASSERT_TRUE(impl != nullptr);
-    ASSERT_TRUE(impl->is_dynamic());
-
-    auto reorder_kernel_params = impl->get_weights_reorder_kernel_params();
-    ASSERT_TRUE(reorder_kernel_params != nullptr);
-    auto reorder_impl = network.get_program()->get_implementations_cache().get(*reorder_kernel_params);
-    // cldnn shape agnostic kernel reorder is done in build time
-    // therefore the reorder is no longer in cache, but the program_node of weight data is in the preferred format
-    ASSERT_TRUE(reorder_impl == nullptr);
-
-    auto out_l = network.get_output_layout(outputs.begin()->first);
-    ASSERT_EQ(output_prim_mem->get_layout().batch(), align_to(input_b, fake_alignment_size)); // fake_alignment
-    ASSERT_EQ(out_l.batch(), input_b);
-    ASSERT_EQ(out_l.feature(), weight_b);
-    ASSERT_EQ(out_l.spatial(0), 1);
-    ASSERT_EQ(out_l.spatial(1), 1);
-
-    cldnn::mem_lock<float> output_ptr (output_prim_mem, get_test_stream());
-
-    ASSERT_EQ(1.5f, output_ptr[0]);
-    ASSERT_EQ(0.75f, output_ptr[1]);
-    ASSERT_EQ(-2.25f, output_ptr[2]);
-    ASSERT_EQ(3.0f, output_ptr[3]);
+TEST_F(fully_connected_gpu_tests, has_cached_weights_reorder_cached) {
+    this->test_has_cached_weights_reorder(true);
 }
 
 template <typename InputT, typename T>
@@ -3016,50 +3130,10 @@ INSTANTIATE_TEST_SUITE_P(
     fully_connected_types_u8_f32_test::PrintToStringParamName
 );
 
-TEST(fully_connected_gpu, weights_reorder_shapes_update_test) {
-    auto& engine = get_test_engine();
-
-    const int32_t input_f = 3, input_b = 1, weight_b = 4;
-
-    auto input_dyn_layout = layout{ ov::PartialShape{ ov::Dimension(1, 10), input_f }, data_types::f32, format::bfyx };
-    auto input_data = engine.allocate_memory(layout{ ov::PartialShape{ input_b, input_f }, data_types::f32, format::bfyx });
-    auto weights_data = engine.allocate_memory({ ov::PartialShape{ weight_b, input_f }, data_types::f32, format::bfyx });
-
-    set_values(input_data, { -0.5f, 2.0f, 0.5f });
-    set_values(weights_data, { 1.5f, 1.0f, 0.5f, -1.0f, 0.0f, 0.5f, 0.5f, -0.5f, -2.0f, -0.5f, 1.0f, 1.5f });
-
-    cldnn::topology topology{
-        input_layout("input", input_dyn_layout),
-        data("weights", weights_data),
-        fully_connected("fc", input_info("input"), "weights")
-    };
-
-    ExecutionConfig config = get_test_default_config(engine);
-    config.set_property(ov::intel_gpu::optimize_data(true));
-    config.set_property(ov::intel_gpu::allow_new_shape_infer(true));
-    network network(engine, topology, config);
-    network.set_input_data("input", input_data);
-
-    auto outputs = network.execute();
-    ASSERT_EQ(outputs.size(), size_t(1));
-    ASSERT_EQ(outputs.begin()->first, "fc");
-
-    auto inst = network.get_primitive("fc");
-    auto impl = inst->get_impl();
-    ASSERT_TRUE(impl != nullptr);
-    ASSERT_TRUE(impl->is_dynamic());
-
-    ASSERT_TRUE(impl->need_weights_reorder());
-    auto weights_reorder_params = impl->get_weights_reorder_params();
-    auto out_weights_reorder_layout = weights_reorder_params->get_output_layout();
-    auto out_weights_reorder_pshape = out_weights_reorder_layout.get_partial_shape();
-    ASSERT_EQ(weights_data->get_layout().get_partial_shape(), out_weights_reorder_pshape);
-
-    auto output_prim_mem = outputs.begin()->second.get_memory();
-    cldnn::mem_lock<float> output_ptr (output_prim_mem, get_test_stream());
-
-    ASSERT_EQ(1.5f, output_ptr[0]);
-    ASSERT_EQ(0.75f, output_ptr[1]);
-    ASSERT_EQ(-2.25f, output_ptr[2]);
-    ASSERT_EQ(3.0f, output_ptr[3]);
+TEST_F(fully_connected_gpu_tests, weights_reorder_shapes_update) {
+    this->test_weights_reorder_shapes_update(false);
+}
+
+TEST_F(fully_connected_gpu_tests, weights_reorder_shapes_update_cached) {
+    this->test_weights_reorder_shapes_update(true);
 }
diff --git a/src/plugins/intel_gpu/tests/unit/test_cases/gemm_gpu_test.cpp b/src/plugins/intel_gpu/tests/unit/test_cases/gemm_gpu_test.cpp
index 24f7391ad20..feccaf402e8 100644
--- a/src/plugins/intel_gpu/tests/unit/test_cases/gemm_gpu_test.cpp
+++ b/src/plugins/intel_gpu/tests/unit/test_cases/gemm_gpu_test.cpp
@@ -130,21 +130,22 @@ public:
         if (is_caching_test) {
             membuf mem_buf;
             {
-                cldnn::network _network(engine, tp, get_test_default_config(engine));
-                process_program(_network.get_program());
                 std::ostream out_mem(&mem_buf);
                 BinaryOutputBuffer ob = BinaryOutputBuffer(out_mem);
-                _network.save(ob);
+                ob.set_stream(get_test_stream_ptr().get());
+                program::build_program(engine, tp, get_test_default_config(engine))->save(ob);
             }
             {
                 std::istream in_mem(&mem_buf);
                 BinaryInputBuffer ib = BinaryInputBuffer(in_mem, engine);
-                network = std::make_shared<cldnn::network>(ib, get_test_stream_ptr(), engine, true, 0);
+                auto imported_prog = std::make_shared<cldnn::program>(engine, get_test_default_config(engine));
+                imported_prog->load(ib);
+                network = std::make_shared<cldnn::network>(imported_prog);
             }
         } else {
             network = std::make_shared<cldnn::network>(engine, tp, get_test_default_config(engine));
-            process_program(network->get_program());
         }
+        process_program(network->get_program());
 
         for (auto &input : network_inputs) {
             network->set_input_data(input.first, input.second);
@@ -247,299 +248,313 @@ INSTANTIATE_TEST_SUITE_P(
         ::testing::Values(false), ::testing::Values(true),
         ::testing::Values(1.0f), ::testing::Values(0.0f)));
 
-template <typename T>
-void test_basic_bfyx_t2_inplace_crop_with_pad(bool is_caching_test) {
-    auto& engine = get_test_engine();
-    auto input = engine.allocate_memory({ data_types::f32, format::bfyx, { 1, 2, 4, 3 } });
-    auto input2 = engine.allocate_memory({ data_types::f32, format::bfyx, { 1, 1, 4, 1 } });
+class gemm_gpu_tests: public ::testing::Test {
+public:
+    void test_basic_bfyx_t2_inplace_crop_with_pad(bool is_caching_test) {
+        auto& engine = get_test_engine();
+        auto input = engine.allocate_memory({ data_types::f32, format::bfyx, { 1, 2, 4, 3 } });
+        auto input2 = engine.allocate_memory({ data_types::f32, format::bfyx, { 1, 1, 4, 1 } });
 
-    std::vector<T> input_data = {
-        1.f, -2.f,  3.f, -4.f,
-        5.f,  6.f, 1.f, 2.f,
-        3.f, 3.f, 2.f, -1.f,
+        std::vector<float> input_data = {
+            1.f, -2.f,  3.f, -4.f,
+            5.f,  6.f, 1.f, 2.f,
+            3.f, 3.f, 2.f, -1.f,
 
-        1.f, -2.f,  3.f, -4.f,
-        5.f,  6.f, 1.f, 2.f,
-        3.f, 3.f, 2.f, -1.f,
-    };
+            1.f, -2.f,  3.f, -4.f,
+            5.f,  6.f, 1.f, 2.f,
+            3.f, 3.f, 2.f, -1.f,
+        };
 
-    std::vector<T> input_data2 = {
-        2.f, 5.f, -4.f, -7.f,
-    };
-    set_values(input, input_data);
-    set_values(input2, input_data2);
+        std::vector<float> input_data2 = {
+            2.f, 5.f, -4.f, -7.f,
+        };
+        set_values(input, input_data);
+        set_values(input2, input_data2);
 
-    std::vector<T> out_data = {
-        8.f, 22.f, 20.f
-    };
+        std::vector<float> out_data = {
+            8.f, 22.f, 20.f
+        };
 
-    topology topology;
-    topology.add(
-        input_layout("input", input->get_layout())
-    );
-    topology.add(
-        input_layout("input2", input2->get_layout())
-    );
-    topology.add(
-        crop("crop.1", input_info("input"), { 1, 1, 4, 3 }, { 0, 1, 0, 0 })
-    );
-    topology.add(
-        gemm("output", { input_info("crop.1"), input_info("input2") }, data_types::f32, false, true)
-    );
+        topology topology;
+        topology.add(
+            input_layout("input", input->get_layout())
+        );
+        topology.add(
+            input_layout("input2", input2->get_layout())
+        );
+        topology.add(
+            crop("crop.1", input_info("input"), { 1, 1, 4, 3 }, { 0, 1, 0, 0 })
+        );
+        topology.add(
+            gemm("output", { input_info("crop.1"), input_info("input2") }, data_types::f32, false, true)
+        );
 
-    ExecutionConfig config = get_test_default_config(engine);
-    config.set_property(ov::intel_gpu::optimize_data(true));
-    cldnn::network::ptr network = get_network(engine, topology, config, get_test_stream_ptr(), is_caching_test);
-    network->set_input_data("input", input);
-    network->set_input_data("input2", input2);
-    auto outputs = network->execute();
+        ExecutionConfig config = get_test_default_config(engine);
+        config.set_property(ov::intel_gpu::optimize_data(true));
+        cldnn::network::ptr network = get_network(engine, topology, config, get_test_stream_ptr(), is_caching_test);
+        network->set_input_data("input", input);
+        network->set_input_data("input2", input2);
+        auto outputs = network->execute();
 
-    auto output = outputs.at("output").get_memory();
-    cldnn::mem_lock<T> output_ptr(output, get_test_stream());
+        auto output = outputs.at("output").get_memory();
+        cldnn::mem_lock<float> output_ptr(output, get_test_stream());
 
-    ASSERT_EQ(output_ptr.size(), (uint32_t)3);
-    for (uint32_t i = 0; i < out_data.size(); ++i) {
-        ASSERT_FLOAT_EQ(output_ptr[i], out_data[i]);
+        ASSERT_EQ(output_ptr.size(), (uint32_t)3);
+        for (uint32_t i = 0; i < out_data.size(); ++i) {
+            ASSERT_FLOAT_EQ(output_ptr[i], out_data[i]);
+        }
     }
-}
 
-TEST(gemm_gpu, basic_bfyx_t2_inplace_crop_with_pad) {
-    test_basic_bfyx_t2_inplace_crop_with_pad<float>(false);
-}
+    void test_dynamic(bool is_caching_test) {
+        auto& engine = get_test_engine();
+        ov::Shape in1_shape = { 1, 1, 3, 4 };
+        ov::Shape in2_shape = { 1, 4 };
+        auto in1_layout = layout{ov::PartialShape::dynamic(in1_shape.size()), data_types::f32, format::bfyx};
+        auto in2_layout = layout{ov::PartialShape::dynamic(in2_shape.size()), data_types::f32, format::bfyx};
+        auto input1 = engine.allocate_memory(layout{ov::PartialShape(in1_shape), data_types::f32, format::bfyx});
+        auto input2 = engine.allocate_memory(layout{ov::PartialShape(in2_shape), data_types::f32, format::bfyx});
 
-TEST(gemm_gpu, dynamic) {
-    auto& engine = get_test_engine();
-    ov::Shape in1_shape = { 1, 1, 3, 4 };
-    ov::Shape in2_shape = { 1, 4 };
-    auto in1_layout = layout{ov::PartialShape::dynamic(in1_shape.size()), data_types::f32, format::bfyx};
-    auto in2_layout = layout{ov::PartialShape::dynamic(in2_shape.size()), data_types::f32, format::bfyx};
-    auto input1 = engine.allocate_memory(layout{ov::PartialShape(in1_shape), data_types::f32, format::bfyx});
-    auto input2 = engine.allocate_memory(layout{ov::PartialShape(in2_shape), data_types::f32, format::bfyx});
+        std::vector<float> input1_data = {
+            1.f, -2.f, 3.f, -4.f,
+            5.f, 6.f, 1.f, 2.f,
+            3.f, 3.f, 2.f, -1.f,
+        };
 
-    std::vector<float> input1_data = {
-        1.f, -2.f, 3.f, -4.f,
-        5.f, 6.f, 1.f, 2.f,
-        3.f, 3.f, 2.f, -1.f,
-    };
+        std::vector<float> input2_data = {
+            2.f, 5.f, -4.f, -7.f,
+        };
+        set_values(input1, input1_data);
+        set_values(input2, input2_data);
 
-    std::vector<float> input2_data = {
-        2.f, 5.f, -4.f, -7.f,
-    };
-    set_values(input1, input1_data);
-    set_values(input2, input2_data);
+        std::vector<float> out_data = {
+            8.f, 22.f, 20.f
+        };
 
-    std::vector<float> out_data = {
-        8.f, 22.f, 20.f
-    };
+        topology topology;
+        topology.add(input_layout("input1", in1_layout),
+                    input_layout("input2", in2_layout),
+                    gemm("gemm", { input_info("input1"), input_info("input2") }, data_types::f32, false, true, 1.0f, 0.0f, 4, 2)
+        );
 
-    topology topology;
-    topology.add(input_layout("input1", in1_layout),
-                 input_layout("input2", in2_layout),
-                 gemm("gemm", { input_info("input1"), input_info("input2") }, data_types::f32, false, true, 1.0f, 0.0f, 4, 2)
-    );
+        ExecutionConfig config = get_test_default_config(engine);
+        config.set_property(ov::intel_gpu::optimize_data(true));
+        config.set_property(ov::intel_gpu::allow_new_shape_infer(true));
+        network::ptr network = get_network(engine, topology, config, get_test_stream_ptr(), is_caching_test);
+        network->set_input_data("input1", input1);
+        network->set_input_data("input2", input2);
 
-    ExecutionConfig config = get_test_default_config(engine);
-    config.set_property(ov::intel_gpu::optimize_data(true));
-    config.set_property(ov::intel_gpu::allow_new_shape_infer(true));
-    network network(engine, topology, config);
-    network.set_input_data("input1", input1);
-    network.set_input_data("input2", input2);
-
-    auto inst = network.get_primitive("gemm");
-    auto impl = inst->get_impl();
-    ASSERT_TRUE(impl != nullptr);
-    ASSERT_TRUE(impl->is_dynamic());
-
-    auto outputs = network.execute();
-
-    auto output = outputs.at("gemm").get_memory();
-    cldnn::mem_lock<float> output_ptr(output, get_test_stream());
-
-    ASSERT_EQ(output_ptr.size(), (uint32_t)3);
-    for (uint32_t i = 0; i < out_data.size(); ++i) {
-        ASSERT_FLOAT_EQ(output_ptr[i], out_data[i]);
-    }
-}
-
-TEST(gemm_gpu, dynamic_multi_inference_same_shape) {
-    auto& engine = get_test_engine();
-
-    auto in1_dyn_layout = layout{ ov::PartialShape{ 1, 1, ov::Dimension(1, 10), 4 }, data_types::f32, format::bfyx };
-    auto in1_actual_layout = layout{ ov::PartialShape{ 1, 1, 3, 4 }, data_types::f32, format::bfyx };
-    auto in2_dyn_layout = layout{ ov::PartialShape{ 4, ov::Dimension(1, 10) }, data_types::f32, format::bfyx };
-    auto in2_actual_layout = layout{ ov::PartialShape{ 4, 1 }, data_types::f32, format::bfyx };
-    auto input1_1 = engine.allocate_memory(in1_actual_layout);
-    auto input1_2 = engine.allocate_memory(in1_actual_layout);
-    auto input2_1 = engine.allocate_memory(in2_actual_layout);
-    auto input2_2 = engine.allocate_memory(in2_actual_layout);
-
-    std::vector<float> input1_data1 = {
-        1.f, -2.f, 3.f, -4.f,
-        5.f, 6.f, 1.f, 2.f,
-        3.f, 3.f, 2.f, -1.f,
-    };
-    std::vector<float> input1_data2 = {
-        -1.f, 2.f, -3.f, 4.f,
-        5.f, 6.f, -1.f, 2.f,
-        3.f, -3.f, 2.f, 1.f,
-    };
-    std::vector<float> input2_data1 = {
-        2.f, 5.f, -4.f, -7.f,
-    };
-    std::vector<float> input2_data2 = {
-        4.f, 7.f, 2.f, 5.f,
-    };
-    set_values(input1_1, input1_data1);
-    set_values(input1_2, input1_data2);
-    set_values(input2_1, input2_data1);
-    set_values(input2_2, input2_data2);
-
-    std::vector<float> out_data1 = {
-        8.f, 22.f, 20.f
-    };
-    std::vector<float> out_data2 = {
-        24.f, 70.f, 0.f
-    };
-
-    topology topology;
-    topology.add(input_layout("input1", in1_dyn_layout),
-                 input_layout("input2", in2_dyn_layout),
-                 gemm("gemm", { input_info("input1"), input_info("input2") }, data_types::f32, false, false, 1.0f, 0.0f, 4, 2)
-    );
-
-    ExecutionConfig config = get_test_default_config(engine);
-    config.set_property(ov::intel_gpu::optimize_data(true));
-    config.set_property(ov::intel_gpu::allow_new_shape_infer(true));
-    network network(engine, topology, config);
-
-    {
-        network.set_input_data("input1", input1_1);
-        network.set_input_data("input2", input2_1);
-
-        auto outputs = network.execute();
-        ASSERT_EQ(outputs.size(), size_t(1));
-        ASSERT_EQ(outputs.begin()->first, "gemm");
-
-        auto prog = network.get_program();
-        auto& node = prog->get_node("gemm");
-        auto impl = node.get_selected_impl();
+        auto inst = network->get_primitive("gemm");
+        auto impl = inst->get_impl();
         ASSERT_TRUE(impl != nullptr);
         ASSERT_TRUE(impl->is_dynamic());
 
-        auto output_prim_mem = outputs.begin()->second.get_memory();
-        cldnn::mem_lock<float> output_ptr(output_prim_mem, get_test_stream());
+        auto outputs = network->execute();
+
+        auto output = outputs.at("gemm").get_memory();
+        cldnn::mem_lock<float> output_ptr(output, get_test_stream());
 
         ASSERT_EQ(output_ptr.size(), (uint32_t)3);
-        for (uint32_t i = 0; i < out_data1.size(); ++i) {
-            ASSERT_FLOAT_EQ(output_ptr[i], out_data1[i]);
+        for (uint32_t i = 0; i < out_data.size(); ++i) {
+            ASSERT_FLOAT_EQ(output_ptr[i], out_data[i]);
         }
     }
 
-    {
-        network.set_input_data("input1", input1_2);
-        network.set_input_data("input2", input2_2);
+    void test_dynamic_multi_inference_same_shape(bool is_caching_test) {
+        auto& engine = get_test_engine();
 
-        auto outputs = network.execute();
-        ASSERT_EQ(outputs.size(), size_t(1));
-        ASSERT_EQ(outputs.begin()->first, "gemm");
+        auto in1_dyn_layout = layout{ ov::PartialShape{ 1, 1, ov::Dimension(1, 10), 4 }, data_types::f32, format::bfyx };
+        auto in1_actual_layout = layout{ ov::PartialShape{ 1, 1, 3, 4 }, data_types::f32, format::bfyx };
+        auto in2_dyn_layout = layout{ ov::PartialShape{ 4, ov::Dimension(1, 10) }, data_types::f32, format::bfyx };
+        auto in2_actual_layout = layout{ ov::PartialShape{ 4, 1 }, data_types::f32, format::bfyx };
+        auto input1_1 = engine.allocate_memory(in1_actual_layout);
+        auto input1_2 = engine.allocate_memory(in1_actual_layout);
+        auto input2_1 = engine.allocate_memory(in2_actual_layout);
+        auto input2_2 = engine.allocate_memory(in2_actual_layout);
 
-        auto output_prim_mem = outputs.begin()->second.get_memory();
-        cldnn::mem_lock<float> output_ptr(output_prim_mem, get_test_stream());
+        std::vector<float> input1_data1 = {
+            1.f, -2.f, 3.f, -4.f,
+            5.f, 6.f, 1.f, 2.f,
+            3.f, 3.f, 2.f, -1.f,
+        };
+        std::vector<float> input1_data2 = {
+            -1.f, 2.f, -3.f, 4.f,
+            5.f, 6.f, -1.f, 2.f,
+            3.f, -3.f, 2.f, 1.f,
+        };
+        std::vector<float> input2_data1 = {
+            2.f, 5.f, -4.f, -7.f,
+        };
+        std::vector<float> input2_data2 = {
+            4.f, 7.f, 2.f, 5.f,
+        };
+        set_values(input1_1, input1_data1);
+        set_values(input1_2, input1_data2);
+        set_values(input2_1, input2_data1);
+        set_values(input2_2, input2_data2);
 
-        ASSERT_EQ(output_ptr.size(), (uint32_t)3);
-        for (uint32_t i = 0; i < out_data2.size(); ++i) {
-            ASSERT_FLOAT_EQ(output_ptr[i], out_data2[i]);
+        std::vector<float> out_data1 = {
+            8.f, 22.f, 20.f
+        };
+        std::vector<float> out_data2 = {
+            24.f, 70.f, 0.f
+        };
+
+        topology topology;
+        topology.add(input_layout("input1", in1_dyn_layout),
+                    input_layout("input2", in2_dyn_layout),
+                    gemm("gemm", { input_info("input1"), input_info("input2") }, data_types::f32, false, false, 1.0f, 0.0f, 4, 2)
+        );
+
+        ExecutionConfig config = get_test_default_config(engine);
+        config.set_property(ov::intel_gpu::optimize_data(true));
+        config.set_property(ov::intel_gpu::allow_new_shape_infer(true));
+        network::ptr network = get_network(engine, topology, config, get_test_stream_ptr(), is_caching_test);
+
+        {
+            network->set_input_data("input1", input1_1);
+            network->set_input_data("input2", input2_1);
+
+            auto outputs = network->execute();
+            ASSERT_EQ(outputs.size(), size_t(1));
+            ASSERT_EQ(outputs.begin()->first, "gemm");
+
+            auto prog = network->get_program();
+            auto& node = prog->get_node("gemm");
+            auto impl = node.get_selected_impl();
+            ASSERT_TRUE(impl != nullptr);
+            ASSERT_TRUE(impl->is_dynamic());
+
+            auto output_prim_mem = outputs.begin()->second.get_memory();
+            cldnn::mem_lock<float> output_ptr(output_prim_mem, get_test_stream());
+
+            ASSERT_EQ(output_ptr.size(), (uint32_t)3);
+            for (uint32_t i = 0; i < out_data1.size(); ++i) {
+                ASSERT_FLOAT_EQ(output_ptr[i], out_data1[i]);
+            }
+        }
+
+        {
+            network->set_input_data("input1", input1_2);
+            network->set_input_data("input2", input2_2);
+
+            auto outputs = network->execute();
+            ASSERT_EQ(outputs.size(), size_t(1));
+            ASSERT_EQ(outputs.begin()->first, "gemm");
+
+            auto output_prim_mem = outputs.begin()->second.get_memory();
+            cldnn::mem_lock<float> output_ptr(output_prim_mem, get_test_stream());
+
+            ASSERT_EQ(output_ptr.size(), (uint32_t)3);
+            for (uint32_t i = 0; i < out_data2.size(); ++i) {
+                ASSERT_FLOAT_EQ(output_ptr[i], out_data2[i]);
+            }
         }
     }
+
+    void test_dynamic_multi_inference_different_shape(bool is_caching_test) {
+        auto& engine = get_test_engine();
+
+        auto in1_dyn_layout = layout{ ov::PartialShape{ 1, 1, ov::Dimension(1, 10), 4 }, data_types::f32, format::bfyx };
+        auto in1_actual_layout1 = layout{ ov::PartialShape{ 1, 1, 3, 4 }, data_types::f32, format::bfyx };
+        auto in1_actual_layout2 = layout{ ov::PartialShape{ 1, 1, 4, 4 }, data_types::f32, format::bfyx };
+        auto in2_dyn_layout = layout{ ov::PartialShape{ 4, ov::Dimension(1, 10) }, data_types::f32, format::bfyx };
+        auto in2_actual_layout = layout{ ov::PartialShape{ 4, 1 }, data_types::f32, format::bfyx };
+        auto input1_1 = engine.allocate_memory(in1_actual_layout1);
+        auto input1_2 = engine.allocate_memory(in1_actual_layout2);
+        auto input2 = engine.allocate_memory(in2_actual_layout);
+
+        std::vector<float> input1_data1 = {
+            1.f, -2.f, 3.f, -4.f,
+            5.f, 6.f, 1.f, 2.f,
+            3.f, 3.f, 2.f, -1.f,
+        };
+        std::vector<float> input1_data2 = {
+            -1.f, 2.f, -3.f, 4.f,
+            5.f, 6.f, -1.f, 2.f,
+            3.f, -3.f, 2.f, 1.f,
+            1.f, 2.f, -5.f, 6.f,
+        };
+        std::vector<float> input2_data = {
+            2.f, 5.f, -4.f, -7.f,
+        };
+        set_values(input1_1, input1_data1);
+        set_values(input1_2, input1_data2);
+        set_values(input2, input2_data);
+
+        std::vector<float> out_data1 = {
+            8.f, 22.f, 20.f
+        };
+        std::vector<float> out_data2 = {
+            -8.f, 30.f, -24.f, -10.f
+        };
+
+        topology topology;
+        topology.add(input_layout("input1", in1_dyn_layout),
+                    input_layout("input2", in2_dyn_layout),
+                    gemm("gemm", { input_info("input1"), input_info("input2") }, data_types::f32, false, false, 1.0f, 0.0f, 4, 2)
+        );
+
+        ExecutionConfig config = get_test_default_config(engine);
+        config.set_property(ov::intel_gpu::optimize_data(true));
+        config.set_property(ov::intel_gpu::allow_new_shape_infer(true));
+        network::ptr network = get_network(engine, topology, config, get_test_stream_ptr(), is_caching_test);
+
+        {
+            network->set_input_data("input1", input1_1);
+            network->set_input_data("input2", input2);
+
+            auto outputs = network->execute();
+            ASSERT_EQ(outputs.size(), size_t(1));
+            ASSERT_EQ(outputs.begin()->first, "gemm");
+
+            auto prog = network->get_program();
+            auto& node = prog->get_node("gemm");
+            auto impl = node.get_selected_impl();
+            ASSERT_TRUE(impl != nullptr);
+            ASSERT_TRUE(impl->is_dynamic());
+
+            auto output_prim_mem = outputs.begin()->second.get_memory();
+            cldnn::mem_lock<float> output_ptr(output_prim_mem, get_test_stream());
+
+            ASSERT_EQ(output_ptr.size(), (uint32_t)3);
+            for (uint32_t i = 0; i < out_data1.size(); ++i) {
+                ASSERT_FLOAT_EQ(output_ptr[i], out_data1[i]);
+            }
+        }
+
+        {
+            network->set_input_data("input1", input1_2);
+            network->set_input_data("input2", input2);
+
+            auto outputs = network->execute();
+            ASSERT_EQ(outputs.size(), size_t(1));
+            ASSERT_EQ(outputs.begin()->first, "gemm");
+
+            auto output_prim_mem = outputs.begin()->second.get_memory();
+            cldnn::mem_lock<float> output_ptr(output_prim_mem, get_test_stream());
+
+            ASSERT_EQ(output_ptr.size(), (uint32_t)4);
+            for (uint32_t i = 0; i < out_data2.size(); ++i) {
+                ASSERT_FLOAT_EQ(output_ptr[i], out_data2[i]);
+            }
+        }
+    }
+};
+
+TEST_F(gemm_gpu_tests, basic_bfyx_t2_inplace_crop_with_pad) {
+    this->test_basic_bfyx_t2_inplace_crop_with_pad(false);
 }
 
-TEST(gemm_gpu, dynamic_multi_inference_different_shape) {
-    auto& engine = get_test_engine();
+TEST_F(gemm_gpu_tests, dynamic) {
+    this->test_dynamic(false);
+}
 
-    auto in1_dyn_layout = layout{ ov::PartialShape{ 1, 1, ov::Dimension(1, 10), 4 }, data_types::f32, format::bfyx };
-    auto in1_actual_layout1 = layout{ ov::PartialShape{ 1, 1, 3, 4 }, data_types::f32, format::bfyx };
-    auto in1_actual_layout2 = layout{ ov::PartialShape{ 1, 1, 4, 4 }, data_types::f32, format::bfyx };
-    auto in2_dyn_layout = layout{ ov::PartialShape{ 4, ov::Dimension(1, 10) }, data_types::f32, format::bfyx };
-    auto in2_actual_layout = layout{ ov::PartialShape{ 4, 1 }, data_types::f32, format::bfyx };
-    auto input1_1 = engine.allocate_memory(in1_actual_layout1);
-    auto input1_2 = engine.allocate_memory(in1_actual_layout2);
-    auto input2 = engine.allocate_memory(in2_actual_layout);
+TEST_F(gemm_gpu_tests, dynamic_multi_inference_same_shape) {
+    this->test_dynamic_multi_inference_same_shape(false);
+}
 
-    std::vector<float> input1_data1 = {
-        1.f, -2.f, 3.f, -4.f,
-        5.f, 6.f, 1.f, 2.f,
-        3.f, 3.f, 2.f, -1.f,
-    };
-    std::vector<float> input1_data2 = {
-        -1.f, 2.f, -3.f, 4.f,
-        5.f, 6.f, -1.f, 2.f,
-        3.f, -3.f, 2.f, 1.f,
-        1.f, 2.f, -5.f, 6.f,
-    };
-    std::vector<float> input2_data = {
-        2.f, 5.f, -4.f, -7.f,
-    };
-    set_values(input1_1, input1_data1);
-    set_values(input1_2, input1_data2);
-    set_values(input2, input2_data);
-
-    std::vector<float> out_data1 = {
-        8.f, 22.f, 20.f
-    };
-    std::vector<float> out_data2 = {
-        -8.f, 30.f, -24.f, -10.f
-    };
-
-    topology topology;
-    topology.add(input_layout("input1", in1_dyn_layout),
-                 input_layout("input2", in2_dyn_layout),
-                 gemm("gemm", { input_info("input1"), input_info("input2") }, data_types::f32, false, false, 1.0f, 0.0f, 4, 2)
-    );
-
-    ExecutionConfig config = get_test_default_config(engine);
-    config.set_property(ov::intel_gpu::optimize_data(true));
-    config.set_property(ov::intel_gpu::allow_new_shape_infer(true));
-    network network(engine, topology, config);
-
-    {
-        network.set_input_data("input1", input1_1);
-        network.set_input_data("input2", input2);
-
-        auto outputs = network.execute();
-        ASSERT_EQ(outputs.size(), size_t(1));
-        ASSERT_EQ(outputs.begin()->first, "gemm");
-
-        auto prog = network.get_program();
-        auto& node = prog->get_node("gemm");
-        auto impl = node.get_selected_impl();
-        ASSERT_TRUE(impl != nullptr);
-        ASSERT_TRUE(impl->is_dynamic());
-
-        auto output_prim_mem = outputs.begin()->second.get_memory();
-        cldnn::mem_lock<float> output_ptr(output_prim_mem, get_test_stream());
-
-        ASSERT_EQ(output_ptr.size(), (uint32_t)3);
-        for (uint32_t i = 0; i < out_data1.size(); ++i) {
-            ASSERT_FLOAT_EQ(output_ptr[i], out_data1[i]);
-        }
-    }
-
-    {
-        network.set_input_data("input1", input1_2);
-        network.set_input_data("input2", input2);
-
-        auto outputs = network.execute();
-        ASSERT_EQ(outputs.size(), size_t(1));
-        ASSERT_EQ(outputs.begin()->first, "gemm");
-
-        auto output_prim_mem = outputs.begin()->second.get_memory();
-        cldnn::mem_lock<float> output_ptr(output_prim_mem, get_test_stream());
-
-        ASSERT_EQ(output_ptr.size(), (uint32_t)4);
-        for (uint32_t i = 0; i < out_data2.size(); ++i) {
-            ASSERT_FLOAT_EQ(output_ptr[i], out_data2[i]);
-        }
-    }
+TEST_F(gemm_gpu_tests, dynamic_multi_inference_different_shape) {
+    this->test_dynamic_multi_inference_different_shape(false);
 }
 
 INSTANTIATE_TEST_SUITE_P(
@@ -1947,8 +1962,20 @@ TEST_P(gemm_fp16_tiled_tn_tests, basic_cached) { auto p = GetParam(); execute(p,
 TEST_P(gemm_fp16_tiled_tt_tests, basic_cached) { auto p = GetParam(); execute(p, true); }
 TEST_P(gemm_fp16_tiled_nn_broadcast_tests, basic_cached) { auto p = GetParam(); execute(p); }
 
+TEST_F(gemm_gpu_tests, dynamic_cached) {
+    this->test_dynamic(true);
+}
+
+TEST_F(gemm_gpu_tests, dynamic_multi_inference_same_shape_cached) {
+    this->test_dynamic_multi_inference_same_shape(true);
+}
+
+TEST_F(gemm_gpu_tests, dynamic_multi_inference_different_shape_cached) {
+    this->test_dynamic_multi_inference_different_shape(true);
+}
 #endif // RUN_ALL_MODEL_CACHING_TESTS
-TEST(gemm_gpu, basic_bfyx_t2_inplace_crop_with_pad_cached) {
-    test_basic_bfyx_t2_inplace_crop_with_pad<float>(true);
+
+TEST_F(gemm_gpu_tests, basic_bfyx_t2_inplace_crop_with_pad_cached) {
+    this->test_basic_bfyx_t2_inplace_crop_with_pad(true);
 }
 } // namespace
diff --git a/src/plugins/intel_gpu/tests/unit/test_cases/loop_gpu_test.cpp b/src/plugins/intel_gpu/tests/unit/test_cases/loop_gpu_test.cpp
index cd1303cbbfc..bf62658b327 100644
--- a/src/plugins/intel_gpu/tests/unit/test_cases/loop_gpu_test.cpp
+++ b/src/plugins/intel_gpu/tests/unit/test_cases/loop_gpu_test.cpp
@@ -553,3 +553,11 @@ TEST(loop_gpu, support_dynamic_tensoriterator) {
 TEST(loop_gpu, support_loop_w_dynamic_body_input) {
     test_loop_gpu_wo_trip_count({ 1, -1, 1, 4 });
 }
+
+TEST(loop_gpu, support_dynamic_tensoriterator_cached) {
+    test_loop_gpu_wo_trip_count({ 1, 1, 1, 4 }, true);
+}
+
+TEST(loop_gpu, support_loop_w_dynamic_body_input_cached) {
+    test_loop_gpu_wo_trip_count({ 1, -1, 1, 4 }, true);
+}
diff --git a/src/plugins/intel_gpu/tests/unit/test_cases/proposal_cpu_test.cpp b/src/plugins/intel_gpu/tests/unit/test_cases/proposal_cpu_test.cpp
index 8b6d4cdecfb..9dbcb7a8db4 100644
--- a/src/plugins/intel_gpu/tests/unit/test_cases/proposal_cpu_test.cpp
+++ b/src/plugins/intel_gpu/tests/unit/test_cases/proposal_cpu_test.cpp
@@ -93,15 +93,17 @@ TestRunnerProposal<Dtype, ImInfoType>::TestRunnerProposal(cldnn::tensor image_in
     if (is_caching_test) {
         membuf mem_buf;
         {
-            cldnn::network _network(get_test_engine(), _topology);
             std::ostream out_mem(&mem_buf);
             BinaryOutputBuffer ob = BinaryOutputBuffer(out_mem);
-            _network.save(ob);
+            ob.set_stream(get_test_stream_ptr().get());
+            program::build_program(get_test_engine(), _topology, {})->save(ob);
         }
         {
             std::istream in_mem(&mem_buf);
             BinaryInputBuffer ib = BinaryInputBuffer(in_mem, get_test_engine());
-            _network.reset(new network(ib, get_test_stream_ptr(), get_test_engine(), true, 0));
+            auto imported_prog = std::make_shared<cldnn::program>(get_test_engine());
+            imported_prog->load(ib);
+            _network.reset(new network(imported_prog));
         }
     } else {
         _network.reset(new network(get_test_engine(), _topology));
diff --git a/src/plugins/intel_gpu/tests/unit/test_cases/streams_test.cpp b/src/plugins/intel_gpu/tests/unit/test_cases/streams_test.cpp
index 3bc4e705f81..8da3b50fcf3 100644
--- a/src/plugins/intel_gpu/tests/unit/test_cases/streams_test.cpp
+++ b/src/plugins/intel_gpu/tests/unit/test_cases/streams_test.cpp
@@ -80,23 +80,18 @@ public:
         if (is_caching_test) {
             membuf mem_buf;
             {
-                auto prog = program::build_program(engine, topology, get_test_default_config(engine));
-                {
-                    network0 = std::make_shared<cldnn::network>(prog, 0);
-                    std::ostream out_mem(&mem_buf);
-                    BinaryOutputBuffer ob = BinaryOutputBuffer(out_mem);
-                    network0->save(ob);
-                }
+                std::ostream out_mem(&mem_buf);
+                BinaryOutputBuffer ob = BinaryOutputBuffer(out_mem);
+                ob.set_stream(get_test_stream_ptr().get());
+                program::build_program(engine, topology, get_test_default_config(engine))->save(ob);
             }
             {
-                {
-                    std::istream in_mem(&mem_buf);
-                    BinaryInputBuffer ib = BinaryInputBuffer(in_mem, engine);
-                    auto pos = ib.tellg();
-                    network0 = std::make_shared<cldnn::network>(ib, get_test_stream_ptr(), engine, true, 0);
-                    ib.seekg(pos);
-                    network1 = std::make_shared<cldnn::network>(ib, get_test_stream_ptr(), engine, false, 0);
-                }
+                std::istream in_mem(&mem_buf);
+                BinaryInputBuffer ib = BinaryInputBuffer(in_mem, engine);
+                auto imported_prog = std::make_shared<cldnn::program>(engine, get_test_default_config(engine));
+                imported_prog->load(ib);
+                network0 = std::make_shared<cldnn::network>(imported_prog, 0);
+                network1 = std::make_shared<cldnn::network>(imported_prog, 1);
             }
         } else {
             auto prog = program::build_program(engine, topology, get_test_default_config(engine));
@@ -171,34 +166,20 @@ public:
         cldnn::network::ptr network0;
         cldnn::network::ptr network1;
         if (is_caching_test) {
-            membuf mem_buf0;
-            membuf mem_buf1;
+            membuf mem_buf;
             {
-                auto prog = program::build_program(engine, topology, get_test_default_config(engine));
-                {
-                    network0 = std::make_shared<cldnn::network>(prog, 0);
-                    std::ostream out_mem0(&mem_buf0);
-                    BinaryOutputBuffer ob0 = BinaryOutputBuffer(out_mem0);
-                    network0->save(ob0);
-                }
-                {
-                    network1 = std::make_shared<cldnn::network>(prog, 1);
-                    std::ostream out_mem1(&mem_buf1);
-                    BinaryOutputBuffer ob1 = BinaryOutputBuffer(out_mem1);
-                    network1->save(ob1);
-                }
+                std::ostream out_mem(&mem_buf);
+                BinaryOutputBuffer ob = BinaryOutputBuffer(out_mem);
+                ob.set_stream(get_test_stream_ptr().get());
+                program::build_program(engine, topology, get_test_default_config(engine))->save(ob);
             }
             {
-                {
-                    std::istream in_mem0(&mem_buf0);
-                    BinaryInputBuffer ib0 = BinaryInputBuffer(in_mem0, engine);
-                    network0 = std::make_shared<cldnn::network>(ib0, get_test_stream_ptr(), engine, false, 0);
-                }
-                {
-                    std::istream in_mem1(&mem_buf1);
-                    BinaryInputBuffer ib1 = BinaryInputBuffer(in_mem1, engine);
-                    network1 = std::make_shared<cldnn::network>(ib1, get_test_stream_ptr(), engine, true, 0);
-                }
+                std::istream in_mem(&mem_buf);
+                BinaryInputBuffer ib = BinaryInputBuffer(in_mem, engine);
+                auto imported_prog = std::make_shared<cldnn::program>(engine, get_test_default_config(engine));
+                imported_prog->load(ib);
+                network0 = std::make_shared<cldnn::network>(imported_prog, 0);
+                network1 = std::make_shared<cldnn::network>(imported_prog, 1);
             }
         } else {
             auto prog = program::build_program(engine, topology, get_test_default_config(engine));
diff --git a/src/plugins/intel_gpu/tests/unit/test_utils/test_utils.h b/src/plugins/intel_gpu/tests/unit/test_utils/test_utils.h
index b63fc2f5fa8..e3a0c41fe88 100644
--- a/src/plugins/intel_gpu/tests/unit/test_utils/test_utils.h
+++ b/src/plugins/intel_gpu/tests/unit/test_utils/test_utils.h
@@ -588,15 +588,17 @@ inline cldnn::network::ptr get_network(cldnn::engine& engine,
     if (is_caching_test) {
         cldnn::membuf mem_buf;
         {
-            cldnn::network _network(engine, topology, config);
             std::ostream out_mem(&mem_buf);
             cldnn::BinaryOutputBuffer ob = cldnn::BinaryOutputBuffer(out_mem);
-            _network.save(ob);
+            ob.set_stream(stream.get());
+            cldnn::program::build_program(engine, topology, config, nullptr, false)->save(ob);
         }
         {
             std::istream in_mem(&mem_buf);
             cldnn::BinaryInputBuffer ib = cldnn::BinaryInputBuffer(in_mem, engine);
-            network = std::make_shared<cldnn::network>(ib, config, stream, engine, true, 0);
+            auto imported_prog = std::make_shared<cldnn::program>(engine, config);
+            imported_prog->load(ib);
+            network = std::make_shared<cldnn::network>(imported_prog);
         }
     } else {
         network = std::make_shared<cldnn::network>(engine, topology, config);