IVGCVSW-7883 Front end and reference implementation for TILE
Signed-off-by: Teresa Charlin <teresa.charlinreyes@arm.com>
Signed-off-by: Cian McGriskin <cian.mcgriskin@arm.com>
Change-Id: I0afb2403fee11c5c1e58ea65e2525e99594d8f2d
diff --git a/src/backends/reference/workloads/CMakeLists.txt b/src/backends/reference/workloads/CMakeLists.txt
index 28f6d2f..9372568 100644
--- a/src/backends/reference/workloads/CMakeLists.txt
+++ b/src/backends/reference/workloads/CMakeLists.txt
@@ -180,6 +180,8 @@
RefStackWorkload.hpp
RefStridedSliceWorkload.cpp
RefStridedSliceWorkload.hpp
+ RefTileWorkload.cpp
+ RefTileWorkload.hpp
RefTransposeConvolution2dWorkload.cpp
RefTransposeConvolution2dWorkload.hpp
RefTransposeWorkload.cpp
@@ -209,6 +211,8 @@
StridedSlice.cpp
StringMapping.cpp
StringMapping.hpp
+ Tile.cpp
+ Tile.hpp
TensorBufferArrayView.hpp
TransposeConvolution2d.cpp
TransposeConvolution2d.hpp
diff --git a/src/backends/reference/workloads/RefTileWorkload.cpp b/src/backends/reference/workloads/RefTileWorkload.cpp
new file mode 100644
index 0000000..9fa8c8c
--- /dev/null
+++ b/src/backends/reference/workloads/RefTileWorkload.cpp
@@ -0,0 +1,47 @@
+//
+// Copyright © 2023 Arm Ltd and Contributors. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#include "RefTileWorkload.hpp"
+#include "RefWorkloadUtils.hpp"
+#include "Tile.hpp"
+#include "Profiling.hpp"
+
+namespace armnn
+{
+
+ RefTileWorkload::RefTileWorkload(const TileQueueDescriptor& descriptor, const WorkloadInfo& info)
+ : RefBaseWorkload(descriptor, info)
+ {}
+
+ void RefTileWorkload::Execute() const
+ {
+ Execute(m_Data.m_Inputs, m_Data.m_Outputs);
+ }
+
+ void RefTileWorkload::ExecuteAsync(ExecutionData& executionData)
+ {
+ WorkingMemDescriptor* workingMemDescriptor = static_cast<WorkingMemDescriptor*>(executionData.m_Data);
+ Execute(workingMemDescriptor->m_Inputs, workingMemDescriptor->m_Outputs);
+ }
+
+ void RefTileWorkload::Execute(std::vector<ITensorHandle*> inputs, std::vector<ITensorHandle*> outputs) const
+ {
+ ARMNN_SCOPED_PROFILING_EVENT(Compute::CpuRef, "RefTileWorkload_Execute");
+
+ const TensorInfo& inputInfo = GetTensorInfo(inputs[0]);
+
+ std::unique_ptr<Decoder<float>> inputDecoder = MakeDecoder<float>(GetTensorInfo(inputs[0]),
+ inputs[0]->Map());
+
+ std::unique_ptr<Encoder<float>> outputEncoder = MakeEncoder<float>(GetTensorInfo(outputs[0]),
+ outputs[0]->Map());
+
+ Tile(m_Data.m_Parameters,
+ inputInfo,
+ *inputDecoder,
+ *outputEncoder);
+ }
+
+} // namespace armnn
\ No newline at end of file
diff --git a/src/backends/reference/workloads/RefTileWorkload.hpp b/src/backends/reference/workloads/RefTileWorkload.hpp
new file mode 100644
index 0000000..2fb8eab
--- /dev/null
+++ b/src/backends/reference/workloads/RefTileWorkload.hpp
@@ -0,0 +1,30 @@
+//
+// Copyright © 2023 Arm Ltd and Contributors. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#pragma once
+
+#include "RefBaseWorkload.hpp"
+#include <armnn/backends/WorkloadData.hpp>
+
+#include "Tile.hpp"
+
+namespace armnn
+{
+
+ class RefTileWorkload : public RefBaseWorkload<TileQueueDescriptor>
+ {
+ public:
+ explicit RefTileWorkload(const TileQueueDescriptor& descriptor,
+ const WorkloadInfo& info);
+
+ void Execute() const override;
+ void ExecuteAsync(ExecutionData& executionData) override;
+
+ private:
+ void Execute(std::vector<ITensorHandle*> inputs, std::vector<ITensorHandle*> outputs) const;
+
+ };
+
+} // namespace armnn
\ No newline at end of file
diff --git a/src/backends/reference/workloads/RefWorkloads.hpp b/src/backends/reference/workloads/RefWorkloads.hpp
index e15a7ca..a36eae5 100644
--- a/src/backends/reference/workloads/RefWorkloads.hpp
+++ b/src/backends/reference/workloads/RefWorkloads.hpp
@@ -62,6 +62,7 @@
#include "RefStackWorkload.hpp"
#include "RefStridedSliceWorkload.hpp"
#include "RefSpaceToDepthWorkload.hpp"
+#include "RefTileWorkload.hpp"
#include "RefTransposeConvolution2dWorkload.hpp"
#include "RefTransposeWorkload.hpp"
#include "RefUnidirectionalSequenceLstmWorkload.hpp"
diff --git a/src/backends/reference/workloads/Tile.cpp b/src/backends/reference/workloads/Tile.cpp
new file mode 100644
index 0000000..148c51d
--- /dev/null
+++ b/src/backends/reference/workloads/Tile.cpp
@@ -0,0 +1,102 @@
+//
+// Copyright © 2023 Arm Ltd and Contributors. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#include "Tile.hpp"
+#include "Encoders.hpp"
+#include <numeric>
+#include <armnn/backends/WorkloadData.hpp>
+#include <armnn/Logging.hpp>
+
+namespace armnn
+{
+
+// Converts a flatten index into a multi-dimensional coordinate.
+std::vector<uint32_t> IndexToCoordinates(std::vector<uint32_t>& shape, uint32_t index)
+{
+ std::vector<uint32_t> coordinates;
+ // Iterating through dimensions starting from the last dimension to the first
+ for (std::size_t i = shape.size() - 1; i < shape.size(); --i)
+ {
+ // Coordinate is found by getting the index and modulus it by the current dimension size
+ // shape of dimension = dimension size
+ coordinates.insert(coordinates.begin(), index % shape[i]);
+ // Pass the index to next iteration making index = index / size of the current dimension
+ index = index/shape[i];
+ }
+ return coordinates;
+}
+
+// Convert a multidimensional coordinate to a flattened index.
+uint32_t CoordinatesToIndex(TensorShape& shape, std::vector<uint32_t>& coordinates)
+{
+ uint32_t index = 0;
+ uint32_t base = 1;
+ uint32_t rank = shape.GetNumDimensions();
+ for (uint32_t i = rank; i > 0; --i)
+ {
+ index = index + coordinates[i - 1] * base;
+ base = base * shape[i - 1];
+ }
+ return index;
+}
+
+void Tile(const TileDescriptor& params,
+ const TensorInfo& inputInfo,
+ Decoder<float>& inputDecoder,
+ Encoder<float>& outputEncoder)
+{
+ // Input and output will always have same rank
+ uint32_t rank = inputInfo.GetNumDimensions();
+
+ TensorShape inputShape = inputInfo.GetShape();
+
+ std::vector<uint32_t> outputShape(rank);
+ for (uint32_t i = 0; i < rank; ++i)
+ {
+ outputShape[i] = inputShape[i] * params.m_Multiples[i];
+ }
+
+ // If all values of multiples are 1, then return the input
+ if ( std::adjacent_find( params.m_Multiples.begin(), params.m_Multiples.end(),
+ std::not_equal_to<>() ) == params.m_Multiples.end() && params.m_Multiples[0] == 1)
+ {
+ for (uint32_t idx = 0; idx < inputInfo.GetNumElements(); ++idx)
+ {
+ float inputValue = inputDecoder.Get();
+ ++inputDecoder;
+ outputEncoder.Set(inputValue);
+ ++outputEncoder;
+ }
+ return;
+ }
+
+ std::vector<float> inputData = inputDecoder.DecodeTensor(inputInfo.GetShape());
+ std::vector<float> outputData;
+ auto outputNumElements = inputData.size() * static_cast<uint32_t>(std::accumulate(begin(params.m_Multiples),
+ end(params.m_Multiples),
+ 1,
+ std::multiplies<>()));
+ outputData.reserve(outputNumElements);
+
+ for (uint32_t outputIndex = 0; outputIndex < outputNumElements; ++outputIndex)
+ {
+ std::vector<uint32_t> outputCoords = IndexToCoordinates(outputShape, outputIndex);
+
+ // Converting output coordinates to input coordinates using modulus
+ std::vector<uint32_t> inputCoordinates;
+ inputCoordinates.reserve(rank);
+ for (uint32_t i = 0; i < rank; ++i)
+ {
+ inputCoordinates.push_back(outputCoords[i] % inputShape[i]);
+ }
+
+ uint32_t inputIndex = CoordinatesToIndex(inputShape, inputCoordinates);
+
+ outputEncoder[outputIndex];
+ outputEncoder.Set(inputData[inputIndex]);
+ }
+}
+
+} // namespace armnn
\ No newline at end of file
diff --git a/src/backends/reference/workloads/Tile.hpp b/src/backends/reference/workloads/Tile.hpp
new file mode 100644
index 0000000..4e7ffc9
--- /dev/null
+++ b/src/backends/reference/workloads/Tile.hpp
@@ -0,0 +1,21 @@
+//
+// Copyright © 2023 Arm Ltd and Contributors. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#pragma once
+
+#include <armnn/Tensor.hpp>
+#include "Encoders.hpp"
+#include "Decoders.hpp"
+#include "armnn/Descriptors.hpp"
+
+namespace armnn
+{
+
+void Tile(const TileDescriptor& params,
+ const TensorInfo& inputInfo,
+ Decoder<float>& inputDecoder,
+ Encoder<float>& outputEncoder);
+
+} // namespace armnn
\ No newline at end of file