std::string result = GetSoftmaxProfilerJson(backends);
std::string backend = "Ref";
+ std::string testName = "SoftmaxWorkload_Execute";
std::string changeLine31 = "\n},\n\"CopyMemGeneric_Execute\": {";
std::string changeLine39 = "us\"";
std::string changeLine40;
if (firstBackend == armnn::Compute::GpuAcc)
{
backend = "Cl";
+ testName = "SoftmaxUintWorkload_Execute";
changeLine31 = ",\n\"OpenClKernelTimer/: softmax_layer_max_shift_exp_sum_quantized_serial GWS[,,]\": {";
changeLine39 = R"(us"
},
else if (firstBackend == armnn::Compute::CpuAcc)
{
backend = "Neon";
+ testName = "SoftmaxUintWorkload_Execute";
changeLine31 = ",\n\"NeonKernelTimer/: NEFillBorderKernel\": {";
changeLine39 = R"(us"
},
],
"unit": "us"
},
-")" + backend + R"(SoftmaxUintWorkload_Execute": {
+")" + backend + testName + R"(": {
"raw": [
,
,
AddOutputToWorkload(invalidData, invalidInfo, outputTensorInfo, nullptr);
//Invalid argument exception is expected, because height != 1.
- BOOST_CHECK_THROW(RefSoftmaxFloat32Workload(invalidData, invalidInfo), armnn::InvalidArgumentException);
+ BOOST_CHECK_THROW(RefSoftmaxWorkload(invalidData, invalidInfo), armnn::InvalidArgumentException);
}
BOOST_AUTO_TEST_CASE(FullyConnectedQueueDescriptor_Validate_RequiredDataMissing)
std::unique_ptr<IWorkload> RefWorkloadFactory::CreateSoftmax(const SoftmaxQueueDescriptor& descriptor,
const WorkloadInfo& info) const
{
- return MakeWorkload<RefSoftmaxFloat32Workload, RefSoftmaxUint8Workload>(descriptor, info);
+ if (IsFloat16(info))
+ {
+ return MakeWorkload<NullWorkload, NullWorkload>(descriptor, info);
+ }
+ return std::make_unique<RefSoftmaxWorkload>(descriptor, info);
}
std::unique_ptr<IWorkload> RefWorkloadFactory::CreateSplitter(const SplitterQueueDescriptor& descriptor,
workloads/RefResizeBilinearFloat32Workload.cpp \
workloads/RefResizeBilinearUint8Workload.cpp \
workloads/RefRsqrtFloat32Workload.cpp \
- workloads/RefSoftmaxFloat32Workload.cpp \
- workloads/RefSoftmaxUint8Workload.cpp \
+ workloads/RefSoftmaxWorkload.cpp \
workloads/RefSpaceToBatchNdWorkload.cpp \
workloads/RefStridedSliceWorkload.cpp \
workloads/RefSplitterFloat32Workload.cpp \
BOOST_AUTO_TEST_CASE(CreateSoftmaxFloat32Workload)
{
- RefCreateSoftmaxWorkloadTest<RefSoftmaxFloat32Workload, armnn::DataType::Float32>();
+ RefCreateSoftmaxWorkloadTest<RefSoftmaxWorkload, armnn::DataType::Float32>();
}
-BOOST_AUTO_TEST_CASE(CreateSoftmaxUint8Workload)
+BOOST_AUTO_TEST_CASE(CreateSoftmaxQuantisedAsymm8Workload)
{
- RefCreateSoftmaxWorkloadTest<RefSoftmaxUint8Workload, armnn::DataType::QuantisedAsymm8>();
+ RefCreateSoftmaxWorkloadTest<RefSoftmaxWorkload, armnn::DataType::QuantisedAsymm8>();
}
template <typename SplitterWorkloadType, armnn::DataType DataType>
RefResizeBilinearUint8Workload.hpp
RefRsqrtFloat32Workload.cpp
RefRsqrtFloat32Workload.hpp
- RefSoftmaxFloat32Workload.cpp
- RefSoftmaxFloat32Workload.hpp
- RefSoftmaxUint8Workload.cpp
- RefSoftmaxUint8Workload.hpp
+ RefSoftmaxWorkload.cpp
+ RefSoftmaxWorkload.hpp
RefSpaceToBatchNdWorkload.cpp
RefSpaceToBatchNdWorkload.hpp
RefSplitterFloat32Workload.cpp
+++ /dev/null
-//
-// Copyright © 2017 Arm Ltd. All rights reserved.
-// SPDX-License-Identifier: MIT
-//
-
-#include "RefSoftmaxFloat32Workload.hpp"
-
-#include "RefWorkloadUtils.hpp"
-#include "Softmax.hpp"
-
-#include "Profiling.hpp"
-
-namespace armnn
-{
-
-void RefSoftmaxFloat32Workload::Execute() const
-{
- ARMNN_SCOPED_PROFILING_EVENT(Compute::CpuRef, "RefSoftmaxFloat32Workload_Execute");
-
- Softmax(GetInputTensorDataFloat(0, m_Data),
- GetOutputTensorDataFloat(0, m_Data),
- GetTensorInfo(m_Data.m_Inputs[0]),
- m_Data.m_Parameters.m_Beta);
-}
-
-} //namespace armnn
+++ /dev/null
-//
-// Copyright © 2017 Arm Ltd. All rights reserved.
-// SPDX-License-Identifier: MIT
-//
-
-#pragma once
-
-#include <backendsCommon/Workload.hpp>
-#include <backendsCommon/WorkloadData.hpp>
-
-namespace armnn
-{
-
-class RefSoftmaxFloat32Workload : public Float32Workload<SoftmaxQueueDescriptor>
-{
-public:
- using Float32Workload<SoftmaxQueueDescriptor>::Float32Workload;
- virtual void Execute() const override;
-};
-
-} //namespace armnn
+++ /dev/null
-//
-// Copyright © 2017 Arm Ltd. All rights reserved.
-// SPDX-License-Identifier: MIT
-//
-
-#include "RefSoftmaxUint8Workload.hpp"
-
-#include "RefWorkloadUtils.hpp"
-#include "Softmax.hpp"
-
-#include "Profiling.hpp"
-
-#include <vector>
-
-namespace armnn
-{
-
-void RefSoftmaxUint8Workload::Execute() const
-{
- ARMNN_SCOPED_PROFILING_EVENT(Compute::CpuRef, "RefSoftmaxUint8Workload_Execute");
-
- const TensorInfo& tensorInfo = GetTensorInfo(m_Data.m_Inputs[0]);
-
- auto dequant = Dequantize(GetInputTensorDataU8(0, m_Data), tensorInfo);
-
- std::vector<float> results(tensorInfo.GetNumElements());
-
- Softmax(dequant.data(),
- results.data(),
- tensorInfo,
- m_Data.m_Parameters.m_Beta);
-
- Quantize(GetOutputTensorDataU8(0, m_Data), results.data(), GetTensorInfo(m_Data.m_Outputs[0]));
-}
-
-} //namespace armnn
--- /dev/null
+//
+// Copyright © 2017 Arm Ltd. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#include "RefSoftmaxWorkload.hpp"
+
+#include "Decoders.hpp"
+#include "Encoders.hpp"
+#include "RefWorkloadUtils.hpp"
+#include "Softmax.hpp"
+
+#include "Profiling.hpp"
+
+#include <vector>
+
+namespace armnn
+{
+
+void RefSoftmaxWorkload::Execute() const
+{
+ ARMNN_SCOPED_PROFILING_EVENT(Compute::CpuRef, "RefSoftmaxWorkload_Execute");
+
+ const TensorInfo &inputTensorInfo = GetTensorInfo(m_Data.m_Inputs[0]);
+
+ std::unique_ptr<Decoder<float>> decoderPtr = MakeDecoder<float>(inputTensorInfo, m_Data.m_Inputs[0]->Map());
+ Decoder<float> &decoder = *decoderPtr;
+
+ const TensorInfo &outputTensorInfo = GetTensorInfo(m_Data.m_Outputs[0]);
+
+ std::unique_ptr<Encoder<float>> encoderPtr = MakeEncoder<float>(outputTensorInfo, m_Data.m_Outputs[0]->Map());
+ Encoder<float> &encoder = *encoderPtr;
+
+ Softmax(decoder,
+ encoder,
+ inputTensorInfo,
+ m_Data.m_Parameters.m_Beta);
+}
+} //namespace armnn
namespace armnn
{
-class RefSoftmaxUint8Workload : public Uint8Workload<SoftmaxQueueDescriptor>
+class RefSoftmaxWorkload : public BaseWorkload<SoftmaxQueueDescriptor>
{
public:
- using Uint8Workload<SoftmaxQueueDescriptor>::Uint8Workload;
+ using BaseWorkload<SoftmaxQueueDescriptor>::BaseWorkload;
virtual void Execute() const override;
};
#include "FullyConnected.hpp"
#include "Gather.hpp"
#include "RefFloorFloat32Workload.hpp"
-#include "RefSoftmaxFloat32Workload.hpp"
-#include "RefSoftmaxUint8Workload.hpp"
+#include "RefSoftmaxWorkload.hpp"
#include "RefResizeBilinearFloat32Workload.hpp"
#include "RefBatchNormalizationUint8Workload.hpp"
#include "ResizeBilinear.hpp"
{
/// Computes the softmax function on some inputs, into outputs, with a shape given by tensorInfo.
-void Softmax(const float* in, float* out, const TensorInfo& tensorInfo, float beta)
+void Softmax(Decoder<float>& in, Encoder<float>& out, const TensorInfo& inputTensorInfo, float beta)
{
- unsigned int numChannels = tensorInfo.GetShape()[1];
- for (unsigned int n = 0; n < tensorInfo.GetShape()[0]; n++)
+ unsigned int numChannels = inputTensorInfo.GetShape()[1];
+
+ for (unsigned int n = 0; n < inputTensorInfo.GetShape()[0]; n++)
{
// Find maximum channel.
- float max = in[n * numChannels];
+ in[n * numChannels];
+ float max = in.Get();
for (unsigned int c = 1; c < numChannels; c++)
{
- float val = in[n * numChannels + c];
+ in[n * numChannels + c];
+ float val = in.Get();
if (val > max)
{
max = val;
float sum = 0.0f;
for (unsigned int c = 0; c < numChannels; c++)
{
- float val = in[n * numChannels + c];
+ in[n * numChannels + c];
+ float val = in.Get();
exponentials[c] = expf((val - max) * beta);
sum += exponentials[c];
}
// Divide exponentials by sum to give outputs.
for (unsigned int c = 0; c < numChannels; c++)
{
- out[n * numChannels + c] = exponentials[c] / sum;
+ out[n * numChannels + c];
+ out.Set(exponentials[c] / sum);
}
}
}
#pragma once
+#include "BaseIterator.hpp"
#include <armnn/Tensor.hpp>
namespace armnn
{
/// Computes the softmax function on some inputs, into outputs, with a shape given by tensorInfo.
-void Softmax(const float* in, float* out, const TensorInfo& tensorInfo, float beta);
+void Softmax(Decoder<float>& in, Encoder<float>& out, const TensorInfo& inputTensorInfo, float beta);
} //namespace armnn