review fixes

src/plugins/intel_gpu/src/graph/graph_optimizer/compile_graph.cpp

@@ -40,7 +40,7 @@ void compile_graph::run(program& p) {
                 try {
                     const auto& params = node->get_kernel_impl_params();
                     auto shape_type = ImplementationManager::get_shape_type(*params);
-                    auto selected_impl_manager = node->type()->choose_impl(*node, *node->get_kernel_impl_params(), shape_type);
+                    auto selected_impl_manager = node->type()->choose_impl(*node, shape_type);
                     std::string fail_reason = "";
                     try {
                         if (selected_impl_manager) {

src/plugins/intel_gpu/src/graph/graph_optimizer/select_preferred_formats.cpp

@@ -100,7 +100,7 @@ void select_preferred_formats::run(program& p) {
         auto factory = test_format<std::shared_ptr<ImplementationManager>>(*n, format::any,
             [&shape_type](program_node& n) {
                 return test_no_input_pad<std::shared_ptr<ImplementationManager>>(n, [&shape_type](program_node& n) {
-                    return n.type()->choose_impl(n, *n.get_kernel_impl_params(), shape_type);
+                    return n.type()->choose_impl(n, shape_type);
             });
         });
 

src/plugins/intel_gpu/src/graph/include/primitive_type.h

@@ -30,9 +30,7 @@ struct primitive_type {
                                                             const program_node& node) const = 0;
 
     virtual std::unique_ptr<primitive_impl> create_impl(const program_node& node) const = 0;
-    virtual std::shared_ptr<ImplementationManager> choose_impl(const program_node& node,
-                                                               const kernel_impl_params& params,
-                                                               shape_types shape_type) const = 0;
+    virtual std::shared_ptr<ImplementationManager> choose_impl(const program_node& node, shape_types shape_type) const = 0;
 
     virtual std::set<impl_types> get_available_impl_types(const program_node& node) const = 0;
     virtual std::vector<std::shared_ptr<ImplementationManager>> get_supported_implementations(const program_node& node) const = 0;

src/plugins/intel_gpu/src/graph/include/primitive_type_base.h

@@ -44,9 +44,7 @@ struct primitive_type_base : primitive_type {
         return {};
     }
 
-    std::shared_ptr<ImplementationManager> choose_impl(const program_node& node,
-                                                       const kernel_impl_params& runtime_params,
-                                                       shape_types requested_shape_type) const override {
+    std::shared_ptr<ImplementationManager> choose_impl(const program_node& node, shape_types requested_shape_type) const override {
         OPENVINO_ASSERT(node.type() == this, "[GPU] primitive_type_base::choose_impl: primitive type mismatch");
         for (auto& impl : get_supported_implementations(node)) {
             impl_types impl_type = impl->get_impl_type();
@@ -68,7 +66,7 @@ struct primitive_type_base : primitive_type {
     std::unique_ptr<primitive_impl> create_impl(const program_node& node) const override {
         OPENVINO_ASSERT(node.type() == this, "[GPU] primitive_type_base::create_impl: primitive type mismatch");
         const auto params = node.get_kernel_impl_params();
-        auto impl = choose_impl(node, *params, ImplementationManager::get_shape_type(*params));
+        auto impl = choose_impl(node, ImplementationManager::get_shape_type(*params));
 
         const auto& p = node.get_primitive();
         OPENVINO_ASSERT(impl != nullptr, "[GPU] Can't choose implementation for ", node.id(), " node (type=", p->type_string(), ")\n",

src/plugins/intel_gpu/src/graph/include/program_node.h

@@ -602,11 +602,12 @@ inline RT test_format(program_node& node, format fmt, std::function<RT(program_n
         node.recalc_output_layouts(false);
 
     bool has_deps = !node.get_dependencies().empty();
-    layout prev_input_layout = has_deps ? node.get_input_layout(0) : layout();
+    layout prev_input_layout = layout();
     if (has_deps) {
+        auto dep_with_port = node.get_dependency_with_port(0);
+        prev_input_layout = dep_with_port.first->get_output_layout(false, dep_with_port.second);
         auto new_layout = prev_input_layout;
         set_format_no_any(new_layout, fmt);
-        auto dep_with_port = node.get_dependency_with_port(0);
         dep_with_port.first->set_output_layout(new_layout, false, dep_with_port.second);
     }
 

src/plugins/intel_gpu/src/graph/layout_optimizer.cpp

@@ -1199,13 +1199,12 @@ impl_types layout_optimizer::get_preferred_impl_type(program_node& node, format
     if (forced_impl != impl_types::any)
         return forced_impl;
 
-    const auto params = node.get_kernel_impl_params();
     auto shape_type = shape_types::any;
 
     auto impl = test_format<std::shared_ptr<ImplementationManager>>(node, preferred_format,
-        [&shape_type, &params](program_node& n) {
-            return test_no_input_pad<std::shared_ptr<ImplementationManager>>(n, [&shape_type, &params](program_node& n) {
-                return n.type()->choose_impl(n, *params, shape_type);
+        [&shape_type](program_node& n) {
+            return test_no_input_pad<std::shared_ptr<ImplementationManager>>(n, [&shape_type](program_node& n) {
+                return n.type()->choose_impl(n, shape_type);
         });
     });
 

src/plugins/intel_gpu/src/graph/primitive_inst.cpp

@@ -2510,7 +2510,7 @@ std::shared_ptr<primitive_impl> ImplementationsFactory::get_primitive_impl_for_p
                 auto kernels = _program.get_kernels_cache().compile(updated_params, impl->get_kernels_source());
                 impl->set_kernels(kernels);
             }
-            cache.add(updated_params, impl->clone());
+            cache.add(updated_params, std::move(impl));
         });
     }
 

src/plugins/intel_gpu/tests/unit/module_tests/kernel_impl_params_relevance_test.cpp

@@ -44,7 +44,7 @@ TEST(kernel_impl_params_relevance, weights_layout) {
     network.set_input_data("input", actual_input_data);
 
     // 2. Force reference `fully_connected_gpu_bfyx_ref` kernel impl before execution,
-    //    so during _node->type()->choose_impl(*_node, updated_params); call for static kernel version reference
+    //    so during _node->type()->choose_impl(*_node); call for static kernel version reference
     //    impl will be used. Call execute() to trigger desired kernel compilation
     auto fc_ref_impl = ov::intel_gpu::ImplementationDesc(format::bfyx, "fully_connected_gpu_bfyx_ref", impl_types::ocl);
     auto force_impl_prop = ov::intel_gpu::force_implementations(ov::intel_gpu::ImplForcingMap{ {"fc", fc_ref_impl} });