COMPMID-1343: Add grouping support to CLCol2ImKernel

Change-Id: I5188a2163e7341f1915d98c21464fea13a9a7faf
Reviewed-on: https://eu-gerrit-1.euhpc.arm.com/143330
Tested-by: Jenkins <bsgcomp@arm.com>
Reviewed-by: Anthony Barbier <anthony.barbier@arm.com>
Reviewed-by: Giorgio Arena <giorgio.arena@arm.com>

5 files changed, 527 insertions, 0 deletions

diff --git a/tests/datasets/Col2ImLayerDataset.h b/tests/datasets/Col2ImLayerDataset.h
new file mode 100644
index 0000000000..96a3cab134
--- /dev/null
+++ b/tests/datasets/Col2ImLayerDataset.h
@@ -0,0 +1,155 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef ARM_COMPUTE_TEST_COL2IM_DATASET
+#define ARM_COMPUTE_TEST_COL2IM_DATASET
+
+#include "utils/TypePrinter.h"
+
+#include "arm_compute/core/TensorShape.h"
+#include "arm_compute/core/Types.h"
+
+namespace arm_compute
+{
+namespace test
+{
+namespace datasets
+{
+class Col2ImLayerDataset
+{
+public:
+    using type = std::tuple<TensorShape, unsigned int, unsigned int, unsigned int>;
+
+    struct iterator
+    {
+        iterator(std::vector<TensorShape>::const_iterator  src_it,
+                 std::vector<unsigned int>::const_iterator convolved_width_it,
+                 std::vector<unsigned int>::const_iterator convolved_height_it,
+                 std::vector<unsigned int>::const_iterator num_groups_it)
+            : _src_it{ std::move(src_it) },
+              _convolved_width_it{ std::move(convolved_width_it) },
+              _convolved_height_it{ std::move(convolved_height_it) },
+              _num_groups_it{ std::move(num_groups_it) }
+        {
+        }
+
+        std::string description() const
+        {
+            std::stringstream description;
+            description << "In=" << *_src_it << ":";
+            description << "ConvolvedWidth=" << *_convolved_width_it << ":";
+            description << "ConvolvedHeight=" << *_convolved_height_it << ":";
+            description << "NumGroups=" << *_num_groups_it;
+            return description.str();
+        }
+
+        Col2ImLayerDataset::type operator*() const
+        {
+            return std::make_tuple(*_src_it, *_convolved_width_it, *_convolved_height_it, *_num_groups_it);
+        }
+
+        iterator &operator++()
+        {
+            ++_src_it;
+            ++_convolved_width_it;
+            ++_convolved_height_it;
+            ++_num_groups_it;
+
+            return *this;
+        }
+
+    private:
+        std::vector<TensorShape>::const_iterator  _src_it;
+        std::vector<unsigned int>::const_iterator _convolved_width_it;
+        std::vector<unsigned int>::const_iterator _convolved_height_it;
+        std::vector<unsigned int>::const_iterator _num_groups_it;
+    };
+
+    iterator begin() const
+    {
+        return iterator(_src_shapes.begin(), _convolved_widths.begin(), _convolved_heights.begin(), _num_groups.begin());
+    }
+
+    int size() const
+    {
+        return std::min(_src_shapes.size(), std::min(_convolved_widths.size(), std::min(_convolved_heights.size(), _num_groups.size())));
+    }
+
+    void add_config(TensorShape src, unsigned int convolved_width, unsigned int convolved_height, unsigned int info)
+    {
+        _src_shapes.emplace_back(std::move(src));
+        _convolved_widths.emplace_back(std::move(convolved_width));
+        _convolved_heights.emplace_back(std::move(convolved_height));
+        _num_groups.emplace_back(std::move(info));
+    }
+
+protected:
+    Col2ImLayerDataset()                      = default;
+    Col2ImLayerDataset(Col2ImLayerDataset &&) = default;
+
+private:
+    std::vector<TensorShape>  _src_shapes{};
+    std::vector<unsigned int> _convolved_widths{};
+    std::vector<unsigned int> _convolved_heights{};
+    std::vector<unsigned int> _num_groups{};
+};
+
+/** Dataset containing small grouped col2im shapes. */
+class SmallGroupedCol2ImLayerDataset final : public Col2ImLayerDataset
+{
+public:
+    SmallGroupedCol2ImLayerDataset()
+    {
+        add_config(TensorShape(10U, 12U, 1U, 1U), 3U, 4U, 1U);
+        add_config(TensorShape(12U, 30U, 1U, 2U), 5U, 6U, 1U);
+        add_config(TensorShape(12U, 30U, 4U, 1U), 5U, 6U, 1U);
+        add_config(TensorShape(10U, 12U, 2U, 4U), 3U, 4U, 2U);
+        add_config(TensorShape(10U, 12U, 2U, 4U), 3U, 4U, 2U);
+        add_config(TensorShape(8U, 16U, 3U, 1U), 4U, 4U, 3U);
+        add_config(TensorShape(8U, 16U, 3U, 3U), 4U, 4U, 3U);
+        add_config(TensorShape(12U, 20U, 4U, 1U), 5U, 4U, 4U);
+        add_config(TensorShape(12U, 20U, 4U, 3U), 5U, 4U, 4U);
+    }
+};
+
+/** Dataset containing large grouped col2im shapes. */
+class LargeGroupedCol2ImLayerDataset final : public Col2ImLayerDataset
+{
+public:
+    LargeGroupedCol2ImLayerDataset()
+    {
+        add_config(TensorShape(233U, 280U, 1U, 55U), 14U, 20U, 1U);
+        add_config(TensorShape(333U, 280U, 1U, 77U), 14U, 20U, 1U);
+        add_config(TensorShape(333U, 280U, 77U, 1U), 14U, 20U, 1U);
+        add_config(TensorShape(120U, 300U, 8U, 3U), 20U, 15U, 8U);
+        add_config(TensorShape(233U, 300U, 8U, 3U), 20U, 15U, 8U);
+        add_config(TensorShape(333U, 280U, 12U, 5U), 20U, 14U, 12U);
+        add_config(TensorShape(177U, 300U, 12U, 5U), 15U, 20U, 12U);
+        add_config(TensorShape(450U, 400U, 16U, 5U), 20U, 20U, 16U);
+        add_config(TensorShape(220U, 400U, 16U, 5U), 20U, 20U, 16U);
+    }
+};
+} // namespace datasets
+} // namespace test
+} // namespace arm_compute
+#endif /* ARM_COMPUTE_TEST_COL2IM_DATASET */
diff --git a/tests/validation/CL/Col2Im.cpp b/tests/validation/CL/Col2Im.cpp
new file mode 100644
index 0000000000..6f1163c278
--- /dev/null
+++ b/tests/validation/CL/Col2Im.cpp
@@ -0,0 +1,126 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#include "arm_compute/core/CL/kernels/CLCol2ImKernel.h"
+#include "arm_compute/core/Types.h"
+#include "tests/CL/Helper.h"
+
+#include "tests/CL/CLAccessor.h"
+#include "tests/datasets/Col2ImLayerDataset.h"
+#include "tests/framework/Asserts.h"
+#include "tests/framework/Macros.h"
+#include "tests/framework/datasets/Datasets.h"
+#include "tests/validation/Validation.h"
+#include "tests/validation/fixtures/Col2ImFixture.h"
+
+namespace arm_compute
+{
+namespace test
+{
+namespace validation
+{
+TEST_SUITE(CL)
+TEST_SUITE(Col2Im)
+
+using CLCol2Im = CLSynthetizeFunction<CLCol2ImKernel>;
+
+// *INDENT-OFF*
+// clang-format off
+DATA_TEST_CASE(Validate, framework::DatasetMode::ALL, zip(zip(zip(zip(zip(
+               framework::dataset::make("InputInfo", { TensorInfo(TensorShape(10U, 12U, 1U, 2U), 1, DataType::S64),    // Unsupported data type
+                                                       TensorInfo(TensorShape(10U, 12U, 1U, 2U), 1, DataType::F32),    // Mismatching data type
+                                                       TensorInfo(TensorShape(10U, 12U, 1U, 2U), 1, DataType::F32),    // Invalid output shape
+                                                       TensorInfo(TensorShape(3U, 12U, 4U, 2U), 1, DataType::F32),
+                                                     }),
+               framework::dataset::make("OutputInfo",{ TensorInfo(TensorShape(3U, 4U, 10U, 2U), 1, DataType::F16),
+                                                       TensorInfo(TensorShape(3U, 4U, 10U, 2U), 1, DataType::F16),
+                                                       TensorInfo(TensorShape(3U, 3U, 10U, 2U), 1, DataType::F32),
+                                                       TensorInfo(TensorShape(3U, 4U, 12U, 2U), 1, DataType::F32),
+                                                     })),
+               framework::dataset::make("ConvolvedWidth", { 3, 3, 3, 3 })),
+               framework::dataset::make("ConvolvedHeight", { 4, 4, 4, 4 })),
+               framework::dataset::make("NumGroups", { 1, 1, 1, 4 })),
+               framework::dataset::make("Expected", { false, false, false, true })),
+               input_info, output_info, convolved_width, convolved_height, num_groups, expected)
+{
+    bool status = bool(CLCol2Im::validate(&input_info, &output_info, std::make_pair(convolved_width, convolved_height), num_groups));
+    ARM_COMPUTE_EXPECT(status == expected, framework::LogLevel::ERRORS);
+}
+// clang-format on
+// *INDENT-ON*
+
+template <typename T>
+using CLCol2ImFixture = Col2ImValidationFixture<CLTensor, CLAccessor, CLCol2Im, T>;
+
+TEST_SUITE(Float)
+TEST_SUITE(FP32)
+FIXTURE_DATA_TEST_CASE(RunSmall, CLCol2ImFixture<float>, framework::DatasetMode::PRECOMMIT, combine(datasets::SmallGroupedCol2ImLayerDataset(), framework::dataset::make("DataType", DataType::F32)))
+{
+    // Validate output
+    validate(CLAccessor(_target), _reference);
+}
+
+FIXTURE_DATA_TEST_CASE(RunLarge, CLCol2ImFixture<float>, framework::DatasetMode::NIGHTLY, combine(datasets::LargeGroupedCol2ImLayerDataset(), framework::dataset::make("DataType", DataType::F32)))
+{
+    // Validate output
+    validate(CLAccessor(_target), _reference);
+}
+TEST_SUITE_END()
+
+TEST_SUITE(FP16)
+FIXTURE_DATA_TEST_CASE(RunSmall, CLCol2ImFixture<half>, framework::DatasetMode::PRECOMMIT, combine(datasets::SmallGroupedCol2ImLayerDataset(), framework::dataset::make("DataType", DataType::F16)))
+{
+    // Validate output
+    validate(CLAccessor(_target), _reference);
+}
+
+FIXTURE_DATA_TEST_CASE(RunLarge, CLCol2ImFixture<half>, framework::DatasetMode::NIGHTLY, combine(datasets::LargeGroupedCol2ImLayerDataset(), framework::dataset::make("DataType", DataType::F16)))
+{
+    // Validate output
+    validate(CLAccessor(_target), _reference);
+}
+TEST_SUITE_END()
+
+TEST_SUITE_END()
+
+TEST_SUITE(QASYMM8)
+FIXTURE_DATA_TEST_CASE(RunSmall, CLCol2ImFixture<uint8_t>, framework::DatasetMode::PRECOMMIT, combine(datasets::SmallGroupedCol2ImLayerDataset(), framework::dataset::make("DataType",
+                                                                                                      DataType::QASYMM8)))
+{
+    // Validate output
+    validate(CLAccessor(_target), _reference);
+}
+
+FIXTURE_DATA_TEST_CASE(RunLarge, CLCol2ImFixture<uint8_t>, framework::DatasetMode::NIGHTLY, combine(datasets::LargeGroupedCol2ImLayerDataset(), framework::dataset::make("DataType",
+                                                                                                    DataType::QASYMM8)))
+{
+    // Validate output
+    validate(CLAccessor(_target), _reference);
+}
+TEST_SUITE_END()
+
+TEST_SUITE_END()
+TEST_SUITE_END()
+} // namespace validation
+} // namespace test
+} // namespace arm_compute
diff --git a/tests/validation/fixtures/Col2ImFixture.h b/tests/validation/fixtures/Col2ImFixture.h
new file mode 100644
index 0000000000..ddc78a5032
--- /dev/null
+++ b/tests/validation/fixtures/Col2ImFixture.h
@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef ARM_COMPUTE_TEST_COL2IM_FIXTURE
+#define ARM_COMPUTE_TEST_COL2IM_FIXTURE
+
+#include "arm_compute/core/Helpers.h"
+#include "arm_compute/core/TensorShape.h"
+#include "arm_compute/core/Types.h"
+#include "arm_compute/core/utils/misc/ShapeCalculator.h"
+#include "arm_compute/runtime/Tensor.h"
+#include "tests/AssetsLibrary.h"
+#include "tests/Globals.h"
+#include "tests/IAccessor.h"
+#include "tests/framework/Asserts.h"
+#include "tests/framework/Fixture.h"
+#include "tests/validation/reference/Col2Im.h"
+
+namespace arm_compute
+{
+namespace test
+{
+namespace validation
+{
+using namespace arm_compute::misc::shape_calculator;
+
+template <typename TensorType, typename AccessorType, typename FunctionType, typename T>
+class Col2ImValidationFixture : public framework::Fixture
+{
+public:
+    template <typename...>
+    void setup(TensorShape input_shape, const unsigned int convolved_width, unsigned int convolved_height, unsigned int num_groups, DataType data_type)
+    {
+        const std::pair<unsigned int, unsigned int> convolved_dims(convolved_width, convolved_height);
+
+        const TensorShape output_shape = compute_col2im_shape(TensorInfo(input_shape, 1, data_type), convolved_dims, num_groups);
+
+        _target    = compute_target(input_shape, output_shape, convolved_dims, num_groups, data_type);
+        _reference = compute_reference(input_shape, output_shape, num_groups, data_type);
+    }
+
+protected:
+    template <typename U>
+    void fill(U &&tensor, const int seed)
+    {
+        library->fill_tensor_uniform(tensor, seed);
+    }
+
+    TensorType compute_target(const TensorShape &input_shape, const TensorShape &output_shape, std::pair<unsigned int, unsigned int> convolved_dims, unsigned int num_groups, DataType data_type)
+    {
+        // Create tensors
+        TensorType src = create_tensor<TensorType>(input_shape, data_type);
+        TensorType dst = create_tensor<TensorType>(output_shape, data_type);
+
+        // Create and configure function
+        FunctionType col2im_func;
+        col2im_func.configure(&src, &dst, convolved_dims, num_groups);
+
+        ARM_COMPUTE_EXPECT(src.info()->is_resizable(), framework::LogLevel::ERRORS);
+        ARM_COMPUTE_EXPECT(dst.info()->is_resizable(), framework::LogLevel::ERRORS);
+
+        // Allocate tensors
+        src.allocator()->allocate();
+        dst.allocator()->allocate();
+
+        ARM_COMPUTE_EXPECT(!src.info()->is_resizable(), framework::LogLevel::ERRORS);
+        ARM_COMPUTE_EXPECT(!dst.info()->is_resizable(), framework::LogLevel::ERRORS);
+
+        // Fill tensors
+        fill(AccessorType(src), 0);
+
+        // Compute function
+        col2im_func.run();
+
+        return dst;
+    }
+
+    SimpleTensor<T> compute_reference(const TensorShape &input_shape, const TensorShape &output_shape, unsigned int num_groups, DataType data_type)
+    {
+        // Create reference
+        SimpleTensor<T> src{ input_shape, data_type };
+
+        // Fill reference
+        fill(src, 0);
+
+        return reference::col2im<T>(src, output_shape, num_groups);
+    }
+    TensorType      _target{};
+    SimpleTensor<T> _reference{};
+};
+} // namespace validation
+} // namespace test
+} // namespace arm_compute
+#endif /* ARM_COMPUTE_TEST_COL2IM_FIXTURE */
diff --git a/tests/validation/reference/Col2Im.cpp b/tests/validation/reference/Col2Im.cpp
new file mode 100644
index 0000000000..90e488f928
--- /dev/null
+++ b/tests/validation/reference/Col2Im.cpp
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#include "Col2Im.h"
+
+#include "tests/validation/Helpers.h"
+#include "tests/validation/reference/Utils.h"
+
+namespace arm_compute
+{
+namespace test
+{
+namespace validation
+{
+namespace reference
+{
+template <typename T>
+SimpleTensor<T> col2im(const SimpleTensor<T> &src, const TensorShape &dst_shape, unsigned int num_groups)
+{
+    SimpleTensor<T> dst{ dst_shape, src.data_type(), 1 };
+
+    // Compute reference
+    const size_t batches    = dst_shape[3];
+    const size_t src_width  = src.shape().x();
+    const size_t src_height = src.shape().y();
+
+    if(num_groups == 1)
+    {
+        // Batches are on the 3rd dimension of the input tensor
+        int dst_idx = 0;
+        for(size_t b = 0; b < batches; ++b)
+        {
+            for(size_t x = 0; x < src_width; ++x)
+            {
+                for(size_t y = 0; y < src_height; ++y)
+                {
+                    dst[dst_idx++] = src[coord2index(src.shape(), Coordinates(x, y, b))];
+                }
+            }
+        }
+    }
+    else
+    {
+        int dst_idx = 0;
+        for(size_t b = 0; b < batches; ++b)
+        {
+            for(size_t g = 0; g < num_groups; ++g)
+            {
+                for(size_t x = 0; x < src_width; ++x)
+                {
+                    for(size_t y = 0; y < src_height; ++y)
+                    {
+                        dst[dst_idx++] = src[coord2index(src.shape(), Coordinates(x, y, g, b))];
+                    }
+                }
+            }
+        }
+    }
+    return dst;
+}
+
+template SimpleTensor<float> col2im(const SimpleTensor<float> &src, const TensorShape &dst_shape, unsigned int num_groups);
+template SimpleTensor<half> col2im(const SimpleTensor<half> &src, const TensorShape &dst_shape, unsigned int num_groups);
+template SimpleTensor<uint8_t> col2im(const SimpleTensor<uint8_t> &src, const TensorShape &dst_shape, unsigned int num_groups);
+} // namespace reference
+} // namespace validation
+} // namespace test
+} // namespace arm_compute
diff --git a/tests/validation/reference/Col2Im.h b/tests/validation/reference/Col2Im.h
new file mode 100644
index 0000000000..608261035d
--- /dev/null
+++ b/tests/validation/reference/Col2Im.h
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_TEST_COL2IM_H__
+#define __ARM_COMPUTE_TEST_COL2IM_H__
+
+#include "tests/SimpleTensor.h"
+#include "tests/validation/Helpers.h"
+
+namespace arm_compute
+{
+namespace test
+{
+namespace validation
+{
+namespace reference
+{
+template <typename T>
+SimpleTensor<T> col2im(const SimpleTensor<T> &src, const TensorShape &dst_shape, unsigned int num_groups);
+} // namespace reference
+} // namespace validation
+} // namespace test
+} // namespace arm_compute
+#endif /* __ARM_COMPUTE_TEST_COL2IM_H__ */