[GPU] Fixed invalid access to input layout in impl map (#12533)

src/plugins/intel_gpu/src/graph/bucketize.cpp

@@ -8,6 +8,7 @@
 #include "bucketize_inst.hpp"
 #include "json_object.h"
 #include "primitive_type_base.h"
+#include "to_string_utils.h"
 
 namespace cldnn {
 

src/plugins/intel_gpu/src/graph/impls/implementation_map.hpp

@@ -10,9 +10,7 @@
 #include <tuple>
 #include <string>
 #include <sstream>
-#include "to_string_utils.h"
 #include "kernel_selector_helper.h"
-#include "activation_inst.h"
 
 namespace cldnn {
 
@@ -50,10 +48,6 @@ struct typed_program_node;
 template <typename primitive_kind>
 struct implementation_key {
     typedef std::tuple<data_types, format::type> type;
-    type operator()(const typed_program_node<primitive_kind>& primitive) {
-        return std::make_tuple(primitive.get_dependency(0).get_output_layout().data_type,
-                               primitive.get_dependency(0).get_output_layout().format);
-    }
     type operator()(const layout& proposed_layout) {
         return std::make_tuple(proposed_layout.data_type, proposed_layout.format);
     }
@@ -62,77 +56,66 @@ struct implementation_key {
 template <>
 struct implementation_key<permute> {
     typedef int32_t type;
-    type operator()(const typed_program_node<permute>&) { return -1; }
     type operator()(const layout&) { return -1; }
 };
 
 template <>
 struct implementation_key<shape_of> {
     typedef int32_t type;
-    type operator()(const typed_program_node<shape_of>&) { return -1; }
     type operator()(const layout&) { return -1; }
 };
 
 template <>
 struct implementation_key<reorder> {
     typedef int32_t type;
-    type operator()(const typed_program_node<reorder>&) { return -1; }
     type operator()(const layout&) { return -1; }
 };
 
 template <>
 struct implementation_key<generic_layer> {
     typedef int32_t type;
-    type operator()(const typed_program_node<generic_layer>&) { return -1; }
     type operator()(const layout&) { return -1; }
 };
 
 template <>
 struct implementation_key<custom_gpu_primitive> {
     typedef int32_t type;
-    type operator()(const typed_program_node<custom_gpu_primitive>&) { return -1; }
     type operator()(const layout&) { return -1; }
 };
 
 template <>
 struct implementation_key<reshape> {
     typedef int32_t type;
-    type operator()(const typed_program_node<reshape>&) { return -1; }
     type operator()(const layout&) { return -1; }
 };
 
 template <>
 struct implementation_key<data> {
     typedef int32_t type;
-    type operator()(const typed_program_node<data>&) { return -1; }
     type operator()(const layout&) { return -1; }
 };
 
 template <>
 struct implementation_key<mutable_data> {
     typedef int32_t type;
-    type operator()(const typed_program_node<mutable_data>&) { return -1; }
     type operator()(const layout&) { return -1; }
 };
 
 template <>
 struct implementation_key<input_layout> {
     typedef int32_t type;
-    type operator()(const typed_program_node<input_layout>&) { return -1; }
     type operator()(const layout&) { return -1; }
 };
 
 template <>
 struct implementation_key<prior_box> {
     typedef int32_t type;
-    type operator()(const typed_program_node<prior_box>&) { return -1; }
     type operator()(const layout&) { return -1; }
 };
 
 template <>
 struct implementation_key<loop> {
     typedef int32_t type;
-    type operator()(const typed_program_node<loop>&) { return -1; }
     type operator()(const layout&) { return -1; }
 };
 
@@ -151,7 +134,8 @@ public:
     using map_type = singleton_map<impl_types, std::pair<std::set<key_type>, factory_type>>;
 
     static factory_type get(const kernel_impl_params& impl_params, impl_types preferred_impl_type) {
-        auto key = key_builder()(impl_params.input_layouts[0]);
+        auto input_layout = !impl_params.input_layouts.empty() ? impl_params.input_layouts[0] : layout{ov::PartialShape{}, data_types::f32, format::any};
+        auto key = key_builder()(input_layout);
         for (auto& kv : map_type::instance()) {
             impl_types impl_type = kv.first;
             if ((preferred_impl_type & impl_type) != impl_type)
@@ -162,23 +146,20 @@ public:
                 return factory;
             }
         }
-        std::stringstream target_impl_type_ss;
+        OPENVINO_ASSERT(false, "[GPU] implementation_map for ", typeid(primitive_kind).name(),
-        target_impl_type_ss << preferred_impl_type;
+                               " could not find any implementation to match key: ", get_key_name(key),
-        throw std::runtime_error(std::string("implementation_map for ") + typeid(primitive_kind).name() +
+                               ", impl_type: ", preferred_impl_type, ", node_id: ",  impl_params.desc->id);
-                                    " could not find any implementation to match key: " +
-                                    get_key_name(key) + ", impl_type: " + target_impl_type_ss.str() + ", node_id: " + impl_params.desc->id);
     }
 
     // check if for a given engine and type there exist an implementation
-    static bool check(const typed_program_node<primitive_kind>& primitive, const kernel_impl_params& impl_params) {
+    static bool check(const kernel_impl_params& impl_params, impl_types target_impl_type) {
-        impl_types target_impl_type = primitive.get_preferred_impl_type();
+        auto input_layout = !impl_params.input_layouts.empty() ? impl_params.input_layouts[0] : layout{ov::PartialShape{}, data_types::f32, format::any};
-        auto key = key_builder()(impl_params.input_layouts[0]);
+        auto key = key_builder()(input_layout);
         return check_key(target_impl_type, key);
     }
 
     // check if there exists a kernel implementation of a primitive with output set it primitive's output layout
-    static bool check_io_eq(const typed_program_node<primitive_kind>& primitive, const kernel_impl_params& impl_params) {
+    static bool check_io_eq(const kernel_impl_params& impl_params, impl_types target_impl_type) {
-        impl_types target_impl_type = primitive.get_preferred_impl_type();
         auto key = key_builder()(impl_params.output_layout);
         return check_key(target_impl_type, key);
     }
@@ -202,9 +183,7 @@ public:
     }
 
     static void add(impl_types impl_type, factory_type factory, std::set<key_type> keys) {
-        if (impl_type == impl_types::any) {
+        OPENVINO_ASSERT(impl_type != impl_types::any, "[GPU] Can't register impl with type any");
-            throw std::runtime_error("[CLDNN] Can't register impl with type any");
-        }
         map_type::instance().insert({impl_type, {keys, factory}});
     }
 

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

@@ -22,17 +22,12 @@ template <class PType>
 struct primitive_type_base : primitive_type {
     std::shared_ptr<cldnn::program_node> create_node(program& program,
                                                      const std::shared_ptr<primitive> prim) const override {
-        if (prim->type != this)
+        OPENVINO_ASSERT(prim->type == this, "[GPU] primitive_type_base::create_node: primitive type mismatch");
-            throw std::invalid_argument("primitive_type_base::create_node: primitive type mismatch");
-
         return std::make_shared<typed_program_node<PType>>(std::static_pointer_cast<PType>(prim), program);
     }
 
-    std::shared_ptr<cldnn::primitive_inst> create_instance(network& network,
+    std::shared_ptr<cldnn::primitive_inst> create_instance(network& network, const cldnn::program_node& node) const override {
-                                                           const cldnn::program_node& node) const override {
+        OPENVINO_ASSERT(node.type() == this, "[GPU] primitive_type_base::create_instance: primitive type mismatch");
-        if (node.type() != this)
-            throw std::invalid_argument("primitive_type_base::create_instance: primitive type mismatch");
-
         return std::make_shared<typed_primitive_inst<PType>>(network, node);
     }
 
@@ -42,11 +37,9 @@ struct primitive_type_base : primitive_type {
     }
 
     std::unique_ptr<primitive_impl> choose_impl(const cldnn::program_node& node, const kernel_impl_params& runtime_params) const override {
-        if (node.type() != this)
+        OPENVINO_ASSERT(node.type() == this, "[GPU] primitive_type_base::choose_impl: primitive type mismatch");
-            throw std::invalid_argument("primitive_type_base::choose_impl: primitive type mismatch");
         auto factory = implementation_map<PType>::get(runtime_params, node.get_preferred_impl_type());
-        auto impl = std::unique_ptr<primitive_impl>(factory(node, runtime_params));
+        return std::unique_ptr<primitive_impl>(factory(node, runtime_params));
-        return impl;
     }
 
     bool does_an_implementation_exist(const cldnn::program_node& node) const override {
@@ -54,10 +47,8 @@ struct primitive_type_base : primitive_type {
     }
 
     bool does_an_implementation_exist(const cldnn::program_node& node, const kernel_impl_params& impl_param) const override {
-        if (node.type() != this)
+        OPENVINO_ASSERT(node.type() == this, "[GPU] primitive_type_base::does_an_implementation_exist: primitive type mismatch");
-            throw std::invalid_argument("primitive_type_base::does_an_implementation_exist: primitive type mismatch");
+        return implementation_map<PType>::check(impl_param, node.get_preferred_impl_type());
-
-        return implementation_map<PType>::check(node, impl_param);
     }
 
     bool does_possible_implementation_exist(const cldnn::program_node& node) const override {
@@ -65,22 +56,17 @@ struct primitive_type_base : primitive_type {
     }
 
     bool does_possible_implementation_exist(const cldnn::program_node& node, const kernel_impl_params& impl_param) const override {
-        if (node.type() != this)
+        OPENVINO_ASSERT(node.type() == this, "[GPU] primitive_type_base::does_possible_implementation_exist: primitive type mismatch");
-            throw std::invalid_argument("primitive_type_base::does_possible_implementation_exist: primitive type mismatch");
+        return implementation_map<PType>::check_io_eq(impl_param, node.get_preferred_impl_type());
-        return implementation_map<PType>::check_io_eq(node, impl_param);
     }
 
     cldnn::layout calc_output_layout(const cldnn::program_node& node, const kernel_impl_params& impl_param) const override {
-        if (node.type() != this)
+        OPENVINO_ASSERT(node.type() == this, "[GPU] primitive_type_base::calc_output_layout: primitive type mismatch");
-            throw std::invalid_argument("primitive_type_base::calc_output_layout: primitive type mismatch");
-
         return typed_primitive_inst<PType>::calc_output_layout(node, impl_param);
     }
 
     std::string to_string(const cldnn::program_node& node) const override {
-        if (node.type() != this)
+        OPENVINO_ASSERT(node.type() == this, "[GPU] primitive_type_base::to_string: primitive type mismatch");
-            throw std::invalid_argument("primitive_type_base::to_string: primitive type mismatch");
-
         return typed_primitive_inst<PType>::to_string(node);
     }
 };

src/plugins/intel_gpu/src/graph/shape_of.cpp

@@ -6,6 +6,7 @@
 #include "primitive_type_base.h"
 #include "intel_gpu/runtime/error_handler.hpp"
 #include "json_object.h"
+#include "to_string_utils.h"
 #include <string>
 #include <vector>