[WIP][GPU] Remove legacy shape infer and multi-out handling

src/plugins/intel_gpu/include/intel_gpu/graph/program.hpp

@@ -287,7 +287,6 @@ struct program {
     void load(cldnn::BinaryInputBuffer& ib);
     bool is_loaded_from_cache() const { return _loaded_from_cache; }
 
-    bool is_new_shape_infer() const { return new_shape_infer; }
     layout_optimizer& get_layout_optimizer() const { return *_layout_optimizer; }
 
 private:
@@ -313,8 +312,6 @@ struct program {
     std::shared_ptr<ICompilationContext> _compilation_context;
     bool _loaded_from_cache = false;
 
-    bool new_shape_infer = false;
-
     std::map<primitive_id, std::shared_ptr<program_node>> nodes_map;
     std::list<primitive_id> optimized_out;
 

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

@@ -138,8 +138,6 @@ class ProgramBuilder final {
 
     void add_primitive(const ov::Node& op, std::shared_ptr<cldnn::primitive> prim, std::vector<std::string> aliases = {});
 
-    bool use_new_shape_infer() const { return allow_new_shape_infer; }
-    bool requires_new_shape_infer(const std::shared_ptr<ov::Node>& op) const;
     bool is_inner_program() const { return m_is_inner_program; }
     bool is_query_mode() { return queryMode; }
 
@@ -157,8 +155,6 @@ class ProgramBuilder final {
     std::shared_ptr<cldnn::topology> m_topology;
     CustomLayerMap m_custom_layers;
 
-    bool allow_new_shape_infer = false;
-
     bool queryMode;
 
     std::shared_ptr<ov::threading::IStreamsExecutor> m_task_executor;

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

@@ -20,35 +20,6 @@ struct adaptive_pooling : public primitive_base<adaptive_pooling> {
                          mode{adaptive_pooling_mode::average},
                          output_size{} {}
 
-    /// @brief Constructs AdaptiveAvgPooling primitive.
-    /// @param id This primitive id.
-    /// @param input Input primitive id.
-    /// @param output_size Output data size of the primitive
-    adaptive_pooling(const primitive_id &id,
-                     const input_info &input,
-                     tensor output_size)
-            : primitive_base(id, {input}),
-              mode{adaptive_pooling_mode::average},
-              output_size{output_size} {}
-
-    /// @brief Constructs AdaptiveMaxPooling primitive.
-    /// @param id This primitive id.
-    /// @param input Input primitive id.
-    /// @param output_shape Output shape primitive id.
-    /// @param output_size Output data size of the primitive
-    /// @param indices_output Indices output primitive id.
-    /// @param index_element_type Data type of indices output.
-    adaptive_pooling(const primitive_id &id,
-                     const input_info &input,
-                     tensor output_size,
-                     const primitive_id &indices_output,
-                     data_types index_element_type)
-            : primitive_base(id, {input, indices_output}),
-              mode{adaptive_pooling_mode::max},
-              output_size{output_size},
-              indices_output{indices_output},
-              index_element_type{index_element_type} {}
-
     /// @brief Constructs AdaptiveAvgPooling primitive for dynamic shape.
     /// @param id This primitive id.
     /// @param input Input primitive id.

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

@@ -111,12 +111,6 @@ struct arg_max_min : public primitive_base<arg_max_min> {
                stable == rhs_casted.stable;
     }
 
-    size_t get_output_nums() const {
-        return (input_size() == 3 ? 2 : output_size());
-    }
-    bool has_second_output() const { return get_output_nums() == 2; }
-    bool use_multiple_outputs() const { return input_size() != 3; }
-
     void save(BinaryOutputBuffer& ob) const override {
         primitive_base<arg_max_min>::save(ob);
         ob << make_data(&mode, sizeof(ov::op::TopKMode));

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

@@ -50,38 +50,33 @@ struct batch_to_space : public primitive_base<batch_to_space> {
     /// @param crops_end Amount to crop from the ending along each axis of data input
     batch_to_space(const primitive_id& id,
                    const input_info& input,
-                   const tensor& block_shape,
-                   const tensor& crops_begin,
-                   const tensor& crops_end,
-                   const tensor& out_size)
+                   const std::vector<int32_t>& block_shape,
+                   const std::vector<int32_t>& crops_begin,
+                   const std::vector<int32_t>& crops_end)
         : primitive_base(id, {input}),
           block_shape(block_shape),
           crops_begin(crops_begin),
           crops_end(crops_end),
-          out_size(out_size),
           shape_constant(1) {}
 
     batch_to_space(const primitive_id& id,
-                   const std::vector<input_info>& inputs,
-                   const tensor& out_size)
-        : primitive_base(id, inputs),
-          block_shape(tensor()),
-          crops_begin(tensor()),
-          crops_end(tensor()),
-          out_size(out_size),
+                   const std::vector<input_info>& inputs)
+        : primitive_base(id, inputs, {}),
+          block_shape({}),
+          crops_begin({}),
+          crops_end({}),
           shape_constant(0) {}
 
-    tensor block_shape;
-    tensor crops_begin;
-    tensor crops_end;
-    tensor out_size;
+    std::vector<int32_t> block_shape;
+    std::vector<int32_t> crops_begin;
+    std::vector<int32_t> crops_end;
     int64_t shape_constant;
 
     size_t hash() const override {
         size_t seed = primitive::hash();
-        seed = hash_combine(seed, block_shape.hash());
-        seed = hash_combine(seed, crops_begin.hash());
-        seed = hash_combine(seed, crops_end.hash());
+        seed = hash_range(seed, block_shape.begin(), block_shape.end());
+        seed = hash_range(seed, crops_begin.begin(), crops_begin.end());
+        seed = hash_range(seed, crops_end.begin(), crops_end.end());
         seed = hash_combine(seed, shape_constant);
         return seed;
     }
@@ -102,7 +97,6 @@ struct batch_to_space : public primitive_base<batch_to_space> {
         ob << block_shape;
         ob << crops_begin;
         ob << crops_end;
-        ob << out_size;
         ob << shape_constant;
     }
 
@@ -111,7 +105,6 @@ struct batch_to_space : public primitive_base<batch_to_space> {
         ib >> block_shape;
         ib >> crops_begin;
         ib >> crops_end;
-        ib >> out_size;
         ib >> shape_constant;
     }
 };

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

@@ -57,25 +57,6 @@ struct broadcast : public primitive_base<broadcast> {
 
     broadcast() : primitive_base("", {}) {}
 
-    /// @brief Constructs broadcast primitive / layer.
-    ///
-    /// @param id              An identifier of new primitive.
-    /// @param input           An identifier of primitive which is an input for newly created
-    ///                        broadcast primitive.
-    /// @param broadcast_sizes Sizes of broadcast. Output size of current primitive
-    ///                        will match broadcast sizes (layout type will not change).
-    /// @param broadcast_axes  Axes positions (0-based, from left to right) in output_shape
-    ///                        that are being broadcast. Values of broadcast_axes on remaining
-    ///                        axes must be greater (dividable) or equal to corresponding input
-    ///                        dimension values.
-    broadcast(const primitive_id& id,
-              const input_info& input,
-              const tensor& broadcast_sizes,
-              const std::vector<uint16_t>& broadcast_axes = {})
-        : primitive_base(id, {input}),
-          broadcast_sizes(broadcast_sizes),
-          broadcast_axes(broadcast_axes) {}
-
     /// @brief Constructs broadcast primitive / layer with static target_shape.
     ///
     /// @param id             An identifier of new primitive.
@@ -99,9 +80,7 @@ struct broadcast : public primitive_base<broadcast> {
         : primitive_base(id, {input}),
           target_shape(target_shape),
           axes_mapping(axes_mapping),
-          broadcast_mode(broadcast_spec),
-          broadcast_sizes(target_shape.empty() ? tensor(1) : tensor(0)),
-          broadcast_axes({}) {}
+          broadcast_mode(broadcast_spec) {}
 
     /// @brief Constructs broadcast primitive / layer with dynamic target_shape.
     broadcast(const primitive_id& id,
@@ -112,27 +91,19 @@ struct broadcast : public primitive_base<broadcast> {
     : primitive_base(id, {input, target_shape_id}),
       target_shape({}),
       axes_mapping(axes_mapping),
-      broadcast_mode(broadcast_spec),
-      broadcast_sizes({}),
-      broadcast_axes({}) {}
+      broadcast_mode(broadcast_spec) {}
 
     /// @brief The shape of the output tensor.
     ov::Shape target_shape;
     /// @brief The axis positions (0-based) in the result that correspond to input axes.
     ov::AxisSet axes_mapping;
     /// @brief Broadcast mode to use for determining broadcast axes.
     ov::op::BroadcastModeSpec broadcast_mode;
-    /// @brief Expected sizes of output from broadcast primitive.
-    tensor broadcast_sizes;
-    /// @brief Array of axes positions from output shape (0-based, from left to right)
-    ///        along which broadcast should happen.
-    std::vector<uint16_t> broadcast_axes;
 
     ov::PartialShape output_pshape = ov::PartialShape::dynamic();
 
     size_t hash() const override {
         size_t seed = primitive::hash();
-        seed = hash_range(seed, broadcast_axes.begin(), broadcast_axes.end());
         seed = hash_range(seed, axes_mapping.begin(), axes_mapping.end());
         return seed;
     }
@@ -145,7 +116,6 @@ struct broadcast : public primitive_base<broadcast> {
 
         return axes_mapping == rhs_casted.axes_mapping &&
                broadcast_mode == rhs_casted.broadcast_mode &&
-               broadcast_sizes == rhs_casted.broadcast_sizes &&
                output_pshape == rhs_casted.output_pshape;
     }
 
@@ -154,8 +124,6 @@ struct broadcast : public primitive_base<broadcast> {
         ob << target_shape;
         ob << axes_mapping;
         ob << make_data(&broadcast_mode, sizeof(ov::op::BroadcastModeSpec));
-        ob << broadcast_sizes;
-        ob << broadcast_axes;
         ob << output_pshape;
     }
 
@@ -164,8 +132,6 @@ struct broadcast : public primitive_base<broadcast> {
         ib >> target_shape;
         ib >> axes_mapping;
         ib >> make_data(&broadcast_mode, sizeof(ov::op::BroadcastModeSpec));
-        ib >> broadcast_sizes;
-        ib >> broadcast_axes;
         ib >> output_pshape;
     }
 };

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

@@ -29,9 +29,8 @@ struct embedding_bag : public primitive_base<embedding_bag> {
     embedding_bag(const primitive_id& id,
                   const std::vector<input_info>& inputs,
                   const embedding_bag_type& type,
-                  const tensor& output_shape,
                   const int32_t default_index = -1)
-        : primitive_base(id, inputs), type(type), output_shape(output_shape), default_index(default_index) {}
+        : primitive_base(id, inputs), type(type), default_index(default_index) {}
 
     /// @brief Type of EmbeddingBag operation
     embedding_bag_type type;
@@ -60,14 +59,12 @@ struct embedding_bag : public primitive_base<embedding_bag> {
     void save(BinaryOutputBuffer& ob) const override {
         primitive_base<embedding_bag>::save(ob);
         ob << make_data(&type, sizeof(embedding_bag_type));
-        ob << output_shape;
         ob << default_index;
     }
 
     void load(BinaryInputBuffer& ib) override {
         primitive_base<embedding_bag>::load(ib);
         ib >> make_data(&type, sizeof(embedding_bag_type));
-        ib >> output_shape;
         ib >> default_index;
     }
 };

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

@@ -37,8 +37,6 @@ struct experimental_detectron_detection_output : public primitive_base<experimen
                                             const input_info& input_deltas,
                                             const input_info& input_scores,
                                             const input_info& input_im_info,
-                                            const input_info& output_classes,
-                                            const input_info& output_scores,
                                             float score_threshold,
                                             float nms_threshold,
                                             int num_classes,
@@ -47,10 +45,7 @@ struct experimental_detectron_detection_output : public primitive_base<experimen
                                             bool class_agnostic_box_regression,
                                             float max_delta_log_wh,
                                             std::vector<float> deltas_weights)
-        : primitive_base{id,
-                         {input_rois, input_deltas, input_scores, input_im_info, output_classes, output_scores}},
-          output_classes{output_classes.pid},
-          output_scores{output_scores.pid},
+        : primitive_base{id, {input_rois, input_deltas, input_scores, input_im_info}},
           score_threshold{score_threshold},
           nms_threshold{nms_threshold},
           num_classes{num_classes},
@@ -60,34 +55,6 @@ struct experimental_detectron_detection_output : public primitive_base<experimen
           max_delta_log_wh{max_delta_log_wh},
           deltas_weights{std::move(deltas_weights)} {}
 
-        experimental_detectron_detection_output(const primitive_id& id,
-                                            const input_info& input_rois,
-                                            const input_info& input_deltas,
-                                            const input_info& input_scores,
-                                            const input_info& input_im_info,
-                                            float score_threshold,
-                                            float nms_threshold,
-                                            int num_classes,
-                                            int post_nms_count,
-                                            int max_detections_per_image,
-                                            bool class_agnostic_box_regression,
-                                            float max_delta_log_wh,
-                                            std::vector<float> deltas_weights)
-        : primitive_base{id,
-                         {input_rois, input_deltas, input_scores, input_im_info}},
-          output_classes{},
-          output_scores{},
-          score_threshold{score_threshold},
-          nms_threshold{nms_threshold},
-          num_classes{num_classes},
-          post_nms_count{post_nms_count},
-          max_detections_per_image{max_detections_per_image},
-          class_agnostic_box_regression{class_agnostic_box_regression},
-          max_delta_log_wh{max_delta_log_wh},
-          deltas_weights{std::move(deltas_weights)} {}
-
-    primitive_id output_classes;
-    primitive_id output_scores;
     float score_threshold = 0.0f;
     float nms_threshold = 0.0f;
     int num_classes = 0;
@@ -107,8 +74,6 @@ struct experimental_detectron_detection_output : public primitive_base<experimen
         seed = hash_combine(seed, class_agnostic_box_regression);
         seed = hash_combine(seed, max_delta_log_wh);
         seed = hash_range(seed, deltas_weights.begin(), deltas_weights.end());
-        seed = hash_combine(seed, output_classes.empty());
-        seed = hash_combine(seed, output_scores.empty());
         return seed;
     }
 
@@ -126,16 +91,12 @@ struct experimental_detectron_detection_output : public primitive_base<experimen
                cmp_fields(max_detections_per_image) &&
                cmp_fields(class_agnostic_box_regression) &&
                cmp_fields(max_delta_log_wh) &&
-               cmp_fields(deltas_weights) &&
-               cmp_fields(output_classes.empty()) &&
-               cmp_fields(output_scores.empty());
+               cmp_fields(deltas_weights);
         #undef cmp_fields
     }
 
     void save(BinaryOutputBuffer& ob) const override {
         primitive_base<experimental_detectron_detection_output>::save(ob);
-        ob << output_classes;
-        ob << output_scores;
         ob << score_threshold;
         ob << nms_threshold;
         ob << num_classes;
@@ -148,8 +109,6 @@ struct experimental_detectron_detection_output : public primitive_base<experimen
 
     void load(BinaryInputBuffer& ib) override {
         primitive_base<experimental_detectron_detection_output>::load(ib);
-        ib >> output_classes;
-        ib >> output_scores;
         ib >> score_threshold;
         ib >> nms_threshold;
         ib >> num_classes;
@@ -159,17 +118,5 @@ struct experimental_detectron_detection_output : public primitive_base<experimen
         ib >> max_delta_log_wh;
         ib >> deltas_weights;
     }
-
-protected:
-    std::vector<input_info> get_dependencies() const override {
-        std::vector<input_info> ret;
-        if (!output_classes.empty())
-            ret.emplace_back(output_classes);
-
-        if (!output_scores.empty())
-            ret.emplace_back(output_scores);
-
-        return ret;
-    }
 };
 }  // namespace cldnn