aboutsummaryrefslogtreecommitdiff
path: root/src/backends/reference
diff options
context:
space:
mode:
Diffstat (limited to 'src/backends/reference')
-rw-r--r--src/backends/reference/RefLayerSupport.cpp82
-rw-r--r--src/backends/reference/RefWorkloadFactory.cpp6
-rw-r--r--src/backends/reference/backend.mk3
-rw-r--r--src/backends/reference/test/RefLayerSupportTests.cpp25
-rw-r--r--src/backends/reference/test/RefLayerTests.cpp28
-rw-r--r--src/backends/reference/workloads/CMakeLists.txt6
-rw-r--r--src/backends/reference/workloads/Mean.cpp45
-rw-r--r--src/backends/reference/workloads/Mean.hpp5
-rw-r--r--src/backends/reference/workloads/RefMeanFloat32Workload.cpp35
-rw-r--r--src/backends/reference/workloads/RefMeanFloat32Workload.hpp22
-rw-r--r--src/backends/reference/workloads/RefMeanUint8Workload.cpp39
-rw-r--r--src/backends/reference/workloads/RefMeanWorkload.cpp34
-rw-r--r--src/backends/reference/workloads/RefMeanWorkload.hpp (renamed from src/backends/reference/workloads/RefMeanUint8Workload.hpp)7
-rw-r--r--src/backends/reference/workloads/RefWorkloads.hpp3
14 files changed, 193 insertions, 147 deletions
diff --git a/src/backends/reference/RefLayerSupport.cpp b/src/backends/reference/RefLayerSupport.cpp
index cf1814e06a..402bd66f02 100644
--- a/src/backends/reference/RefLayerSupport.cpp
+++ b/src/backends/reference/RefLayerSupport.cpp
@@ -47,6 +47,21 @@ bool IsSupportedForDataTypeRef(Optional<std::string&> reasonIfUnsupported,
} // anonymous namespace
+namespace
+{
+
+std::string CreateIncorrectDimensionsErrorMsg(unsigned int expected,
+ unsigned int actual,
+ std::string& layerStr,
+ std::string& tensorName)
+{
+ std::string errorMsg = "Reference " + layerStr + ": Expected " + std::to_string(expected) + " dimensions but got" +
+ " " + std::to_string(actual) + " dimensions instead, for the '" + tensorName + "' tensor.";
+
+ return errorMsg;
+}
+
+} // anonymous namespace
namespace
{
@@ -177,6 +192,15 @@ struct ShapesAreBroadcastCompatible : public Rule
}
}
};
+
+struct TensorNumDimensionsAreCorrect : public Rule
+{
+ TensorNumDimensionsAreCorrect(const TensorInfo& info, unsigned int expectedNumDimensions)
+ {
+ m_Res = info.GetNumDimensions() == expectedNumDimensions;
+ }
+};
+
} // namespace
@@ -874,12 +898,58 @@ bool RefLayerSupport::IsMeanSupported(const TensorInfo& input,
const MeanDescriptor& descriptor,
Optional<std::string&> reasonIfUnsupported) const
{
- ignore_unused(output);
- ignore_unused(descriptor);
- return IsSupportedForDataTypeRef(reasonIfUnsupported,
- input.GetDataType(),
- &TrueFunc<>,
- &TrueFunc<>);
+ bool supported = true;
+ std::string meanLayerStr = "Mean";
+ std::string outputTensorStr = "output";
+
+ std::array<DataType,2> supportedTypes =
+ {
+ DataType::Float32,
+ DataType::QuantisedAsymm8
+ };
+
+ supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
+ "Reference Mean: input type not supported.");
+
+ supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
+ "Reference Mean: input and output types are mismatched");
+
+ if (descriptor.m_KeepDims)
+ {
+ supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(output, input.GetNumDimensions()),
+ reasonIfUnsupported,
+ CreateIncorrectDimensionsErrorMsg(input.GetNumDimensions(),
+ output.GetNumDimensions(),
+ meanLayerStr, outputTensorStr).data());
+ }
+ else if (descriptor.m_Axis.empty())
+ {
+ supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(output, 1),
+ reasonIfUnsupported,
+ CreateIncorrectDimensionsErrorMsg(1, output.GetNumDimensions(),
+ meanLayerStr, outputTensorStr).data());
+ }
+ else
+ {
+ auto outputDim = input.GetNumDimensions() - boost::numeric_cast<unsigned int>(descriptor.m_Axis.size());
+
+ if (outputDim > 0)
+ {
+ supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(output, outputDim),
+ reasonIfUnsupported,
+ CreateIncorrectDimensionsErrorMsg(outputDim, output.GetNumDimensions(),
+ meanLayerStr, outputTensorStr).data());
+ }
+ else
+ {
+ supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(output, 1),
+ reasonIfUnsupported,
+ CreateIncorrectDimensionsErrorMsg(1, output.GetNumDimensions(),
+ meanLayerStr, outputTensorStr).data());
+ }
+ }
+
+ return supported;
}
bool RefLayerSupport::IsMergerSupported(const std::vector<const TensorInfo*> inputs,
diff --git a/src/backends/reference/RefWorkloadFactory.cpp b/src/backends/reference/RefWorkloadFactory.cpp
index 728e60520a..4467bd4ad6 100644
--- a/src/backends/reference/RefWorkloadFactory.cpp
+++ b/src/backends/reference/RefWorkloadFactory.cpp
@@ -353,7 +353,11 @@ std::unique_ptr<armnn::IWorkload> RefWorkloadFactory::CreateMaximum(
std::unique_ptr<armnn::IWorkload> RefWorkloadFactory::CreateMean(
const MeanQueueDescriptor& descriptor, const WorkloadInfo& info) const
{
- return MakeWorkload<RefMeanFloat32Workload, RefMeanUint8Workload>(descriptor, info);
+ if (IsFloat16(info))
+ {
+ return MakeWorkload<NullWorkload, NullWorkload>(descriptor, info);
+ }
+ return std::make_unique<RefMeanWorkload>(descriptor, info);
}
std::unique_ptr<armnn::IWorkload> RefWorkloadFactory::CreateMinimum(
diff --git a/src/backends/reference/backend.mk b/src/backends/reference/backend.mk
index c4a0c76bdc..ecd281208a 100644
--- a/src/backends/reference/backend.mk
+++ b/src/backends/reference/backend.mk
@@ -45,8 +45,7 @@ BACKEND_SOURCES := \
workloads/RefGatherWorkload.cpp \
workloads/RefL2NormalizationWorkload.cpp \
workloads/RefLstmWorkload.cpp \
- workloads/RefMeanFloat32Workload.cpp \
- workloads/RefMeanUint8Workload.cpp \
+ workloads/RefMeanWorkload.cpp \
workloads/RefNormalizationWorkload.cpp \
workloads/RefPadWorkload.cpp \
workloads/RefPermuteWorkload.cpp \
diff --git a/src/backends/reference/test/RefLayerSupportTests.cpp b/src/backends/reference/test/RefLayerSupportTests.cpp
index 2c7e17da43..0d99b3e66f 100644
--- a/src/backends/reference/test/RefLayerSupportTests.cpp
+++ b/src/backends/reference/test/RefLayerSupportTests.cpp
@@ -14,6 +14,7 @@
#include <backendsCommon/test/IsLayerSupportedTestImpl.hpp>
#include <boost/test/unit_test.hpp>
+#include <boost/algorithm/string/trim.hpp>
#include <string>
@@ -130,4 +131,28 @@ BOOST_AUTO_TEST_CASE(IsConvertFp32ToFp16SupportedFp32OutputReference)
BOOST_CHECK_EQUAL(reasonIfUnsupported, "Layer is not supported with float32 data type output");
}
+BOOST_AUTO_TEST_CASE(IsLayerSupportedMeanDimensionsReference)
+{
+ std::string reasonIfUnsupported;
+
+ bool result = IsMeanLayerSupportedTests<armnn::RefWorkloadFactory,
+ armnn::DataType::Float32, armnn::DataType::Float32>(reasonIfUnsupported);
+
+ BOOST_CHECK(result);
+}
+
+BOOST_AUTO_TEST_CASE(IsLayerNotSupportedMeanDimensionsReference)
+{
+ std::string reasonIfUnsupported;
+
+ bool result = IsMeanLayerNotSupportedTests<armnn::RefWorkloadFactory,
+ armnn::DataType::Float32, armnn::DataType::Float32>(reasonIfUnsupported);
+
+ BOOST_CHECK(!result);
+
+ boost::algorithm::trim(reasonIfUnsupported);
+ BOOST_CHECK_EQUAL(reasonIfUnsupported,
+ "Reference Mean: Expected 4 dimensions but got 2 dimensions instead, for the 'output' tensor.");
+}
+
BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/backends/reference/test/RefLayerTests.cpp b/src/backends/reference/test/RefLayerTests.cpp
index 7ff6d1b269..c2cda8ec6b 100644
--- a/src/backends/reference/test/RefLayerTests.cpp
+++ b/src/backends/reference/test/RefLayerTests.cpp
@@ -607,19 +607,21 @@ ARMNN_AUTO_TEST_CASE(SimpleConvertFp16ToFp32, SimpleConvertFp16ToFp32Test)
ARMNN_AUTO_TEST_CASE(SimpleConvertFp32ToFp16, SimpleConvertFp32ToFp16Test)
// Mean
-ARMNN_AUTO_TEST_CASE(MeanUint8Simple, MeanUint8SimpleTest)
-ARMNN_AUTO_TEST_CASE(MeanUint8SimpleAxis, MeanUint8SimpleAxisTest)
-ARMNN_AUTO_TEST_CASE(MeanUint8KeepDims, MeanUint8KeepDimsTest)
-ARMNN_AUTO_TEST_CASE(MeanUint8MultipleDims, MeanUint8MultipleDimsTest)
-ARMNN_AUTO_TEST_CASE(MeanVtsUint8, MeanVtsUint8Test)
-
-ARMNN_AUTO_TEST_CASE(MeanFloatSimple, MeanFloatSimpleTest)
-ARMNN_AUTO_TEST_CASE(MeanFloatSimpleAxis, MeanFloatSimpleAxisTest)
-ARMNN_AUTO_TEST_CASE(MeanFloatKeepDims, MeanFloatKeepDimsTest)
-ARMNN_AUTO_TEST_CASE(MeanFloatMultipleDims, MeanFloatMultipleDimsTest)
-ARMNN_AUTO_TEST_CASE(MeanVtsFloat1, MeanVtsFloat1Test)
-ARMNN_AUTO_TEST_CASE(MeanVtsFloat2, MeanVtsFloat2Test)
-ARMNN_AUTO_TEST_CASE(MeanVtsFloat3, MeanVtsFloat3Test)
+ARMNN_AUTO_TEST_CASE(MeanSimpleFloat32, MeanSimpleTest<armnn::DataType::Float32>)
+ARMNN_AUTO_TEST_CASE(MeanSimpleAxisFloat32, MeanSimpleAxisTest<armnn::DataType::Float32>)
+ARMNN_AUTO_TEST_CASE(MeanKeepDimsFloat32, MeanKeepDimsTest<armnn::DataType::Float32>)
+ARMNN_AUTO_TEST_CASE(MeanMultipleDimsFloat32, MeanMultipleDimsTest<armnn::DataType::Float32>)
+ARMNN_AUTO_TEST_CASE(MeanVts1Float32, MeanVts1Test<armnn::DataType::Float32>)
+ARMNN_AUTO_TEST_CASE(MeanVts2Float32, MeanVts2Test<armnn::DataType::Float32>)
+ARMNN_AUTO_TEST_CASE(MeanVts3Float32, MeanVts3Test<armnn::DataType::Float32>)
+
+ARMNN_AUTO_TEST_CASE(MeanSimpleQuantisedAsymm8, MeanSimpleTest<armnn::DataType::QuantisedAsymm8>)
+ARMNN_AUTO_TEST_CASE(MeanSimpleAxisQuantisedAsymm8, MeanSimpleAxisTest<armnn::DataType::QuantisedAsymm8>)
+ARMNN_AUTO_TEST_CASE(MeanKeepDimsQuantisedAsymm8, MeanKeepDimsTest<armnn::DataType::QuantisedAsymm8>)
+ARMNN_AUTO_TEST_CASE(MeanMultipleDimsQuantisedAsymm8, MeanMultipleDimsTest<armnn::DataType::QuantisedAsymm8>)
+ARMNN_AUTO_TEST_CASE(MeanVts1QuantisedAsymm8, MeanVts1Test<armnn::DataType::QuantisedAsymm8>)
+ARMNN_AUTO_TEST_CASE(MeanVts2QuantisedAsymm8, MeanVts2Test<armnn::DataType::QuantisedAsymm8>)
+ARMNN_AUTO_TEST_CASE(MeanVts3QuantisedAsymm8, MeanVts3Test<armnn::DataType::QuantisedAsymm8>)
ARMNN_AUTO_TEST_CASE(AdditionAfterMaxPool, AdditionAfterMaxPoolTest)
diff --git a/src/backends/reference/workloads/CMakeLists.txt b/src/backends/reference/workloads/CMakeLists.txt
index ebd33901d3..1ab38ccbcb 100644
--- a/src/backends/reference/workloads/CMakeLists.txt
+++ b/src/backends/reference/workloads/CMakeLists.txt
@@ -119,10 +119,8 @@ list(APPEND armnnRefBackendWorkloads_sources
TensorBufferArrayView.hpp
Mean.cpp
Mean.hpp
- RefMeanFloat32Workload.cpp
- RefMeanFloat32Workload.hpp
- RefMeanUint8Workload.cpp
- RefMeanUint8Workload.hpp
+ RefMeanWorkload.cpp
+ RefMeanWorkload.hpp
)
add_library(armnnRefBackendWorkloads OBJECT ${armnnRefBackendWorkloads_sources})
diff --git a/src/backends/reference/workloads/Mean.cpp b/src/backends/reference/workloads/Mean.cpp
index 530aade611..3ac3af96a4 100644
--- a/src/backends/reference/workloads/Mean.cpp
+++ b/src/backends/reference/workloads/Mean.cpp
@@ -36,10 +36,13 @@ bool NextIndex(const unsigned int numDims, const armnn::TensorShape& dims, std::
return (carry == 0);
}
-std::size_t ReducedOutputOffset(const unsigned int numDims, const armnn::TensorShape& dims,
- std::vector<unsigned int>& index, const unsigned int numAxis,
- const std::vector<unsigned int>& axis) {
- std::size_t offset = 0;
+unsigned int ReducedOutputOffset(const unsigned int numDims,
+ const armnn::TensorShape& dims,
+ std::vector<unsigned int>& index,
+ const unsigned int numAxis,
+ const std::vector<unsigned int>& axis)
+{
+ unsigned int offset = 0;
for (unsigned int idx = 0; idx < numDims; ++idx)
{
bool isAxis = false;
@@ -56,7 +59,7 @@ std::size_t ReducedOutputOffset(const unsigned int numDims, const armnn::TensorS
}
if (!isAxis)
{
- offset = offset * boost::numeric_cast<size_t>(dims[idx]) + boost::numeric_cast<size_t>(index[idx]);
+ offset = offset * dims[idx] + index[idx];
}
}
return offset;
@@ -68,8 +71,9 @@ namespace armnn
void Mean(const armnn::TensorInfo& inputInfo,
const armnn::TensorInfo& outputInfo,
const std::vector<unsigned int>& axis,
- const float* inputData,
- float* outputData) {
+ Decoder<float>& input,
+ Encoder<float>& output)
+{
unsigned int inputNumDims = inputInfo.GetNumDimensions();
unsigned int outputNumDims = outputInfo.GetNumDimensions();
@@ -78,16 +82,17 @@ void Mean(const armnn::TensorInfo& inputInfo,
armnn::TensorShape inputDims = inputInfo.GetShape();
// Initialise output data.
- size_t numOutputs = 1;
+ unsigned int numOutputs = 1;
for (unsigned int idx = 0; idx < outputNumDims; ++idx)
{
- numOutputs *= boost::numeric_cast<size_t>(outputDims[idx]);
+ numOutputs *= outputDims[idx];
}
std::vector<float> tempSum(numOutputs);
- for (size_t idx = 0; idx < numOutputs; ++idx)
+ for (unsigned int idx = 0; idx < numOutputs; ++idx)
{
- outputData[idx] = 0.0f;
+ output[idx];
+ output.Set(0.0f);
tempSum[idx] = 0.0f;
}
@@ -106,30 +111,32 @@ void Mean(const armnn::TensorInfo& inputInfo,
resolvedAxis.push_back(idx);
}
}
- unsigned int numResolvedAxis = boost::numeric_cast<unsigned int>(resolvedAxis.size());
+ auto numResolvedAxis = boost::numeric_cast<unsigned int>(resolvedAxis.size());
// Iterates through input_data and sum up the reduced axis.
for (bool hasNext = true; hasNext; hasNext = NextIndex(inputNumDims, inputDims, tempIndex))
{
- size_t inputOffset = ReducedOutputOffset(inputNumDims, inputDims, tempIndex, 0, {});
- size_t outputOffset = ReducedOutputOffset(inputNumDims, inputDims, tempIndex,
- numResolvedAxis, resolvedAxis);
- tempSum[outputOffset] += inputData[inputOffset];
+ unsigned int inputOffset = ReducedOutputOffset(inputNumDims, inputDims, tempIndex, 0, {});
+ unsigned int outputOffset = ReducedOutputOffset(inputNumDims, inputDims, tempIndex,
+ numResolvedAxis, resolvedAxis);
+ input[inputOffset];
+ tempSum[outputOffset] += input.Get();
}
// Takes average by num of elements added to get mean.
size_t numElementsInAxis = 1;
for (unsigned int idx = 0; idx < numResolvedAxis; ++idx)
{
- size_t current = boost::numeric_cast<size_t>(inputDims[resolvedAxis[idx]]);
+ unsigned int current = inputDims[resolvedAxis[idx]];
BOOST_ASSERT(boost::numeric_cast<float>(current) <
(std::numeric_limits<float>::max() / boost::numeric_cast<float>(numElementsInAxis)));
numElementsInAxis *= current;
}
if (numElementsInAxis > 0) {
- for (size_t idx = 0; idx < numOutputs; ++idx)
+ for (unsigned int idx = 0; idx < numOutputs; ++idx)
{
- outputData[idx] = tempSum[idx] / boost::numeric_cast<float>(numElementsInAxis);
+ output[idx];
+ output.Set(tempSum[idx] / boost::numeric_cast<float>(numElementsInAxis));
}
}
}
diff --git a/src/backends/reference/workloads/Mean.hpp b/src/backends/reference/workloads/Mean.hpp
index 38c2e39653..dfb0302bf9 100644
--- a/src/backends/reference/workloads/Mean.hpp
+++ b/src/backends/reference/workloads/Mean.hpp
@@ -7,6 +7,7 @@
#include "armnn/DescriptorsFwd.hpp"
#include "armnn/Tensor.hpp"
+#include "BaseIterator.hpp"
#include <vector>
@@ -15,7 +16,7 @@ namespace armnn
void Mean(const TensorInfo& inputInfo,
const TensorInfo& outputInfo,
const std::vector<unsigned int>& axis,
- const float* inputData,
- float* outputData);
+ Decoder<float>& input,
+ Encoder<float>& output);
} //namespace armnn
diff --git a/src/backends/reference/workloads/RefMeanFloat32Workload.cpp b/src/backends/reference/workloads/RefMeanFloat32Workload.cpp
deleted file mode 100644
index a23906b8aa..0000000000
--- a/src/backends/reference/workloads/RefMeanFloat32Workload.cpp
+++ /dev/null
@@ -1,35 +0,0 @@
-//
-// Copyright © 2017 Arm Ltd. All rights reserved.
-// SPDX-License-Identifier: MIT
-//
-
-#include "RefMeanFloat32Workload.hpp"
-
-#include "Mean.hpp"
-#include "RefWorkloadUtils.hpp"
-
-#include "Profiling.hpp"
-#include "vector"
-
-namespace armnn
-{
-
-RefMeanFloat32Workload::RefMeanFloat32Workload(const MeanQueueDescriptor& descriptor, const WorkloadInfo& info)
- :Float32Workload<MeanQueueDescriptor>(descriptor, info) {}
-
-
-void RefMeanFloat32Workload::Execute() const
-{
- ARMNN_SCOPED_PROFILING_EVENT(Compute::CpuRef, "RefMeanFloat32Workload_Execute");
-
- const TensorInfo& inputInfo = GetTensorInfo(m_Data.m_Inputs[0]);
- const TensorInfo& outputInfo = GetTensorInfo(m_Data.m_Outputs[0]);
- const float* inputData = GetInputTensorDataFloat(0, m_Data);
- float* outputData = GetOutputTensorDataFloat(0, m_Data);
-
- Mean(inputInfo, outputInfo, m_Data.m_Parameters.m_Axis, inputData, outputData);
-}
-
-} //namespace armnn
-
-
diff --git a/src/backends/reference/workloads/RefMeanFloat32Workload.hpp b/src/backends/reference/workloads/RefMeanFloat32Workload.hpp
deleted file mode 100644
index 153ebe161a..0000000000
--- a/src/backends/reference/workloads/RefMeanFloat32Workload.hpp
+++ /dev/null
@@ -1,22 +0,0 @@
-//
-// Copyright © 2017 Arm Ltd. All rights reserved.
-// SPDX-License-Identifier: MIT
-//
-
-#pragma once
-
-#include "backendsCommon/Workload.hpp"
-#include "backendsCommon/WorkloadData.hpp"
-
-namespace armnn
-{
-
-
-class RefMeanFloat32Workload : public Float32Workload<MeanQueueDescriptor>
-{
-public:
- explicit RefMeanFloat32Workload (const MeanQueueDescriptor& descriptor, const WorkloadInfo& info);
- virtual void Execute() const override;
-};
-
-}//namespace armnn
diff --git a/src/backends/reference/workloads/RefMeanUint8Workload.cpp b/src/backends/reference/workloads/RefMeanUint8Workload.cpp
deleted file mode 100644
index 4ebffcfd70..0000000000
--- a/src/backends/reference/workloads/RefMeanUint8Workload.cpp
+++ /dev/null
@@ -1,39 +0,0 @@
-//
-// Copyright © 2017 Arm Ltd. All rights reserved.
-// SPDX-License-Identifier: MIT
-//
-
-#include "RefMeanUint8Workload.hpp"
-
-#include "Mean.hpp"
-#include "RefWorkloadUtils.hpp"
-
-#include "Profiling.hpp"
-
-#include <vector>
-
-namespace armnn
-{
-
-RefMeanUint8Workload::RefMeanUint8Workload(const MeanQueueDescriptor& descriptor, const WorkloadInfo& info)
- :Uint8Workload<MeanQueueDescriptor>(descriptor, info) {}
-
-
-void RefMeanUint8Workload::Execute() const
-{
- ARMNN_SCOPED_PROFILING_EVENT(Compute::CpuRef, "RefMeanUint8Workload_Execute");
-
- const TensorInfo& inputInfo = GetTensorInfo(m_Data.m_Inputs[0]);
- const TensorInfo& outputInfo = GetTensorInfo(m_Data.m_Outputs[0]);
-
- auto dequant = Dequantize(GetInputTensorDataU8(0, m_Data), inputInfo);
-
- std::vector<float> results(outputInfo.GetNumElements());
-
- Mean(inputInfo, outputInfo, m_Data.m_Parameters.m_Axis, dequant.data(), results.data());
-
- Quantize(GetOutputTensorDataU8(0, m_Data), results.data(), outputInfo);
-}
-
-} //namespace armnn
-
diff --git a/src/backends/reference/workloads/RefMeanWorkload.cpp b/src/backends/reference/workloads/RefMeanWorkload.cpp
new file mode 100644
index 0000000000..375ab395be
--- /dev/null
+++ b/src/backends/reference/workloads/RefMeanWorkload.cpp
@@ -0,0 +1,34 @@
+//
+// Copyright © 2017 Arm Ltd. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#include "RefMeanWorkload.hpp"
+
+#include "Mean.hpp"
+#include "RefWorkloadUtils.hpp"
+
+#include "Profiling.hpp"
+
+#include <vector>
+
+namespace armnn
+{
+
+RefMeanWorkload::RefMeanWorkload(const MeanQueueDescriptor& descriptor, const WorkloadInfo& info)
+ :BaseWorkload<MeanQueueDescriptor>(descriptor, info) {}
+
+void RefMeanWorkload::Execute() const
+{
+ ARMNN_SCOPED_PROFILING_EVENT(Compute::CpuRef, "RefMeanWorkload_Execute");
+
+ const TensorInfo& inputInfo = GetTensorInfo(m_Data.m_Inputs[0]);
+ const TensorInfo& outputInfo = GetTensorInfo(m_Data.m_Outputs[0]);
+
+ auto inputDecoder = MakeDecoder<float>(inputInfo, m_Data.m_Inputs[0]->Map());
+ auto outputEncoder = MakeEncoder<float>(outputInfo, m_Data.m_Outputs[0]->Map());
+
+ Mean(inputInfo, outputInfo, m_Data.m_Parameters.m_Axis, *inputDecoder, *outputEncoder);
+}
+
+} //namespace armnn
diff --git a/src/backends/reference/workloads/RefMeanUint8Workload.hpp b/src/backends/reference/workloads/RefMeanWorkload.hpp
index f53b8a434a..eb4b407dbd 100644
--- a/src/backends/reference/workloads/RefMeanUint8Workload.hpp
+++ b/src/backends/reference/workloads/RefMeanWorkload.hpp
@@ -8,13 +8,16 @@
#include "backendsCommon/Workload.hpp"
#include "backendsCommon/WorkloadData.hpp"
+#include "Decoders.hpp"
+#include "Encoders.hpp"
+
namespace armnn
{
-class RefMeanUint8Workload : public Uint8Workload<MeanQueueDescriptor>
+class RefMeanWorkload : public BaseWorkload<MeanQueueDescriptor>
{
public:
- explicit RefMeanUint8Workload (const MeanQueueDescriptor& descriptor, const WorkloadInfo& info);
+ explicit RefMeanWorkload (const MeanQueueDescriptor& descriptor, const WorkloadInfo& info);
virtual void Execute() const override;
};
diff --git a/src/backends/reference/workloads/RefWorkloads.hpp b/src/backends/reference/workloads/RefWorkloads.hpp
index 7cfced484e..b14129146a 100644
--- a/src/backends/reference/workloads/RefWorkloads.hpp
+++ b/src/backends/reference/workloads/RefWorkloads.hpp
@@ -42,8 +42,7 @@
#include "RefLstmWorkload.hpp"
#include "RefConvertFp16ToFp32Workload.hpp"
#include "RefConvertFp32ToFp16Workload.hpp"
-#include "RefMeanUint8Workload.hpp"
-#include "RefMeanFloat32Workload.hpp"
+#include "RefMeanWorkload.hpp"
#include "RefPadWorkload.hpp"
#include "RefBatchToSpaceNdUint8Workload.hpp"
#include "RefBatchToSpaceNdFloat32Workload.hpp"
generated by cgit v1.2.1 (git 2.23.0) at 2024-06-06 14:53:08 +0000