COMPMID-2728: Add support for split sizes in CLSplit

Signed-off-by: Kurtis Charnock <kurtis.charnock@arm.com>
Change-Id: I69ea9e812478904c3e10379bb5943d534c45f942
Reviewed-on: https://eu-gerrit-1.euhpc.arm.com/c/VisualCompute/ComputeLibrary/+/214132
Tested-by: bsgcomp <bsgcomp@arm.com>
Reviewed-by: Georgios Pinitas <georgios.pinitas@arm.com>
Reviewed-on: https://review.mlplatform.org/c/2432
Tested-by: Arm Jenkins <bsgcomp@arm.com>
Comments-Addressed: Arm Jenkins <bsgcomp@arm.com>
Reviewed-by: Michele Di Giorgio <michele.digiorgio@arm.com>

3 files changed, 267 insertions, 3 deletions

diff --git a/tests/datasets/SplitDataset.h b/tests/datasets/SplitDataset.h
index b38252a489..3d4c289ba7 100644
--- a/tests/datasets/SplitDataset.h
+++ b/tests/datasets/SplitDataset.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018 ARM Limited.
+ * Copyright (c) 2018-2020 ARM Limited.
  *
  * SPDX-License-Identifier: MIT
  *
@@ -128,6 +128,90 @@ public:
         add_config(TensorShape(128U, 64U, 32U, 4U), 3U, 4U);
     }
 };
+
+class SplitShapesDataset
+{
+public:
+    using type = std::tuple<TensorShape, unsigned int, std::vector<TensorShape>>;
+
+    struct iterator
+    {
+        iterator(std::vector<TensorShape>::const_iterator              tensor_shapes_it,
+                 std::vector<unsigned int>::const_iterator             axis_values_it,
+                 std::vector<std::vector<TensorShape>>::const_iterator split_shapes_values_it)
+            : _tensor_shapes_it{ std::move(tensor_shapes_it) },
+              _axis_values_it{ std::move(axis_values_it) },
+              _split_shapes_values_it{ std::move(split_shapes_values_it) }
+        {
+        }
+
+        std::string description() const
+        {
+            std::stringstream description;
+            description << "Shape=" << *_tensor_shapes_it << ":";
+            description << "Axis=" << *_axis_values_it << ":";
+            description << "Split shapes=" << *_split_shapes_values_it << ":";
+            return description.str();
+        }
+
+        SplitShapesDataset::type operator*() const
+        {
+            return std::make_tuple(*_tensor_shapes_it, *_axis_values_it, *_split_shapes_values_it);
+        }
+
+        iterator &operator++()
+        {
+            ++_tensor_shapes_it;
+            ++_axis_values_it;
+            ++_split_shapes_values_it;
+            return *this;
+        }
+
+    private:
+        std::vector<TensorShape>::const_iterator              _tensor_shapes_it;
+        std::vector<unsigned int>::const_iterator             _axis_values_it;
+        std::vector<std::vector<TensorShape>>::const_iterator _split_shapes_values_it;
+    };
+
+    iterator begin() const
+    {
+        return iterator(_tensor_shapes.begin(), _axis_values.begin(), _split_shapes_values.begin());
+    }
+
+    int size() const
+    {
+        return std::min(_tensor_shapes.size(), std::min(_axis_values.size(), _split_shapes_values.size()));
+    }
+
+    void add_config(TensorShape shape, unsigned int axis, std::vector<TensorShape> split_shapes)
+    {
+        _tensor_shapes.emplace_back(std::move(shape));
+        _axis_values.emplace_back(axis);
+        _split_shapes_values.emplace_back(split_shapes);
+    }
+
+protected:
+    SplitShapesDataset()                      = default;
+    SplitShapesDataset(SplitShapesDataset &&) = default;
+
+private:
+    std::vector<TensorShape>              _tensor_shapes{};
+    std::vector<unsigned int>             _axis_values{};
+    std::vector<std::vector<TensorShape>> _split_shapes_values{};
+};
+
+class SmallSplitShapesDataset final : public SplitShapesDataset
+{
+public:
+    SmallSplitShapesDataset()
+    {
+        add_config(TensorShape(27U, 3U, 16U, 2U), 2U, std::vector<TensorShape> { TensorShape(27U, 3U, 4U, 2U),
+                                                                                 TensorShape(27U, 3U, 4U, 2U),
+                                                                                 TensorShape(27U, 3U, 8U, 2U)
+                                                                               });
+    }
+};
+
 } // namespace datasets
 } // namespace test
 } // namespace arm_compute
diff --git a/tests/validation/CL/Split.cpp b/tests/validation/CL/Split.cpp
index e038b89856..8f55b4250f 100644
--- a/tests/validation/CL/Split.cpp
+++ b/tests/validation/CL/Split.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018-2019 ARM Limited.
+ * Copyright (c) 2018-2020 ARM Limited.
  *
  * SPDX-License-Identifier: MIT
  *
@@ -65,6 +65,29 @@ DATA_TEST_CASE(Validate, framework::DatasetMode::ALL, zip(zip(zip(
     const Status status = CLSplit::validate(&input_info.clone()->set_is_resizable(false), outputs_info_ptr, axis);
     ARM_COMPUTE_EXPECT(bool(status) == expected, framework::LogLevel::ERRORS);
 }
+
+DATA_TEST_CASE(ValidateSplitShapes, framework::DatasetMode::ALL, zip(zip(zip(
+        framework::dataset::make("InputInfo", { TensorInfo(TensorShape(27U, 3U, 16U, 2U), 1, DataType::F32),
+                                                TensorInfo(TensorShape(27U, 3U, 16U, 2U), 1, DataType::F32)
+        }),
+        framework::dataset::make("Axis", { 2, 2 })),
+        framework::dataset::make("Splits", { std::vector<TensorInfo>{TensorInfo(TensorShape(27U, 3U, 4U,  2U), 1, DataType::F32),
+                                                                     TensorInfo(TensorShape(27U, 3U, 4U,  2U), 1, DataType::F32),
+                                                                     TensorInfo(TensorShape(27U, 3U, 8U,  2U), 1, DataType::F32)},
+                                             std::vector<TensorInfo>{TensorInfo(TensorShape(27U, 3U, 3U,  2U), 1, DataType::F32),
+                                                                     TensorInfo(TensorShape(27U, 3U, 13U, 2U), 1, DataType::F32)} })),
+        framework::dataset::make("Expected", { true, true })),
+        input_info, axis, splits, expected)
+{
+    std::vector<ITensorInfo*> outputs_info_ptr;
+
+    for(auto &split : splits)
+    {
+        outputs_info_ptr.emplace_back(const_cast<TensorInfo*>(&split));
+    }
+    const Status status = CLSplit::validate(&input_info.clone()->set_is_resizable(false), outputs_info_ptr, axis);
+    ARM_COMPUTE_EXPECT(bool(status) == expected, framework::LogLevel::ERRORS);
+}
 // clang-format on
 // *INDENT-ON*
 
@@ -95,9 +118,45 @@ DATA_TEST_CASE(Configuration,
     }
 }
 
+DATA_TEST_CASE(ConfigurationSplitShapes,
+               framework::DatasetMode::ALL,
+               combine(datasets::SmallSplitShapesDataset(), framework::dataset::make("DataType", { DataType::F16, DataType::F32 })),
+               shape, axis, split_shapes, data_type)
+{
+    // Create tensors
+    CLTensor              src = create_tensor<CLTensor>(shape, data_type);
+    std::vector<CLTensor> dsts;
+
+    for(const auto &split_shape : split_shapes)
+    {
+        CLTensor dst = create_tensor<CLTensor>(split_shape, data_type);
+        dsts.push_back(std::move(dst));
+    }
+
+    std::vector<ICLTensor *> dsts_ptrs;
+    for(auto &dst : dsts)
+    {
+        dsts_ptrs.emplace_back(&dst);
+    }
+
+    // Create and Configure function
+    CLSplit split;
+    split.configure(&src, dsts_ptrs, axis);
+
+    // Validate valid regions
+    for(auto &dst : dsts)
+    {
+        const ValidRegion valid_region = shape_to_valid_region(dst.info()->tensor_shape());
+        validate(dst.info()->valid_region(), valid_region);
+    }
+}
+
 template <typename T>
 using CLSplitFixture = SplitFixture<CLTensor, ICLTensor, CLAccessor, CLSplit, T>;
 
+template <typename T>
+using CLSplitShapesFixture = SplitShapesFixture<CLTensor, ICLTensor, CLAccessor, CLSplit, T>;
+
 TEST_SUITE(Float)
 TEST_SUITE(FP16)
 FIXTURE_DATA_TEST_CASE(RunSmall,
@@ -149,6 +208,18 @@ FIXTURE_DATA_TEST_CASE(RunLarge,
         validate(CLAccessor(_target[i]), _reference[i]);
     }
 }
+
+FIXTURE_DATA_TEST_CASE(RunSmallSplitShapes,
+                       CLSplitShapesFixture<float>,
+                       framework::DatasetMode::PRECOMMIT,
+                       combine(datasets::SmallSplitShapesDataset(), framework::dataset::make("DataType", DataType::F32)))
+{
+    // Validate outputs
+    for(unsigned int i = 0; i < _target.size(); ++i)
+    {
+        validate(CLAccessor(_target[i]), _reference[i]);
+    }
+}
 TEST_SUITE_END() // FP32
 TEST_SUITE_END() // Float
 
diff --git a/tests/validation/fixtures/SplitFixture.h b/tests/validation/fixtures/SplitFixture.h
index 07501775e5..d2336ab2d9 100644
--- a/tests/validation/fixtures/SplitFixture.h
+++ b/tests/validation/fixtures/SplitFixture.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018 ARM Limited.
+ * Copyright (c) 2018-2020 ARM Limited.
  *
  * SPDX-License-Identifier: MIT
  *
@@ -145,6 +145,115 @@ protected:
     std::vector<TensorType>      _target{};
     std::vector<SimpleTensor<T>> _reference{};
 };
+
+template <typename TensorType, typename ITensorType, typename AccessorType, typename FunctionType, typename T>
+class SplitShapesFixture : public framework::Fixture
+{
+public:
+    template <typename...>
+    void setup(TensorShape shape, unsigned int axis, std::vector<TensorShape> split_shapes, DataType data_type)
+    {
+        _target    = compute_target(shape, axis, split_shapes, data_type);
+        _reference = compute_reference(shape, axis, split_shapes, data_type);
+    }
+
+protected:
+    template <typename U>
+    void fill(U &&tensor, int i)
+    {
+        library->fill_tensor_uniform(tensor, i);
+    }
+
+    std::vector<TensorType> compute_target(TensorShape shape, unsigned int axis, std::vector<TensorShape> split_shapes, DataType data_type)
+    {
+        // Create tensors
+        TensorType                 src = create_tensor<TensorType>(shape, data_type);
+        std::vector<TensorType>    dsts{};
+        std::vector<ITensorType *> dsts_ptr;
+
+        for(const auto &split_shape : split_shapes)
+        {
+            TensorType dst = create_tensor<TensorType>(split_shape, data_type);
+            dsts.push_back(std::move(dst));
+        }
+
+        for(auto &dst : dsts)
+        {
+            dsts_ptr.emplace_back(&dst);
+        }
+
+        // Create and configure function
+        FunctionType split;
+        split.configure(&src, dsts_ptr, axis);
+
+        ARM_COMPUTE_EXPECT(src.info()->is_resizable(), framework::LogLevel::ERRORS);
+        ARM_COMPUTE_EXPECT(std::all_of(dsts.cbegin(), dsts.cend(), [](const TensorType & t)
+        {
+            return t.info()->is_resizable();
+        }),
+        framework::LogLevel::ERRORS);
+
+        // Allocate tensors
+        src.allocator()->allocate();
+        for(unsigned int i = 0; i < dsts.size(); ++i)
+        {
+            dsts[i].allocator()->allocate();
+        }
+
+        ARM_COMPUTE_EXPECT(!src.info()->is_resizable(), framework::LogLevel::ERRORS);
+        ARM_COMPUTE_EXPECT(std::all_of(dsts.cbegin(), dsts.cend(), [](const TensorType & t)
+        {
+            return !t.info()->is_resizable();
+        }),
+        framework::LogLevel::ERRORS);
+
+        // Fill tensors
+        fill(AccessorType(src), 0);
+
+        // Compute function
+        split.run();
+
+        return dsts;
+    }
+
+    std::vector<SimpleTensor<T>> compute_reference(TensorShape shape, unsigned int axis, std::vector<TensorShape> split_shapes, DataType data_type)
+    {
+        // Create reference
+        SimpleTensor<T>              src{ shape, data_type };
+        std::vector<SimpleTensor<T>> dsts;
+
+        // Fill reference
+        fill(src, 0);
+
+        unsigned int axis_offset{ 0 };
+        for(const auto &split_shape : split_shapes)
+        {
+            // Calculate splice for each split
+            const size_t axis_split_step = split_shape[axis];
+
+            // Start/End coordinates
+            Coordinates start_coords;
+            Coordinates end_coords;
+            for(unsigned int d = 0; d < shape.num_dimensions(); ++d)
+            {
+                end_coords.set(d, -1);
+            }
+
+            // Update coordinate on axis
+            start_coords.set(axis, axis_offset);
+            end_coords.set(axis, axis_offset + axis_split_step);
+
+            dsts.emplace_back(std::move(reference::slice(src, start_coords, end_coords)));
+
+            axis_offset += axis_split_step;
+        }
+
+        return dsts;
+    }
+
+    std::vector<TensorType>      _target{};
+    std::vector<SimpleTensor<T>> _reference{};
+};
 } // namespace validation
 } // namespace test
 } // namespace arm_compute