Support for more complex cases with data paddings after the crop axis

Author: sshlyapn

src/plugins/intel_gpu/src/graph/impls/ocl/crop.cpp

@@ -8,6 +8,8 @@
 #include "eltwise/eltwise_kernel_selector.h"
 #include "eltwise/eltwise_kernel_base.h"
 
+#include "openvino/core/validation_util.hpp"
+
 namespace cldnn {
 namespace ocl {
 
@@ -56,18 +58,27 @@ struct crop_impl : typed_primitive_impl_ocl<crop> {
 
         update_shapes(*_kernel_data.params, impl_param);
 
-        // Reset input_layout padding as the offset configured by crop should affect only "data"
-        // area and shouldn't depend on input_layout paddings.
-        // For example, for an input shape like: [1, 32, 128 (pad_before=512, pad_after=0), 8]
+        // The padding sizes are reset to 0 up to crop_axis, as kernel reads data using
+        // "input[GET_INDEX(INPUT, order) + runtime_offset]", where GET_INDEX handles all paddings before
+        // specified axis. However, for proper runtime offset calculation, we have to consider paddings
+        // after the crop_axis, which requires subtracting input_offset from the runtime buffer, since
+        // padding for the first element is already included in the GET_INDEX() call.
+        // For example, for input shape like: [1, 32, 128 (pad_before=512, pad_after=0), 8 (pad_before=4, pad_after=4)]
         // with crop_axis=2 and split_lengths = {64, 64},
-        // runtime_offset should be set in terms of [1, 32, 128, 8] shape, as the kernel reads data
-        // using "input[GET_INDEX(INPUT, order) + runtime_offset]", where GET_INDEX already reflects input
-        // data paddings.
-        // So crop.out0's runtime_offset=0 and crop.out1's runtime_offset=512.
+        // runtime_offset should be set in terms of [1, 32, 128 (pad_before=0, pad_after=0), 8 (pad_before=4, pad_after=4)] shape.
+        // So crop.out0's runtime_offset=0 and crop.out1's runtime_offset=1024.
+
         auto input_layout = impl_param.get_input_layout();
-        input_layout.data_padding = padding();
+        auto crop_axis = ov::util::normalize(impl_param.typed_desc<crop>()->axis, static_cast<int64_t>(input_layout.get_partial_shape().size()));
+
+        input_layout.data_padding._dynamic_dims_mask = padding::EMPTY_MASK;
+        for (size_t i = 0; i <= static_cast<size_t>(crop_axis); i++) {
+            input_layout.data_padding._lower_size[i] = 0;
+            input_layout.data_padding._upper_size[i] = 0;
+        }
 
-        auto runtime_offset = convert_data_tensor(input_layout, impl_param.input_offsets[0]).GetFirstElementOffset();
+        auto input_offset = convert_data_tensor(input_layout).GetFirstElementOffset();
+        auto runtime_offset = convert_data_tensor(input_layout, impl_param.input_offsets[0]).GetFirstElementOffset() - input_offset;
         kernel_selector::ScalarDescriptor s;
         s.t = kernel_selector::ScalarDescriptor::Types::UINT32;
         s.v.u32 = static_cast<uint32_t>(runtime_offset);

src/plugins/intel_gpu/tests/unit/test_cases/crop_gpu_test.cpp

@@ -1485,16 +1485,24 @@ TEST(crop_gpu, dynamic_input_padding_varaidic_split) {
     auto y_size = 128;
     auto x_size = 4;
 
-    auto axis = 2;
+    auto split_axis = 2;
+    auto data_y_pad_axis = 2;
+    auto data_x_pad_axis = 3;
     auto input_y_pad_before = 64;
     auto input_y_pad_after = 32;
+    auto input_x_pad_before = 8;
+    auto input_x_pad_after = 2;
 
     auto input_dyn_layout = layout{ ov::PartialShape{-1, feature_num, y_size, x_size}, data_types::f32, format::bfyx };
-    input_dyn_layout.data_padding._dynamic_dims_mask[axis] = 1;
+    input_dyn_layout.data_padding._dynamic_dims_mask[data_y_pad_axis] = 1;
+    input_dyn_layout.data_padding._lower_size[data_x_pad_axis] = input_x_pad_before;
+    input_dyn_layout.data_padding._upper_size[data_x_pad_axis] = input_x_pad_after;
 
     auto input_actual_layout = layout{ ov::PartialShape{batch_num, feature_num, y_size, x_size}, data_types::f32, format::bfyx };
-    input_actual_layout.data_padding._lower_size[axis] = input_y_pad_before;
-    input_actual_layout.data_padding._upper_size[axis] = input_y_pad_after;
+    input_actual_layout.data_padding._lower_size[data_y_pad_axis] = input_y_pad_before;
+    input_actual_layout.data_padding._upper_size[data_y_pad_axis] = input_y_pad_after;
+    input_actual_layout.data_padding._lower_size[data_x_pad_axis] = input_x_pad_before;
+    input_actual_layout.data_padding._upper_size[data_x_pad_axis] = input_x_pad_after;
 
     auto input_mem = engine.allocate_memory(input_actual_layout);
     auto axis_mem = engine.allocate_memory({ {}, data_types::i64, format::bfyx });
@@ -1506,16 +1514,16 @@ TEST(crop_gpu, dynamic_input_padding_varaidic_split) {
     cldnn::crop_ngraph_op_mode op_mode = cldnn::crop_ngraph_op_mode::variadic_split;
     topology topology;
     topology.add(input_layout("input", input_dyn_layout));
-    topology.add(data("axis", axis_mem));
+    topology.add(data("split_axis", axis_mem));
     topology.add(data("splits_length", splits_length_mem));
-    topology.add(crop("variadic_split.out0", { input_info("input"), input_info("axis"), input_info("splits_length") }, tensor(1), tensor(0), op_mode, 0, axis));
-    topology.add(crop("variadic_split.out1", { input_info("input"), input_info("axis"), input_info("splits_length") }, tensor(1), tensor(0), op_mode, 1, axis));
+    topology.add(crop("variadic_split.out0", { input_info("input"), input_info("split_axis"), input_info("splits_length") }, tensor(1), tensor(0), op_mode, 0, split_axis));
+    topology.add(crop("variadic_split.out1", { input_info("input"), input_info("split_axis"), input_info("splits_length") }, tensor(1), tensor(0), op_mode, 1, split_axis));
 
     std::vector<int64_t> splits_vec = { 64, 64 };
 
     set_values(input_mem, input_data);
     set_values(splits_length_mem, splits_vec);
-    set_values<int64_t>(axis_mem, {axis});
+    set_values<int64_t>(axis_mem, {split_axis});
 
     ExecutionConfig config = get_test_default_config(engine);
     config.set_property(ov::intel_gpu::allow_new_shape_infer(true));