src/backends/reference/RefWorkloadFactory.cpp

   1 //
   2 // Copyright © 2017 Arm Ltd. All rights reserved.
   3 // SPDX-License-Identifier: MIT
   4 //
   5 #include <backendsCommon/CpuTensorHandle.hpp>
   6 #include <backendsCommon/MemCopyWorkload.hpp>
   7 #include <backendsCommon/MakeWorkloadHelper.hpp>
   8 #include "RefWorkloadFactory.hpp"
   9 #include "RefBackendId.hpp"
  10 #include "workloads/RefWorkloads.hpp"
  11 #include "Layer.hpp"
  12
  13 #include <boost/log/trivial.hpp>
  14
  15 namespace armnn
  16 {
  17
  18 namespace
  19 {
  20 static const BackendId s_Id{RefBackendId()};
  21 }
  22
  23 template <typename F32Workload, typename U8Workload, typename QueueDescriptorType>
  24 std::unique_ptr<IWorkload> RefWorkloadFactory::MakeWorkload(const QueueDescriptorType& descriptor,
  25     const WorkloadInfo& info) const
  26 {
  27     return armnn::MakeWorkloadHelper<NullWorkload, F32Workload, U8Workload>(descriptor, info);
  28 }
  29
  30 RefWorkloadFactory::RefWorkloadFactory()
  31 {
  32 }
  33
  34 const BackendId& RefWorkloadFactory::GetBackendId() const
  35 {
  36     return s_Id;
  37 }
  38
  39 bool RefWorkloadFactory::IsLayerSupported(const Layer& layer,
  40                                           Optional<DataType> dataType,
  41                                           std::string& outReasonIfUnsupported)
  42 {
  43     return IWorkloadFactory::IsLayerSupported(s_Id, layer, dataType, outReasonIfUnsupported);
  44 }
  45
  46 std::unique_ptr<ITensorHandle> RefWorkloadFactory::CreateTensorHandle(const TensorInfo& tensorInfo) const
  47 {
  48     return std::make_unique<ScopedCpuTensorHandle>(tensorInfo);
  49 }
  50
  51 std::unique_ptr<ITensorHandle> RefWorkloadFactory::CreateTensorHandle(const TensorInfo& tensorInfo,
  52                                                                       DataLayout dataLayout) const
  53 {
  54     return std::make_unique<ScopedCpuTensorHandle>(tensorInfo);
  55 }
  56
  57 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateInput(const InputQueueDescriptor& descriptor,
  58                                                            const WorkloadInfo& info) const
  59 {
  60     if (info.m_InputTensorInfos.empty() )
  61     {
  62         throw InvalidArgumentException("RefWorkloadFactory::CreateInput: Input cannot be zero length");
  63     }
  64     if (info.m_OutputTensorInfos.empty())
  65     {
  66         throw InvalidArgumentException("RefWorkloadFactory::CreateInput: Output cannot be zero length");
  67     }
  68
  69     if (info.m_InputTensorInfos[0].GetNumBytes() != info.m_OutputTensorInfos[0].GetNumBytes())
  70     {
  71         throw InvalidArgumentException("RefWorkloadFactory::CreateInput: data input and output differ in byte count.");
  72     }
  73
  74     return MakeWorkload<CopyMemGenericWorkload, CopyMemGenericWorkload>(descriptor, info);
  75 }
  76
  77 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateOutput(const OutputQueueDescriptor& descriptor,
  78                                                             const WorkloadInfo& info) const
  79 {
  80     if (info.m_InputTensorInfos.empty() )
  81     {
  82         throw InvalidArgumentException("RefWorkloadFactory::CreateOutput: Input cannot be zero length");
  83     }
  84     if (info.m_OutputTensorInfos.empty())
  85     {
  86         throw InvalidArgumentException("RefWorkloadFactory::CreateOutput: Output cannot be zero length");
  87     }
  88     if (info.m_InputTensorInfos[0].GetNumBytes() != info.m_OutputTensorInfos[0].GetNumBytes())
  89     {
  90         throw InvalidArgumentException("RefWorkloadFactory::CreateOutput: data input and output differ in byte count.");
  91     }
  92
  93     return MakeWorkload<CopyMemGenericWorkload, CopyMemGenericWorkload>(descriptor, info);
  94 }
  95
  96 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateActivation(const ActivationQueueDescriptor& descriptor,
  97                                                                 const WorkloadInfo&              info) const
  98 {
  99     return MakeWorkload<RefActivationFloat32Workload, RefActivationUint8Workload>(descriptor, info);
 100 }
 101
 102 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateSoftmax(const SoftmaxQueueDescriptor& descriptor,
 103                                                              const WorkloadInfo&           info) const
 104 {
 105     return MakeWorkload<RefSoftmaxFloat32Workload, RefSoftmaxUint8Workload>(descriptor, info);
 106 }
 107
 108 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateSplitter(const SplitterQueueDescriptor& descriptor,
 109                                                               const WorkloadInfo&            info) const
 110 {
 111     return MakeWorkload<RefSplitterFloat32Workload, RefSplitterUint8Workload>(descriptor, info);
 112 }
 113
 114 std::unique_ptr<armnn::IWorkload> RefWorkloadFactory::CreateMerger(const MergerQueueDescriptor& descriptor,
 115                                                                    const WorkloadInfo&          info) const
 116 {
 117     return MakeWorkload<RefMergerFloat32Workload, RefMergerUint8Workload>(descriptor, info);
 118 }
 119
 120 std::unique_ptr<armnn::IWorkload> RefWorkloadFactory::CreateFullyConnected(
 121     const FullyConnectedQueueDescriptor& descriptor, const WorkloadInfo& info) const
 122 {
 123     return MakeWorkload<RefFullyConnectedFloat32Workload, RefFullyConnectedUint8Workload>(descriptor, info);
 124 }
 125
 126 std::unique_ptr<armnn::IWorkload> RefWorkloadFactory::CreatePermute(const PermuteQueueDescriptor& descriptor,
 127                                                                     const WorkloadInfo&           info) const
 128 {
 129     return MakeWorkloadHelper<RefPermuteFloat16Workload, RefPermuteFloat32Workload, RefPermuteUint8Workload>
 130         (descriptor, info);
 131 }
 132
 133 std::unique_ptr<armnn::IWorkload> RefWorkloadFactory::CreatePooling2d(const Pooling2dQueueDescriptor& descriptor,
 134                                                                       const WorkloadInfo&           info) const
 135 {
 136     return MakeWorkload<RefPooling2dFloat32Workload, RefPooling2dUint8Workload>(descriptor, info);
 137 }
 138
 139 std::unique_ptr<armnn::IWorkload> RefWorkloadFactory::CreateConvolution2d(
 140     const Convolution2dQueueDescriptor& descriptor, const WorkloadInfo& info) const
 141 {
 142     return MakeWorkload<RefConvolution2dFloat32Workload, RefConvolution2dUint8Workload>(descriptor, info);
 143 }
 144
 145 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateDepthwiseConvolution2d(
 146     const DepthwiseConvolution2dQueueDescriptor& descriptor, const WorkloadInfo& info) const
 147 {
 148     return MakeWorkload<RefDepthwiseConvolution2dFloat32Workload,
 149         RefDepthwiseConvolution2dUint8Workload>(descriptor, info);
 150 }
 151
 152 std::unique_ptr<armnn::IWorkload> RefWorkloadFactory::CreateNormalization(
 153     const NormalizationQueueDescriptor& descriptor, const WorkloadInfo& info) const
 154 {
 155     return MakeWorkload<RefNormalizationFloat32Workload, NullWorkload>(descriptor, info);
 156 }
 157
 158 std::unique_ptr<armnn::IWorkload> RefWorkloadFactory::CreateAddition(const AdditionQueueDescriptor& descriptor,
 159                                                                      const WorkloadInfo&            info) const
 160 {
 161     return MakeWorkload<RefAdditionFloat32Workload, RefAdditionUint8Workload>(descriptor, info);
 162 }
 163
 164 std::unique_ptr<armnn::IWorkload> RefWorkloadFactory::CreateMultiplication(
 165     const MultiplicationQueueDescriptor& descriptor, const WorkloadInfo& info) const
 166 {
 167     return MakeWorkload<RefMultiplicationFloat32Workload, RefMultiplicationUint8Workload>(descriptor, info);
 168 }
 169
 170 std::unique_ptr<armnn::IWorkload> RefWorkloadFactory::CreateBatchNormalization(
 171     const BatchNormalizationQueueDescriptor& descriptor, const WorkloadInfo& info) const
 172 {
 173     return MakeWorkload<RefBatchNormalizationFloat32Workload, RefBatchNormalizationUint8Workload>(descriptor, info);
 174 }
 175
 176 std::unique_ptr<armnn::IWorkload> RefWorkloadFactory::CreateMemCopy(const MemCopyQueueDescriptor& descriptor,
 177                                                                     const WorkloadInfo&        info) const
 178 {
 179     if (descriptor.m_Inputs.empty())
 180     {
 181         throw InvalidArgumentException("RefWorkloadFactory: CreateMemCopy() expected an input tensor.");
 182     }
 183     return std::make_unique<CopyMemGenericWorkload>(descriptor, info);
 184 }
 185
 186 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateResizeBilinear(const ResizeBilinearQueueDescriptor& descriptor,
 187                                                                     const WorkloadInfo& info) const
 188 {
 189     return MakeWorkload<RefResizeBilinearFloat32Workload, RefResizeBilinearUint8Workload>(descriptor, info);
 190 }
 191
 192 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateFakeQuantization(
 193     const FakeQuantizationQueueDescriptor& descriptor,
 194     const WorkloadInfo& info) const
 195 {
 196     return MakeWorkload<RefFakeQuantizationFloat32Workload, NullWorkload>(descriptor, info);
 197 }
 198
 199 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateL2Normalization(const L2NormalizationQueueDescriptor& descriptor,
 200     const WorkloadInfo& info) const
 201 {
 202     return MakeWorkload<RefL2NormalizationFloat32Workload, NullWorkload>(descriptor, info);
 203 }
 204
 205 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateConstant(const ConstantQueueDescriptor& descriptor,
 206     const WorkloadInfo& info) const
 207 {
 208     return MakeWorkload<RefConstantFloat32Workload, RefConstantUint8Workload>(descriptor, info);
 209 }
 210
 211 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateReshape(const ReshapeQueueDescriptor& descriptor,
 212     const WorkloadInfo& info) const
 213 {
 214     return MakeWorkload<RefReshapeFloat32Workload, RefReshapeUint8Workload>(descriptor, info);
 215 }
 216
 217 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateSpaceToBatchNd(const SpaceToBatchNdQueueDescriptor& descriptor,
 218     const WorkloadInfo& info) const
 219 {
 220     return MakeWorkload<NullWorkload, NullWorkload>(descriptor, info);
 221 }
 222
 223 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateFloor(const FloorQueueDescriptor& descriptor,
 224                                                           const WorkloadInfo& info) const
 225 {
 226     return MakeWorkload<RefFloorFloat32Workload, NullWorkload>(descriptor, info);
 227 }
 228
 229 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateLstm(const LstmQueueDescriptor& descriptor,
 230     const WorkloadInfo& info) const
 231 {
 232     return MakeWorkload<RefLstmFloat32Workload, NullWorkload>(descriptor, info);
 233 }
 234
 235 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateConvertFp16ToFp32(
 236     const ConvertFp16ToFp32QueueDescriptor& descriptor,
 237     const WorkloadInfo& info) const
 238 {
 239     return std::make_unique<RefConvertFp16ToFp32Workload>(descriptor, info);
 240 }
 241
 242 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateConvertFp32ToFp16(
 243     const ConvertFp32ToFp16QueueDescriptor& descriptor,
 244     const WorkloadInfo& info) const
 245 {
 246     return std::make_unique<RefConvertFp32ToFp16Workload>(descriptor, info);
 247 }
 248
 249 std::unique_ptr<armnn::IWorkload> RefWorkloadFactory::CreateDivision(
 250     const DivisionQueueDescriptor& descriptor, const WorkloadInfo& info) const
 251 {
 252     return MakeWorkload<RefDivisionFloat32Workload, RefDivisionUint8Workload>(descriptor, info);
 253 }
 254
 255 std::unique_ptr<armnn::IWorkload> RefWorkloadFactory::CreateSubtraction(
 256     const SubtractionQueueDescriptor& descriptor, const WorkloadInfo& info) const
 257 {
 258     return MakeWorkload<RefSubtractionFloat32Workload, RefSubtractionUint8Workload>(descriptor, info);
 259 }
 260
 261 std::unique_ptr<armnn::IWorkload> RefWorkloadFactory::CreateMean(
 262     const MeanQueueDescriptor& descriptor, const WorkloadInfo& info) const
 263 {
 264     return MakeWorkload<RefMeanFloat32Workload, RefMeanUint8Workload>(descriptor, info);
 265 }
 266
 267 std::unique_ptr<IWorkload> RefWorkloadFactory::CreatePad(const PadQueueDescriptor& descriptor,
 268                                                  const WorkloadInfo& info) const
 269 {
 270     return MakeWorkload<RefPadFloat32Workload, RefPadUint8Workload>(descriptor, info);
 271 }
 272
 273
 274 } // namespace armnn