[GPU] Allow setting primitive's dependencies using index (#30436)

### Details:
- This patch is preliminary work for updating the unfusion logic. It
adds an additional method `primitive::get_dependency(size_t idx)`, which
returns a mutable reference to the input_info associated with the
specified dependency index, allowing to reconfigure it

Author: Sergey Shlyapnikov

src/plugins/intel_gpu/include/intel_gpu/primitives/activation.hpp

@@ -120,14 +120,14 @@ struct activation : public primitive_base<activation> {
     /// @brief PRelu activation slope input primitive id.
     /// Input x dimension should be equal to input feature size (one slope per channel).
     /// All other dimensions should be 1.
-    primitive_id additional_params_input;
+    input_info additional_params_input;
 
     size_t hash() const override {
         size_t seed = primitive::hash();
         seed = hash_combine(seed, activation_function);
         seed = hash_combine(seed, additional_params.a);
         seed = hash_combine(seed, additional_params.b);
-        seed = hash_combine(seed, additional_params_input.empty());
+        seed = hash_combine(seed, additional_params_input.is_valid());
         return seed;
     }
 
@@ -140,7 +140,7 @@ struct activation : public primitive_base<activation> {
         return activation_function == rhs_casted.activation_function &&
                additional_params.a == rhs_casted.additional_params.a &&
                additional_params.b == rhs_casted.additional_params.b &&
-               additional_params_input.empty() == rhs_casted.additional_params_input.empty();
+               additional_params_input.is_valid() == rhs_casted.additional_params_input.is_valid();
     }
 
     void save(BinaryOutputBuffer& ob) const override {
@@ -158,10 +158,14 @@ struct activation : public primitive_base<activation> {
     }
 
 protected:
-    std::vector<input_info> get_dependencies() const override {
-        if (additional_params_input.empty())
-            return {};
-        return {additional_params_input};
+    std::map<size_t, const input_info*> get_dependencies_map() const override {
+        auto ret = std::map<size_t, const input_info*>{};
+        auto idx = input.size();
+
+        if (additional_params_input.is_valid())
+            ret[idx++] = &additional_params_input;
+
+        return ret;
     }
 };
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/adaptive_pooling.hpp

@@ -79,14 +79,14 @@ struct adaptive_pooling : public primitive_base<adaptive_pooling> {
 
     adaptive_pooling_mode mode;
     tensor output_size;
-    primitive_id indices_output;
+    input_info indices_output;
     data_types index_element_type{data_types::i64};
 
     size_t hash() const override {
         size_t seed = primitive::hash();
         seed = hash_combine(seed, mode);
         seed = hash_combine(seed, index_element_type);
-        seed = hash_combine(seed, indices_output.empty());
+        seed = hash_combine(seed, indices_output.is_valid());
         return seed;
     }
 
@@ -118,10 +118,13 @@ struct adaptive_pooling : public primitive_base<adaptive_pooling> {
     }
 
 protected:
-    std::vector<input_info> get_dependencies() const override {
-        std::vector<input_info> ret;
-        if (!indices_output.empty())
-            ret.push_back(indices_output);
+    std::map<size_t, const input_info*> get_dependencies_map() const override {
+        auto ret = std::map<size_t, const input_info*>{};
+        auto idx = input.size();
+
+        if (indices_output.is_valid())
+            ret[idx++] = &indices_output;
+
         return ret;
     }
 };

src/plugins/intel_gpu/include/intel_gpu/primitives/condition.hpp

@@ -111,9 +111,6 @@ struct condition : public primitive_base<condition> {
         ib >> branch_true;
         ib >> branch_false;
     }
-
-protected:
-    std::vector<input_info> get_dependencies() const override { return {}; }
 };
 
 static inline std::ostream& operator<< (std::ostream& os, condition::branch& info) {

src/plugins/intel_gpu/include/intel_gpu/primitives/convolution.hpp

@@ -187,15 +187,15 @@ struct convolution : public primitive_base<convolution> {
     /// @param grouped_weights_shape Defines if weights tensor has explicit group dimension.
     bool grouped_weights_shape {false};
     /// @brief Primitive id containing weights data.
-    const primitive_id weights;
+    input_info weights;
     /// @brief Primitive id containing bias data.
-    const primitive_id bias;
+    input_info bias;
     /// @brief Primitive id containing weights zero points.
-    const primitive_id weights_zero_points;
+    input_info weights_zero_points;
     /// @brief Primitive id containing activations zero points.
-    const primitive_id activations_zero_points;
+    input_info activations_zero_points;
     /// @brief Primitive id containing compensation.
-    const primitive_id compensation;
+    input_info compensation;
 
     size_t hash() const override {
         size_t seed = primitive::hash();
@@ -210,11 +210,11 @@ struct convolution : public primitive_base<convolution> {
         seed = hash_combine(seed, bilinear_interpolation_pad);
         seed = hash_combine(seed, transposed);
         seed = hash_combine(seed, grouped_weights_shape);
-        seed = hash_combine(seed, !weights.empty());
-        seed = hash_combine(seed, !bias.empty());
-        seed = hash_combine(seed, !weights_zero_points.empty());
-        seed = hash_combine(seed, !activations_zero_points.empty());
-        seed = hash_combine(seed, !compensation.empty());
+        seed = hash_combine(seed, !weights.is_valid());
+        seed = hash_combine(seed, !bias.is_valid());
+        seed = hash_combine(seed, !weights_zero_points.is_valid());
+        seed = hash_combine(seed, !activations_zero_points.is_valid());
+        seed = hash_combine(seed, !compensation.is_valid());
         return seed;
     }
 
@@ -236,11 +236,11 @@ struct convolution : public primitive_base<convolution> {
                cmp_fields(bilinear_interpolation_pad) &&
                cmp_fields(transposed) &&
                cmp_fields(grouped_weights_shape) &&
-               cmp_fields(weights.empty()) &&
-               cmp_fields(bias.empty()) &&
-               cmp_fields(weights_zero_points.empty()) &&
-               cmp_fields(activations_zero_points.empty()) &&
-               cmp_fields(compensation.empty());
+               cmp_fields(weights.is_valid()) &&
+               cmp_fields(bias.is_valid()) &&
+               cmp_fields(weights_zero_points.is_valid()) &&
+               cmp_fields(activations_zero_points.is_valid()) &&
+               cmp_fields(compensation.is_valid());
         #undef cmp_fields
     }
 
@@ -277,27 +277,32 @@ struct convolution : public primitive_base<convolution> {
         ib >> bilinear_interpolation_pad;
         ib >> transposed;
         ib >> grouped_weights_shape;
-        ib >> *const_cast<primitive_id*>(&weights);
-        ib >> *const_cast<primitive_id*>(&bias);
-        ib >> *const_cast<primitive_id*>(&weights_zero_points);
-        ib >> *const_cast<primitive_id*>(&activations_zero_points);
-        ib >> *const_cast<primitive_id*>(&compensation);
+        ib >> weights;
+        ib >> bias;
+        ib >> weights_zero_points;
+        ib >> activations_zero_points;
+        ib >> compensation;
     }
 
-    std::vector<input_info> get_dependencies() const override {
-        std::vector<input_info> ret = {weights};
-        if (!bias.empty()) {
-            ret.push_back(bias);
-        }
-        if (!weights_zero_points.empty()) {
-            ret.push_back(weights_zero_points);
-        }
-        if (!activations_zero_points.empty()) {
-            ret.push_back(activations_zero_points);
-        }
-        if (!compensation.empty()) {
-            ret.push_back(compensation);
-        }
+protected:
+    std::map<size_t, const input_info*> get_dependencies_map() const override {
+        auto ret = std::map<size_t, const input_info*>{};
+        auto idx = input.size();
+
+        OPENVINO_ASSERT(weights.is_valid());
+        ret[idx++] = &weights;
+
+        if (bias.is_valid())
+            ret[idx++] = &bias;
+
+        if (weights_zero_points.is_valid())
+            ret[idx++] = &weights_zero_points;
+
+        if (activations_zero_points.is_valid())
+            ret[idx++] = &activations_zero_points;
+
+        if (compensation.is_valid())
+            ret[idx++] = &compensation;
 
         return ret;
     }

src/plugins/intel_gpu/include/intel_gpu/primitives/deconvolution.hpp

@@ -31,8 +31,8 @@ struct deconvolution : public primitive_base<deconvolution> {
     /// @param activation_slp Relu activation slope.
     deconvolution(const primitive_id& id,
                   const input_info& input,
-                  const std::vector<primitive_id>& weights,
-                  const std::vector<primitive_id>& bias,
+                  const primitive_id& weights,
+                  const primitive_id& bias,
                   ov::Strides stride = {1, 1},
                   ov::CoordinateDiff pad = {0, 0},
                   ov::Strides dilations = {1, 1})
@@ -62,8 +62,8 @@ struct deconvolution : public primitive_base<deconvolution> {
     /// @param activation_slp Relu activation slope.
     deconvolution(const primitive_id& id,
                   const input_info& input,
-                  const std::vector<primitive_id>& weights,
-                  const std::vector<primitive_id>& bias,
+                  const primitive_id& weights,
+                  const primitive_id& bias,
                   uint32_t groups,
                   ov::Strides stride = {1, 1},
                   ov::CoordinateDiff pad = {0, 0},
@@ -93,7 +93,7 @@ struct deconvolution : public primitive_base<deconvolution> {
     /// @param activation_slp Relu activation slope.
     deconvolution(const primitive_id& id,
                   const input_info& input,
-                  const std::vector<primitive_id>& weights,
+                  const primitive_id& weights,
                   ov::Strides stride = {1, 1},
                   ov::CoordinateDiff pad = {0, 0},
                   ov::Strides dilations = {1, 1})
@@ -110,7 +110,7 @@ struct deconvolution : public primitive_base<deconvolution> {
           output_partial_shape({}),
           output_shape_id(""),
           weights(weights),
-          bias(std::vector<primitive_id>(0)) {}
+          bias("") {}
 
     /// @brief Constructs deconvolution primitive (w/o bias).
     /// @param id This primitive id.
@@ -123,7 +123,7 @@ struct deconvolution : public primitive_base<deconvolution> {
     /// @param activation_slp Relu activation slope.
     deconvolution(const primitive_id& id,
                   const input_info& input,
-                  const std::vector<primitive_id> &weights,
+                  const primitive_id& weights,
                   uint32_t groups,
                   ov::Strides stride = {1, 1},
                   ov::CoordinateDiff pad = {0, 0},
@@ -141,7 +141,7 @@ struct deconvolution : public primitive_base<deconvolution> {
           output_partial_shape({}),
           output_shape_id(""),
           weights(weights),
-          bias(std::vector<primitive_id>(0)) {}
+          bias("") {}
 
     /// @brief Constructs deconvolution primitive (computes input paddings to match output size).
     /// @param id This primitive id.
@@ -155,8 +155,8 @@ struct deconvolution : public primitive_base<deconvolution> {
     /// @param output_size User-defined output data size of the primitive (w/o padding).
     deconvolution(const primitive_id& id,
                   const input_info& input,
-                  const std::vector<primitive_id>& weights,
-                  const std::vector<primitive_id>& bias,
+                  const primitive_id& weights,
+                  const primitive_id& bias,
                   ov::Strides stride,
                   ov::CoordinateDiff pad,
                   ov::Strides dilations,
@@ -190,8 +190,8 @@ struct deconvolution : public primitive_base<deconvolution> {
     /// @param output_size User-defined output data size of the primitive (w/o padding).
     deconvolution(const primitive_id& id,
                   const input_info& input,
-                  const std::vector<primitive_id>& weights,
-                  const std::vector<primitive_id>& bias,
+                  const primitive_id& weights,
+                  const primitive_id& bias,
                   uint32_t groups,
                   ov::Strides stride,
                   ov::CoordinateDiff pad,
@@ -227,8 +227,8 @@ struct deconvolution : public primitive_base<deconvolution> {
     /// @param output_size User-defined output data size of the primitive (w/o padding).
     deconvolution(const primitive_id& id,
                   const input_info& input,
-                  const std::vector<primitive_id>& weights,
-                  const std::vector<primitive_id>& bias,
+                  const primitive_id& weights,
+                  const primitive_id& bias,
                   uint32_t groups,
                   ov::Strides stride,
                   ov::CoordinateDiff pad,
@@ -263,7 +263,7 @@ struct deconvolution : public primitive_base<deconvolution> {
     /// @param output_size User-defined output data size of the primitive (w/o padding).
     deconvolution(const primitive_id& id,
                   const input_info& input,
-                  const std::vector<primitive_id>& weights,
+                  const primitive_id& weights,
                   ov::Strides stride,
                   ov::CoordinateDiff pad,
                   ov::Strides dilations,
@@ -280,7 +280,7 @@ struct deconvolution : public primitive_base<deconvolution> {
           out_padding(pad.size(), 0),
           grouped_weights_shape(false),
           weights(weights),
-          bias(std::vector<primitive_id>(0)) {}
+          bias("") {}
 
     /// @brief Constructs deconvolution primitive (computes input paddings to match output size).
     /// @param id This primitive id.
@@ -295,8 +295,8 @@ struct deconvolution : public primitive_base<deconvolution> {
     /// @return Deconvolution primitive with specified settings.
     static deconvolution create_with_output_size(const primitive_id& id,
                                                  const input_info& input,
-                                                 const std::vector<primitive_id>& weights,
-                                                 const std::vector<primitive_id>& bias,
+                                                 const primitive_id& weights,
+                                                 const primitive_id& bias,
                                                  tensor output_size,
                                                  ov::Strides stride = {1, 1},
                                                  ov::CoordinateDiff pad = {0, 0},
@@ -323,7 +323,7 @@ struct deconvolution : public primitive_base<deconvolution> {
     /// @return Deconvolution primitive with specified settings.
     static deconvolution create_with_output_size(const primitive_id& id,
                                                  const input_info& input,
-                                                 const std::vector<primitive_id>& weights,
+                                                 const primitive_id& weights,
                                                  tensor output_size,
                                                  ov::Strides stride = {1, 1},
                                                  ov::CoordinateDiff pad = {0, 0},
@@ -360,21 +360,21 @@ struct deconvolution : public primitive_base<deconvolution> {
     /// @brief Defines spatial shape of the output.
     ov::PartialShape output_partial_shape;
     /// @brief Data primitive id containing spatial shape of the output.
-    primitive_id output_shape_id;
+    input_info output_shape_id;
     /// @brief List of primitive ids containing weights data.
-    const primitive_id_arr weights;
+    input_info weights;
     /// @brief List of primitive ids containing bias data.
-    const primitive_id_arr bias;
+    input_info bias;
 
     size_t hash() const override {
         size_t seed = primitive::hash();
         seed = hash_range(seed, pad.begin(), pad.end());
         seed = hash_range(seed, stride.begin(), stride.end());
         seed = hash_combine(seed, groups);
         seed = hash_combine(seed, grouped_weights_shape);
-        seed = hash_combine(seed, weights.size());
-        seed = hash_combine(seed, bias.size());
-        seed = hash_combine(seed, output_shape_id.empty());
+        seed = hash_combine(seed, weights.is_valid());
+        seed = hash_combine(seed, bias.is_valid());
+        seed = hash_combine(seed, output_shape_id.is_valid());
         return seed;
     }
 
@@ -393,9 +393,9 @@ struct deconvolution : public primitive_base<deconvolution> {
                cmp_fields(pads_end) &&
                cmp_fields(out_padding) &&
                cmp_fields(grouped_weights_shape) &&
-               cmp_fields(weights.size()) &&
-               cmp_fields(bias.size()) &&
-               cmp_fields(output_shape_id.empty());
+               cmp_fields(weights.is_valid()) &&
+               cmp_fields(bias.is_valid()) &&
+               cmp_fields(output_shape_id.is_valid());
         #undef cmp_fields
     }
 
@@ -431,17 +431,23 @@ struct deconvolution : public primitive_base<deconvolution> {
         ib >> grouped_weights_shape;
         ib >> output_partial_shape;
         ib >> output_shape_id;
-        ib >> *const_cast<primitive_id_arr*>(&weights);
-        ib >> *const_cast<primitive_id_arr*>(&bias);
+        ib >> weights;
+        ib >> bias;
     }
 
 protected:
-    std::vector<input_info> get_dependencies() const override {
-        std::vector<input_info> ret;
-        ret.reserve(weights.size() + bias.size() + (output_shape_id.empty() ? 0 : 1));
-        for (auto& w : weights) ret.push_back(w);
-        for (auto& b : bias) ret.push_back(b);
-        if (!output_shape_id.empty()) ret.push_back(output_shape_id);
+    std::map<size_t, const input_info*> get_dependencies_map() const override {
+        auto ret = std::map<size_t, const input_info*>{};
+        auto idx = input.size();
+
+        OPENVINO_ASSERT(weights.is_valid());
+        ret[idx++] = &weights;
+
+        if (bias.is_valid())
+            ret[idx++] = &bias;
+
+        if (output_shape_id.is_valid())
+            ret[idx++] = &output_shape_id;
 
         return ret;
     }