[CORE][REFERENCE] Add bounds checking for SpaceToBatch

[EgorDuplensky]

Tickets:

• 181018

[Copilot]

Pull request overview

Adds runtime-side validation for SpaceToBatch padding values to prevent invalid/overflowing padded-shape computations, and extends the template plugin reference tests with negative coverage to ensure invalid paddings throw.

Changes:

• Add non-negative and overflow guards when computing padded_shape in SpaceToBatch reference evaluation.
• Add new negative (exception-expected) reference tests covering huge and negative padding inputs.

Reviewed changes

Copilot reviewed 2 out of 2 changed files in this pull request and generated 2 comments.

File	Description
src/core/src/op/space_to_batch.cpp	Adds padding validation and overflow checks during evaluate() padded-shape computation.
src/plugins/template/tests/functional/op_reference/space_to_batch.cpp	Adds parameterized negative tests asserting invalid padding configurations throw ov::Exception.

---

You can also share your feedback on Copilot code review. Take the survey.

[maxnick]

@mitruska , could you please review the core shape inference changes and tests?

[mitruska]

Approved as the checks are valid and the output shape logic remains the same, backward compatibility is preserved.

The only suggestion is that those checks could be moved from evaluate to shape_infer.

[mitruska]

Any reason why the validation has been not extended in the shape_infer function?

The shape_infer is called during op constructor and in SpaceToBatch::evaluate, in case of Const pads and static/bounded dimensions, it could preserve from creation of such op even before execution. Also the checks could be beneficial for plugins where the shape_infer function is shared and called for dynamic case.

Related tests to cover such case are here:

openvino/src/core/tests/type_prop/space_to_batch.cpp

Lines 73 to 85 in 44967ef

	TEST(type_prop, space_to_batch_when_space_is_static) {
	auto data_shape = PartialShape{{2, 5}, 100, 1024, 3};
	set_shape_symbols(data_shape);
	auto data = make_shared<ov::op::v0::Parameter>(element::f32, data_shape);
	auto block_shape = make_shared<ov::op::v0::Constant>(element::i64, Shape{4}, vector<int64_t>{1, 12, 100, 2});
	auto pads_begin = make_shared<ov::op::v0::Constant>(element::i64, Shape{4}, vector<int64_t>{0, 3, 38, 1});
	auto pads_end = make_shared<ov::op::v0::Constant>(element::i64, Shape{4}, vector<int64_t>{0, 5, 38, 0});
	auto space_to_batch = make_shared<op::v1::SpaceToBatch>(data, block_shape, pads_begin, pads_end);
	EXPECT_EQ(
	space_to_batch->get_output_partial_shape(0),
	(PartialShape{{2 * 12 * 100 * 2, 5 * 12 * 100 * 2}, (100 + 3 + 5) / 12, (1024 + 38 + 38) / 100, (3 + 1) / 2}));

openvino/src/plugins/intel_cpu/tests/unit/shape_inference_test/space_to_batch_shape_inference_test.cpp

Lines 50 to 65 in 44967ef

	TEST_F(SpaceToBatchV1StaticShapeInferenceTest, blocks_pads_as_constants) {
	const auto data = std::make_shared<Parameter>(element::f32, PartialShape{-1, -1, -1, -1});
	const auto block_shape =
	std::make_shared<Constant>(element::i64, ov::Shape{4}, std::vector<int64_t>{1, 12, 100, 2});
	const auto pads_begin = std::make_shared<Constant>(element::i64, ov::Shape{4}, std::vector<int64_t>{0, 3, 38, 1});
	const auto pads_end = std::make_shared<Constant>(element::i64, ov::Shape{4}, std::vector<int64_t>{0, 5, 38, 0});
	const auto op = make_op(data, block_shape, pads_begin, pads_end);
	input_shapes = {{2, 100, 1024, 3}, {4}, {4}, {4}};
	output_shapes = shape_inference(op.get(), input_shapes);
	EXPECT_EQ(output_shapes[0],
	(StaticShape{2 * 12 * 100 * 2, (100 + 3 + 5) / 12, (1024 + 38 + 38) / 100, (3 + 1) / 2}));
	}