From dca769b9673a1e197258f7b35637b2a17f1a9e8b Mon Sep 17 00:00:00 2001 From: James Conroy Date: Tue, 27 Apr 2021 17:13:27 +0100 Subject: IVGCVSW-5815 Generalise ConstCpuTensorHandle * Generalises ConstCpuTensorHandle and inherited classes by removing 'Cpu' from aliases. * New renamed classes: ConstTensorHandle, TensorHandle, ScopedTensorHandle, PassthroughTensorHandle, ConstPassthroughTensorHandle. Signed-off-by: James Conroy Change-Id: I1824e0e134202735fb77051f20a7252f161dfe16 --- include/armnn/backends/CMakeLists.txt | 1 + include/armnn/backends/CpuTensorHandleFwd.hpp | 3 + include/armnn/backends/TensorHandleFwd.hpp | 17 ++ src/armnn/Layer.cpp | 4 +- src/armnn/Layer.hpp | 4 +- src/armnn/LoadedNetwork.cpp | 14 +- src/armnn/Network.cpp | 140 +++++------ src/armnn/WorkingMemHandle.cpp | 2 +- src/armnn/layers/BatchNormalizationLayer.cpp | 2 +- src/armnn/layers/BatchNormalizationLayer.hpp | 10 +- src/armnn/layers/BatchToSpaceNdLayer.cpp | 2 +- src/armnn/layers/ConstantLayer.cpp | 2 +- src/armnn/layers/ConstantLayer.hpp | 4 +- src/armnn/layers/Convolution2dLayer.cpp | 2 +- src/armnn/layers/Convolution2dLayer.hpp | 6 +- src/armnn/layers/DepthwiseConvolution2dLayer.cpp | 2 +- src/armnn/layers/DepthwiseConvolution2dLayer.hpp | 6 +- src/armnn/layers/DetectionPostProcessLayer.cpp | 2 +- src/armnn/layers/DetectionPostProcessLayer.hpp | 4 +- src/armnn/layers/FullyConnectedLayer.cpp | 2 +- src/armnn/layers/FullyConnectedLayer.hpp | 6 +- src/armnn/layers/LstmLayer.cpp | 2 +- src/armnn/layers/LstmLayer.hpp | 44 ++-- src/armnn/layers/MeanLayer.cpp | 2 +- src/armnn/layers/PadLayer.cpp | 2 +- src/armnn/layers/PreluLayer.cpp | 2 +- src/armnn/layers/QLstmLayer.cpp | 2 +- src/armnn/layers/QLstmLayer.hpp | 44 ++-- src/armnn/layers/QuantizedLstmLayer.cpp | 2 +- src/armnn/layers/QuantizedLstmLayer.hpp | 26 +-- src/armnn/layers/TransposeConvolution2dLayer.cpp | 2 +- src/armnn/layers/TransposeConvolution2dLayer.hpp | 6 +- .../optimizations/AddBroadcastReshapeLayer.hpp | 4 +- src/armnn/optimizations/ConvertConstants.hpp | 18 +- .../optimizations/ConvertFp32NetworkToBf16.hpp | 2 +- src/armnn/optimizations/FuseBatchNorm.hpp | 4 +- src/armnn/test/CreateWorkload.hpp | 116 +++++----- src/armnn/test/GraphTests.cpp | 4 +- src/armnn/test/OptimizerTests.cpp | 56 ++--- src/armnn/test/ShapeInferenceTests.cpp | 84 +++---- src/armnn/test/SubgraphViewTests.cpp | 2 +- .../AddBroadcastReshapeLayerTests.cpp | 4 +- .../optimizations/ConvertConstantsBFloatTests.cpp | 4 +- .../ConvertConstantsFloatToHalfTests.cpp | 2 +- .../ConvertConstantsHalfToFloatTests.cpp | 2 +- .../Fp32NetworkToBf16ConverterTests.cpp | 8 +- src/backends/backendsCommon/CMakeLists.txt | 5 +- src/backends/backendsCommon/CpuTensorHandle.cpp | 141 ----------- src/backends/backendsCommon/CpuTensorHandle.hpp | 245 -------------------- src/backends/backendsCommon/CpuTensorHandleFwd.hpp | 9 - src/backends/backendsCommon/MemCopyWorkload.cpp | 2 +- src/backends/backendsCommon/MemCopyWorkload.hpp | 2 +- src/backends/backendsCommon/MemImportWorkload.cpp | 2 +- src/backends/backendsCommon/MemImportWorkload.hpp | 2 +- src/backends/backendsCommon/MemSyncWorkload.cpp | 2 +- src/backends/backendsCommon/MemSyncWorkload.hpp | 2 +- src/backends/backendsCommon/TensorHandle.cpp | 141 +++++++++++ src/backends/backendsCommon/TensorHandle.hpp | 257 +++++++++++++++++++++ src/backends/backendsCommon/WorkloadData.cpp | 2 +- src/backends/backendsCommon/WorkloadData.hpp | 142 ++++++------ src/backends/backendsCommon/WorkloadFactory.cpp | 2 +- src/backends/backendsCommon/WorkloadUtils.cpp | 4 +- src/backends/backendsCommon/WorkloadUtils.hpp | 6 +- src/backends/backendsCommon/common.mk | 2 +- .../backendsCommon/test/CommonTestUtils.hpp | 6 +- .../test/DefaultAsyncExecuteTest.cpp | 30 +-- .../backendsCommon/test/DynamicBackendTests.hpp | 4 +- .../test/IsLayerSupportedTestImpl.hpp | 106 ++++----- .../test/LayerReleaseConstantDataTest.cpp | 22 +- .../backendsCommon/test/WorkloadDataValidation.cpp | 58 ++--- .../test/layerTests/BatchNormalizationTestImpl.cpp | 26 +-- .../test/layerTests/ConstantTestImpl.cpp | 4 +- .../test/layerTests/Conv2dTestImpl.cpp | 46 ++-- .../layerTests/DetectionPostProcessTestImpl.hpp | 4 +- .../test/layerTests/FakeQuantizationTestImpl.cpp | 4 +- .../test/layerTests/FullyConnectedTestImpl.cpp | 6 +- .../layerTests/InstanceNormalizationTestImpl.cpp | 2 +- .../test/layerTests/LogSoftmaxTestImpl.cpp | 2 +- .../test/layerTests/LstmTestImpl.cpp | 244 +++++++++---------- .../test/layerTests/NormalizationTestImpl.cpp | 6 +- .../test/layerTests/SoftmaxTestImpl.cpp | 2 +- .../layerTests/TransposeConvolution2dTestImpl.cpp | 12 +- src/backends/cl/ClWorkloadFactory.cpp | 2 +- src/backends/cl/test/ClCreateWorkloadTests.cpp | 4 +- src/backends/cl/test/ClLayerSupportTests.cpp | 2 +- src/backends/cl/test/Fp16SupportTest.cpp | 2 +- src/backends/cl/test/OpenClTimerTest.cpp | 10 +- src/backends/cl/workloads/ClActivationWorkload.cpp | 2 +- src/backends/cl/workloads/ClAdditionWorkload.cpp | 2 +- src/backends/cl/workloads/ClArgMinMaxWorkload.cpp | 2 +- .../ClBatchNormalizationFloatWorkload.cpp | 2 +- .../cl/workloads/ClBatchToSpaceNdWorkload.cpp | 2 +- src/backends/cl/workloads/ClComparisonWorkload.cpp | 2 +- src/backends/cl/workloads/ClConcatWorkload.cpp | 2 +- src/backends/cl/workloads/ClConstantWorkload.cpp | 2 +- .../cl/workloads/ClConvolution2dWorkload.cpp | 2 +- .../workloads/ClDepthwiseConvolutionWorkload.cpp | 4 +- src/backends/cl/workloads/ClDequantizeWorkload.cpp | 2 +- src/backends/cl/workloads/ClDivisionWorkload.cpp | 2 +- .../cl/workloads/ClFullyConnectedWorkload.cpp | 2 +- .../workloads/ClL2NormalizationFloatWorkload.cpp | 2 +- src/backends/cl/workloads/ClLstmFloatWorkload.cpp | 2 +- src/backends/cl/workloads/ClMaximumWorkload.cpp | 2 +- src/backends/cl/workloads/ClMinimumWorkload.cpp | 2 +- .../cl/workloads/ClMultiplicationWorkload.cpp | 2 +- .../cl/workloads/ClNormalizationFloatWorkload.cpp | 2 +- src/backends/cl/workloads/ClPreluWorkload.cpp | 2 +- src/backends/cl/workloads/ClQuantizeWorkload.cpp | 2 +- .../cl/workloads/ClQuantizedLstmWorkload.cpp | 2 +- src/backends/cl/workloads/ClReshapeWorkload.cpp | 2 +- src/backends/cl/workloads/ClResizeWorkload.cpp | 2 +- .../cl/workloads/ClSpaceToBatchNdWorkload.cpp | 2 +- .../cl/workloads/ClSpaceToDepthWorkload.cpp | 2 +- src/backends/cl/workloads/ClSplitterWorkload.cpp | 2 +- src/backends/cl/workloads/ClStackWorkload.cpp | 2 +- .../cl/workloads/ClStridedSliceWorkload.cpp | 2 +- .../cl/workloads/ClSubtractionWorkload.cpp | 2 +- .../workloads/ClTransposeConvolution2dWorkload.cpp | 2 +- src/backends/cl/workloads/ClWorkloadUtils.hpp | 4 +- src/backends/neon/NeonWorkloadFactory.cpp | 2 +- src/backends/neon/test/NeonLayerSupportTests.cpp | 2 +- src/backends/neon/test/NeonTimerTest.cpp | 2 +- .../neon/workloads/NeonAdditionWorkload.cpp | 2 +- .../neon/workloads/NeonArgMinMaxWorkload.cpp | 2 +- .../workloads/NeonBatchNormalizationWorkload.cpp | 2 +- .../neon/workloads/NeonComparisonWorkload.cpp | 2 +- src/backends/neon/workloads/NeonConcatWorkload.cpp | 2 +- .../neon/workloads/NeonConstantWorkload.cpp | 2 +- .../neon/workloads/NeonConvolution2dWorkload.cpp | 2 +- .../workloads/NeonDepthwiseConvolutionWorkload.cpp | 4 +- .../neon/workloads/NeonDequantizeWorkload.cpp | 2 +- .../neon/workloads/NeonDivisionWorkload.cpp | 2 +- .../neon/workloads/NeonFullyConnectedWorkload.cpp | 2 +- .../NeonInstanceNormalizationWorkload.cpp | 2 +- .../neon/workloads/NeonMaximumWorkload.cpp | 2 +- .../neon/workloads/NeonMinimumWorkload.cpp | 2 +- .../neon/workloads/NeonQuantizedLstmWorkload.cpp | 2 +- src/backends/neon/workloads/NeonResizeWorkload.cpp | 2 +- .../neon/workloads/NeonSplitterWorkload.cpp | 2 +- src/backends/neon/workloads/NeonStackWorkload.cpp | 2 +- .../neon/workloads/NeonSubtractionWorkload.cpp | 2 +- .../NeonTransposeConvolution2dWorkload.cpp | 2 +- src/backends/neon/workloads/NeonWorkloadUtils.hpp | 4 +- src/backends/reference/RefTensorHandle.hpp | 2 +- src/backends/reference/RefWorkloadFactory.cpp | 2 +- .../reference/test/RefLayerSupportTests.cpp | 2 +- .../reference/test/RefTensorHandleTests.cpp | 4 +- src/backends/reference/workloads/LstmUtils.cpp | 6 +- src/backends/reference/workloads/LstmUtils.hpp | 4 +- .../workloads/RefBatchNormalizationWorkload.cpp | 8 +- .../workloads/RefBatchNormalizationWorkload.hpp | 8 +- .../workloads/RefConvolution2dWorkload.cpp | 4 +- .../workloads/RefConvolution2dWorkload.hpp | 4 +- .../RefDepthwiseConvolution2dWorkload.cpp | 4 +- .../RefDepthwiseConvolution2dWorkload.hpp | 4 +- .../workloads/RefDetectionPostProcessWorkload.cpp | 2 +- .../workloads/RefDetectionPostProcessWorkload.hpp | 2 +- .../workloads/RefFullyConnectedWorkload.cpp | 4 +- .../workloads/RefFullyConnectedWorkload.hpp | 4 +- .../reference/workloads/RefLstmWorkload.cpp | 42 ++-- .../reference/workloads/RefLstmWorkload.hpp | 42 ++-- .../reference/workloads/RefQLstmWorkload.cpp | 52 ++--- .../reference/workloads/RefQLstmWorkload.hpp | 52 ++--- .../RefTransposeConvolution2dWorkload.cpp | 4 +- .../RefTransposeConvolution2dWorkload.hpp | 6 +- .../reference/workloads/RefWorkloadUtils.hpp | 2 +- .../sample/SampleDynamicWorkloadFactory.cpp | 6 +- src/dynamic/sample/SampleTensorHandle.hpp | 2 +- 168 files changed, 1333 insertions(+), 1310 deletions(-) create mode 100644 include/armnn/backends/TensorHandleFwd.hpp delete mode 100644 src/backends/backendsCommon/CpuTensorHandle.cpp delete mode 100644 src/backends/backendsCommon/CpuTensorHandle.hpp delete mode 100644 src/backends/backendsCommon/CpuTensorHandleFwd.hpp create mode 100644 src/backends/backendsCommon/TensorHandle.cpp create mode 100644 src/backends/backendsCommon/TensorHandle.hpp diff --git a/include/armnn/backends/CMakeLists.txt b/include/armnn/backends/CMakeLists.txt index 94e757fe8a..58d0abf872 100644 --- a/include/armnn/backends/CMakeLists.txt +++ b/include/armnn/backends/CMakeLists.txt @@ -5,6 +5,7 @@ list(APPEND armnnBackendsAPI_sources CpuTensorHandleFwd.hpp + TensorHandleFwd.hpp DynamicBackend.hpp IBackendInternal.hpp IBackendContext.hpp diff --git a/include/armnn/backends/CpuTensorHandleFwd.hpp b/include/armnn/backends/CpuTensorHandleFwd.hpp index c4b58a2bb2..a5a28d8135 100644 --- a/include/armnn/backends/CpuTensorHandleFwd.hpp +++ b/include/armnn/backends/CpuTensorHandleFwd.hpp @@ -3,6 +3,9 @@ // SPDX-License-Identifier: MIT // +// This file is deprecated and will be removed soon. +// Please use the new file include/armnn/TensorHandleFwd.hpp instead. + #pragma once namespace armnn diff --git a/include/armnn/backends/TensorHandleFwd.hpp b/include/armnn/backends/TensorHandleFwd.hpp new file mode 100644 index 0000000000..9faa499932 --- /dev/null +++ b/include/armnn/backends/TensorHandleFwd.hpp @@ -0,0 +1,17 @@ +// +// Copyright © 2021 Arm Ltd and Contributors. All rights reserved. +// SPDX-License-Identifier: MIT +// + +#pragma once + +namespace armnn +{ + +class ConstTensorHandle; +class TensorHandle; +class ScopedTensorHandle; +class PassthroughTensorHandle; +class ConstPassthroughTensorHandle; + +} // namespace armnn diff --git a/src/armnn/Layer.cpp b/src/armnn/Layer.cpp index 782f1939b0..e0d988d8ea 100644 --- a/src/armnn/Layer.cpp +++ b/src/armnn/Layer.cpp @@ -7,8 +7,8 @@ #include "Graph.hpp" #include #include +#include #include -#include #include @@ -283,7 +283,7 @@ void Layer::CreateTensorHandles(const TensorHandleFactoryRegistry& registry, void Layer::ReleaseConstantData() { // Now free up the static data. - OperateOnConstantTensors([](std::shared_ptr& handle) + OperateOnConstantTensors([](std::shared_ptr& handle) { handle.reset(); }); diff --git a/src/armnn/Layer.hpp b/src/armnn/Layer.hpp index d43545c01f..76f9b41f4c 100644 --- a/src/armnn/Layer.hpp +++ b/src/armnn/Layer.hpp @@ -200,7 +200,7 @@ inline const IOutputSlot* InputSlot::GetConnection() const { return GetConnected inline IOutputSlot* InputSlot::GetConnection() { return GetConnectedOutputSlot(); } -class ScopedCpuTensorHandle; +class ScopedTensorHandle; // Base layer class @@ -391,7 +391,7 @@ protected: LayerType* CloneBase(Graph& graph, Params&& ... params) const; // Retrieve the Handles to the constants - using ConstantTensors = std::vector>>; + using ConstantTensors = std::vector>>; virtual ConstantTensors GetConstantTensorsByRef() {return ConstantTensors(); }; // "Blob" diff --git a/src/armnn/LoadedNetwork.cpp b/src/armnn/LoadedNetwork.cpp index 5c5a963212..46eb9883fb 100644 --- a/src/armnn/LoadedNetwork.cpp +++ b/src/armnn/LoadedNetwork.cpp @@ -16,7 +16,7 @@ #include #include -#include +#include #include #include #include @@ -484,7 +484,7 @@ public: auto inputTensor = inputTensorPair.second; std::unique_ptr tensorHandle = - std::make_unique(inputTensor.GetInfo(),inputTensor.GetMemoryArea()); + std::make_unique(inputTensor.GetInfo(),inputTensor.GetMemoryArea()); LayerBindingId layerId = inputTensorPair.first; m_InputTensorPins.emplace_back(std::move(tensorHandle), inputTensor.GetInfo(), layerId); @@ -495,7 +495,7 @@ public: auto outputTensor = outputTensorPair.second; std::unique_ptr tensorHandle = - std::make_unique(outputTensor.GetInfo(), outputTensor.GetMemoryArea()); + std::make_unique(outputTensor.GetInfo(), outputTensor.GetMemoryArea()); LayerBindingId layerId = outputTensorPair.first; m_OutputTensorPins.emplace_back(std::move(tensorHandle), outputTensor.GetInfo(), layerId); @@ -864,7 +864,7 @@ void LoadedNetwork::EnqueueInput(const BindableLayer& layer, { // This assumes a CPU Tensor handle std::unique_ptr tensorHandle = - std::make_unique(inputTensor.GetInfo(), + std::make_unique(inputTensor.GetInfo(), inputTensor.GetMemoryArea()); void* mem = tensorHandle->Map(false); @@ -884,7 +884,7 @@ void LoadedNetwork::EnqueueInput(const BindableLayer& layer, else { std::unique_ptr tensorHandle = - std::make_unique(inputTensor.GetInfo(), inputTensor.GetMemoryArea()); + std::make_unique(inputTensor.GetInfo(), inputTensor.GetMemoryArea()); auto copyFunc = [](void* dst, const void* src, size_t size) { @@ -928,7 +928,7 @@ void LoadedNetwork::EnqueueOutput(const BindableLayer& layer, const Tensor& outp if (CheckFlag(importFlags, MemorySource::Malloc)) { std::unique_ptr tensorHandle = - std::make_unique(outputTensor.GetInfo(), + std::make_unique(outputTensor.GetInfo(), outputTensor.GetMemoryArea()); void* mem = tensorHandle->Map(false); @@ -964,7 +964,7 @@ void LoadedNetwork::EnqueueOutput(const BindableLayer& layer, const Tensor& outp }; std::unique_ptr tensorHandle = - std::make_unique(outputTensor.GetInfo(), + std::make_unique(outputTensor.GetInfo(), outputTensor.GetMemoryArea()); CopyTensorContentsGeneric(inputTensorHandle, tensorHandle.get(), copyFunc); diff --git a/src/armnn/Network.cpp b/src/armnn/Network.cpp index c99690e4a6..b79576c87e 100644 --- a/src/armnn/Network.cpp +++ b/src/armnn/Network.cpp @@ -12,7 +12,7 @@ #include "BackendSettings.hpp" #include "optimizations/All.hpp" -#include +#include #include #include #include @@ -671,7 +671,7 @@ LayerT* ConvertBf16ToFp32Weight(Layer* l) TensorInfo newInfo(info.GetShape(), DataType::Float32); ConstTensor newInput(newInfo, newValues); - layer->m_Weight.reset(new ScopedCpuTensorHandle(newInput)); + layer->m_Weight.reset(new ScopedTensorHandle(newInput)); } } return layer; @@ -1752,10 +1752,10 @@ IConnectableLayer* NetworkImpl::AddFullyConnectedLayerImpl(const FullyConnectedD if (fullyConnectedDescriptor.m_ConstantWeights) { - layer->m_Weight = std::make_shared(weights.value()); + layer->m_Weight = std::make_shared(weights.value()); if (fullyConnectedDescriptor.m_BiasEnabled) { - layer->m_Bias = std::make_shared(biases.value()); + layer->m_Bias = std::make_shared(biases.value()); } } @@ -1816,11 +1816,11 @@ IConnectableLayer* NetworkImpl::AddConvolution2dLayerImpl(const Convolution2dDes const auto layer = m_Graph->AddLayer(convolution2dDescriptor, name); - layer->m_Weight = std::make_shared(weights); + layer->m_Weight = std::make_shared(weights); if (convolution2dDescriptor.m_BiasEnabled) { - layer->m_Bias = std::make_shared(biases.value()); + layer->m_Bias = std::make_shared(biases.value()); } return layer; @@ -1864,11 +1864,11 @@ IConnectableLayer* NetworkImpl::AddDepthwiseConvolution2dLayerImpl( const auto layer = m_Graph->AddLayer(convolution2dDescriptor, name); - layer->m_Weight = std::make_shared(weights); + layer->m_Weight = std::make_shared(weights); if (convolution2dDescriptor.m_BiasEnabled) { - layer->m_Bias = std::make_shared(biases.value()); + layer->m_Bias = std::make_shared(biases.value()); } return layer; @@ -1913,7 +1913,7 @@ IConnectableLayer* NetworkImpl::AddDetectionPostProcessLayer(const armnn::Detect { const auto layer = m_Graph->AddLayer(descriptor, name); - layer->m_Anchors = std::make_shared(anchors); + layer->m_Anchors = std::make_shared(anchors); return layer; } @@ -2011,10 +2011,10 @@ IConnectableLayer* NetworkImpl::AddBatchNormalizationLayer(const BatchNormalizat { const auto layer = m_Graph->AddLayer(desc, name); - layer->m_Mean = std::make_shared(mean); - layer->m_Variance = std::make_shared(variance); - layer->m_Beta = std::make_shared(beta); - layer->m_Gamma = std::make_shared(gamma); + layer->m_Mean = std::make_shared(mean); + layer->m_Variance = std::make_shared(variance); + layer->m_Beta = std::make_shared(beta); + layer->m_Gamma = std::make_shared(gamma); return layer; } @@ -2071,7 +2071,7 @@ IConnectableLayer* NetworkImpl::AddConstantLayer(const ConstTensor& input, const { auto layer = m_Graph->AddLayer(name); - layer->m_LayerOutput = std::make_shared(input); + layer->m_LayerOutput = std::make_shared(input); return layer; } @@ -2107,23 +2107,23 @@ IConnectableLayer* NetworkImpl::AddLstmLayer(const LstmDescriptor& descriptor, //Lstm Basic Parameters layer->m_BasicParameters.m_InputToForgetWeights = - std::make_shared(*(params.m_InputToForgetWeights)); + std::make_shared(*(params.m_InputToForgetWeights)); layer->m_BasicParameters.m_InputToCellWeights = - std::make_shared(*(params.m_InputToCellWeights)); + std::make_shared(*(params.m_InputToCellWeights)); layer->m_BasicParameters.m_InputToOutputWeights = - std::make_shared(*(params.m_InputToOutputWeights)); + std::make_shared(*(params.m_InputToOutputWeights)); layer->m_BasicParameters.m_RecurrentToForgetWeights = - std::make_shared(*(params.m_RecurrentToForgetWeights)); + std::make_shared(*(params.m_RecurrentToForgetWeights)); layer->m_BasicParameters.m_RecurrentToCellWeights = - std::make_shared(*(params.m_RecurrentToCellWeights)); + std::make_shared(*(params.m_RecurrentToCellWeights)); layer->m_BasicParameters.m_RecurrentToOutputWeights = - std::make_shared(*(params.m_RecurrentToOutputWeights)); + std::make_shared(*(params.m_RecurrentToOutputWeights)); layer->m_BasicParameters.m_ForgetGateBias = - std::make_shared(*(params.m_ForgetGateBias)); + std::make_shared(*(params.m_ForgetGateBias)); layer->m_BasicParameters.m_CellBias = - std::make_shared(*(params.m_CellBias)); + std::make_shared(*(params.m_CellBias)); layer->m_BasicParameters.m_OutputGateBias = - std::make_shared(*(params.m_OutputGateBias)); + std::make_shared(*(params.m_OutputGateBias)); //Lstm Cifg parameters if(!descriptor.m_CifgEnabled) @@ -2145,11 +2145,11 @@ IConnectableLayer* NetworkImpl::AddLstmLayer(const LstmDescriptor& descriptor, "when CIFG is disabled."); } layer->m_CifgParameters.m_InputToInputWeights = - std::make_shared(*(params.m_InputToInputWeights)); + std::make_shared(*(params.m_InputToInputWeights)); layer->m_CifgParameters.m_RecurrentToInputWeights = - std::make_shared(*(params.m_RecurrentToInputWeights)); + std::make_shared(*(params.m_RecurrentToInputWeights)); layer->m_CifgParameters.m_InputGateBias = - std::make_shared(*(params.m_InputGateBias)); + std::make_shared(*(params.m_InputGateBias)); } //Lstm projection parameters @@ -2161,11 +2161,11 @@ IConnectableLayer* NetworkImpl::AddLstmLayer(const LstmDescriptor& descriptor, "when projection is enabled."); } layer->m_ProjectionParameters.m_ProjectionWeights = - std::make_shared(*(params.m_ProjectionWeights)); + std::make_shared(*(params.m_ProjectionWeights)); if(params.m_ProjectionBias != nullptr) { layer->m_ProjectionParameters.m_ProjectionBias = - std::make_shared(*(params.m_ProjectionBias)); + std::make_shared(*(params.m_ProjectionBias)); } } @@ -2181,7 +2181,7 @@ IConnectableLayer* NetworkImpl::AddLstmLayer(const LstmDescriptor& descriptor, } layer->m_PeepholeParameters.m_CellToInputWeights = - std::make_shared(*(params.m_CellToInputWeights)); + std::make_shared(*(params.m_CellToInputWeights)); } if(params.m_CellToForgetWeights == nullptr) @@ -2196,9 +2196,9 @@ IConnectableLayer* NetworkImpl::AddLstmLayer(const LstmDescriptor& descriptor, } layer->m_PeepholeParameters.m_CellToForgetWeights = - std::make_shared(*(params.m_CellToForgetWeights)); + std::make_shared(*(params.m_CellToForgetWeights)); layer->m_PeepholeParameters.m_CellToOutputWeights = - std::make_shared(*(params.m_CellToOutputWeights)); + std::make_shared(*(params.m_CellToOutputWeights)); } //Lstm Layer Normalization params @@ -2212,7 +2212,7 @@ IConnectableLayer* NetworkImpl::AddLstmLayer(const LstmDescriptor& descriptor, "when layer normalization is enabled and CIFG disabled."); } layer->m_LayerNormParameters.m_InputLayerNormWeights = - std::make_shared(*(params.m_InputLayerNormWeights)); + std::make_shared(*(params.m_InputLayerNormWeights)); } if(params.m_ForgetLayerNormWeights == nullptr) @@ -2231,11 +2231,11 @@ IConnectableLayer* NetworkImpl::AddLstmLayer(const LstmDescriptor& descriptor, "when layer normalization is enabled."); } layer->m_LayerNormParameters.m_ForgetLayerNormWeights = - std::make_shared(*(params.m_ForgetLayerNormWeights)); + std::make_shared(*(params.m_ForgetLayerNormWeights)); layer->m_LayerNormParameters.m_CellLayerNormWeights = - std::make_shared(*(params.m_CellLayerNormWeights)); + std::make_shared(*(params.m_CellLayerNormWeights)); layer->m_LayerNormParameters.m_OutputLayerNormWeights = - std::make_shared(*(params.m_OutputLayerNormWeights)); + std::make_shared(*(params.m_OutputLayerNormWeights)); } return layer; } @@ -2330,11 +2330,11 @@ IConnectableLayer* NetworkImpl::AddTransposeConvolution2dLayer(const TransposeCo const auto layer = m_Graph->AddLayer(descriptor, name); - layer->m_Weight = std::make_shared(weights); + layer->m_Weight = std::make_shared(weights); if (descriptor.m_BiasEnabled) { - layer->m_Bias = std::make_shared(biases.value()); + layer->m_Bias = std::make_shared(biases.value()); } return layer; @@ -2366,33 +2366,33 @@ IConnectableLayer* NetworkImpl::AddQuantizedLstmLayer(const QuantizedLstmInputPa // InputToX weights layer->m_QuantizedLstmParameters.m_InputToInputWeights = - std::make_shared(params.GetInputToInputWeights()); + std::make_shared(params.GetInputToInputWeights()); layer->m_QuantizedLstmParameters.m_InputToForgetWeights = - std::make_shared(params.GetInputToForgetWeights()); + std::make_shared(params.GetInputToForgetWeights()); layer->m_QuantizedLstmParameters.m_InputToCellWeights = - std::make_shared(params.GetInputToCellWeights()); + std::make_shared(params.GetInputToCellWeights()); layer->m_QuantizedLstmParameters.m_InputToOutputWeights = - std::make_shared(params.GetInputToOutputWeights()); + std::make_shared(params.GetInputToOutputWeights()); // RecurrentToX weights layer->m_QuantizedLstmParameters.m_RecurrentToInputWeights = - std::make_shared(params.GetRecurrentToInputWeights()); + std::make_shared(params.GetRecurrentToInputWeights()); layer->m_QuantizedLstmParameters.m_RecurrentToForgetWeights = - std::make_shared(params.GetRecurrentToForgetWeights()); + std::make_shared(params.GetRecurrentToForgetWeights()); layer->m_QuantizedLstmParameters.m_RecurrentToCellWeights = - std::make_shared(params.GetRecurrentToCellWeights()); + std::make_shared(params.GetRecurrentToCellWeights()); layer->m_QuantizedLstmParameters.m_RecurrentToOutputWeights = - std::make_shared(params.GetRecurrentToOutputWeights()); + std::make_shared(params.GetRecurrentToOutputWeights()); // Bias layer->m_QuantizedLstmParameters.m_InputGateBias = - std::make_shared(params.GetInputGateBias()); + std::make_shared(params.GetInputGateBias()); layer->m_QuantizedLstmParameters.m_ForgetGateBias = - std::make_shared(params.GetForgetGateBias()); + std::make_shared(params.GetForgetGateBias()); layer->m_QuantizedLstmParameters.m_CellBias = - std::make_shared(params.GetCellBias()); + std::make_shared(params.GetCellBias()); layer->m_QuantizedLstmParameters.m_OutputGateBias = - std::make_shared(params.GetOutputGateBias()); + std::make_shared(params.GetOutputGateBias()); return layer; } @@ -2405,23 +2405,23 @@ IConnectableLayer* NetworkImpl::AddQLstmLayer(const QLstmDescriptor& descriptor // QLstm Basic Parameters layer->m_BasicParameters.m_InputToForgetWeights = - std::make_shared(*(params.m_InputToForgetWeights)); + std::make_shared(*(params.m_InputToForgetWeights)); layer->m_BasicParameters.m_InputToCellWeights = - std::make_shared(*(params.m_InputToCellWeights)); + std::make_shared(*(params.m_InputToCellWeights)); layer->m_BasicParameters.m_InputToOutputWeights = - std::make_shared(*(params.m_InputToOutputWeights)); + std::make_shared(*(params.m_InputToOutputWeights)); layer->m_BasicParameters.m_RecurrentToForgetWeights = - std::make_shared(*(params.m_RecurrentToForgetWeights)); + std::make_shared(*(params.m_RecurrentToForgetWeights)); layer->m_BasicParameters.m_RecurrentToCellWeights = - std::make_shared(*(params.m_RecurrentToCellWeights)); + std::make_shared(*(params.m_RecurrentToCellWeights)); layer->m_BasicParameters.m_RecurrentToOutputWeights = - std::make_shared(*(params.m_RecurrentToOutputWeights)); + std::make_shared(*(params.m_RecurrentToOutputWeights)); layer->m_BasicParameters.m_ForgetGateBias = - std::make_shared(*(params.m_ForgetGateBias)); + std::make_shared(*(params.m_ForgetGateBias)); layer->m_BasicParameters.m_CellBias = - std::make_shared(*(params.m_CellBias)); + std::make_shared(*(params.m_CellBias)); layer->m_BasicParameters.m_OutputGateBias = - std::make_shared(*(params.m_OutputGateBias)); + std::make_shared(*(params.m_OutputGateBias)); // QLstm Cifg parameters if(!descriptor.m_CifgEnabled) @@ -2443,11 +2443,11 @@ IConnectableLayer* NetworkImpl::AddQLstmLayer(const QLstmDescriptor& descriptor } layer->m_CifgParameters.m_InputToInputWeights = - std::make_shared(*(params.m_InputToInputWeights)); + std::make_shared(*(params.m_InputToInputWeights)); layer->m_CifgParameters.m_RecurrentToInputWeights = - std::make_shared(*(params.m_RecurrentToInputWeights)); + std::make_shared(*(params.m_RecurrentToInputWeights)); layer->m_CifgParameters.m_InputGateBias = - std::make_shared(*(params.m_InputGateBias)); + std::make_shared(*(params.m_InputGateBias)); } // QLstm Projection parameters @@ -2459,13 +2459,13 @@ IConnectableLayer* NetworkImpl::AddQLstmLayer(const QLstmDescriptor& descriptor } layer->m_ProjectionParameters.m_ProjectionWeights = - std::make_shared(*(params.m_ProjectionWeights)); + std::make_shared(*(params.m_ProjectionWeights)); // Projection bias is optional even if projection is enabled if(params.m_ProjectionWeights != nullptr) { layer->m_ProjectionParameters.m_ProjectionBias = - std::make_shared(*(params.m_ProjectionBias)); + std::make_shared(*(params.m_ProjectionBias)); } } @@ -2491,13 +2491,13 @@ IConnectableLayer* NetworkImpl::AddQLstmLayer(const QLstmDescriptor& descriptor } layer->m_PeepholeParameters.m_CellToInputWeights = - std::make_shared(*(params.m_CellToInputWeights)); + std::make_shared(*(params.m_CellToInputWeights)); } layer->m_PeepholeParameters.m_CellToForgetWeights = - std::make_shared(*(params.m_CellToForgetWeights)); + std::make_shared(*(params.m_CellToForgetWeights)); layer->m_PeepholeParameters.m_CellToOutputWeights = - std::make_shared(*(params.m_CellToOutputWeights)); + std::make_shared(*(params.m_CellToOutputWeights)); } // QLstm Layer Normalization params @@ -2526,15 +2526,15 @@ IConnectableLayer* NetworkImpl::AddQLstmLayer(const QLstmDescriptor& descriptor } layer->m_LayerNormParameters.m_InputLayerNormWeights = - std::make_shared(*(params.m_InputLayerNormWeights)); + std::make_shared(*(params.m_InputLayerNormWeights)); } layer->m_LayerNormParameters.m_ForgetLayerNormWeights = - std::make_shared(*(params.m_ForgetLayerNormWeights)); + std::make_shared(*(params.m_ForgetLayerNormWeights)); layer->m_LayerNormParameters.m_CellLayerNormWeights = - std::make_shared(*(params.m_CellLayerNormWeights)); + std::make_shared(*(params.m_CellLayerNormWeights)); layer->m_LayerNormParameters.m_OutputLayerNormWeights = - std::make_shared(*(params.m_OutputLayerNormWeights)); + std::make_shared(*(params.m_OutputLayerNormWeights)); } return layer; } diff --git a/src/armnn/WorkingMemHandle.cpp b/src/armnn/WorkingMemHandle.cpp index b54c5baddd..94d796eced 100644 --- a/src/armnn/WorkingMemHandle.cpp +++ b/src/armnn/WorkingMemHandle.cpp @@ -3,7 +3,7 @@ // SPDX-License-Identifier: MIT // -#include "backendsCommon/CpuTensorHandle.hpp" +#include "backendsCommon/TensorHandle.hpp" #include "WorkingMemHandle.hpp" #include "Network.hpp" #include diff --git a/src/armnn/layers/BatchNormalizationLayer.cpp b/src/armnn/layers/BatchNormalizationLayer.cpp index 83ed45aa33..e3ee643ac5 100644 --- a/src/armnn/layers/BatchNormalizationLayer.cpp +++ b/src/armnn/layers/BatchNormalizationLayer.cpp @@ -7,7 +7,7 @@ #include "LayerCloneBase.hpp" #include -#include +#include #include namespace armnn diff --git a/src/armnn/layers/BatchNormalizationLayer.hpp b/src/armnn/layers/BatchNormalizationLayer.hpp index bf9e4b7917..2777633a34 100644 --- a/src/armnn/layers/BatchNormalizationLayer.hpp +++ b/src/armnn/layers/BatchNormalizationLayer.hpp @@ -9,20 +9,20 @@ namespace armnn { -class ScopedCpuTensorHandle; +class ScopedTensorHandle; /// This layer represents a batch normalization operation. class BatchNormalizationLayer : public LayerWithParameters { public: /// A unique pointer to store Mean values - std::shared_ptr m_Mean; + std::shared_ptr m_Mean; /// A unique pointer to store Variance values - std::shared_ptr m_Variance; + std::shared_ptr m_Variance; /// A unique pointer to store Beta values - std::shared_ptr m_Beta; + std::shared_ptr m_Beta; /// A unique pointer to store Gamma values - std::shared_ptr m_Gamma; + std::shared_ptr m_Gamma; /// Makes a workload for the BatchNormalization type. /// @param [in] graph The graph where this layer can be found. diff --git a/src/armnn/layers/BatchToSpaceNdLayer.cpp b/src/armnn/layers/BatchToSpaceNdLayer.cpp index a13b0b731a..4b33b96229 100644 --- a/src/armnn/layers/BatchToSpaceNdLayer.cpp +++ b/src/armnn/layers/BatchToSpaceNdLayer.cpp @@ -12,7 +12,7 @@ #include -#include +#include #include #include diff --git a/src/armnn/layers/ConstantLayer.cpp b/src/armnn/layers/ConstantLayer.cpp index eb28187d25..feeb762263 100644 --- a/src/armnn/layers/ConstantLayer.cpp +++ b/src/armnn/layers/ConstantLayer.cpp @@ -6,7 +6,7 @@ #include "LayerCloneBase.hpp" #include -#include +#include #include #include diff --git a/src/armnn/layers/ConstantLayer.hpp b/src/armnn/layers/ConstantLayer.hpp index ff4c03775f..ead8816684 100644 --- a/src/armnn/layers/ConstantLayer.hpp +++ b/src/armnn/layers/ConstantLayer.hpp @@ -9,7 +9,7 @@ namespace armnn { -class ScopedCpuTensorHandle; +class ScopedTensorHandle; /// A layer that the constant data can be bound to. class ConstantLayer : public Layer @@ -43,7 +43,7 @@ public: void ExecuteStrategy(IStrategy& strategy) const override; - std::shared_ptr m_LayerOutput; + std::shared_ptr m_LayerOutput; protected: /// Constructor to create a ConstantLayer. diff --git a/src/armnn/layers/Convolution2dLayer.cpp b/src/armnn/layers/Convolution2dLayer.cpp index d7a7a330ef..b7bf0462d8 100644 --- a/src/armnn/layers/Convolution2dLayer.cpp +++ b/src/armnn/layers/Convolution2dLayer.cpp @@ -10,7 +10,7 @@ #include -#include +#include #include #include diff --git a/src/armnn/layers/Convolution2dLayer.hpp b/src/armnn/layers/Convolution2dLayer.hpp index 2d5ab194de..a33cda27cb 100644 --- a/src/armnn/layers/Convolution2dLayer.hpp +++ b/src/armnn/layers/Convolution2dLayer.hpp @@ -9,7 +9,7 @@ namespace armnn { -class ScopedCpuTensorHandle; +class ScopedTensorHandle; /// This layer represents a convolution 2d operation. class Convolution2dLayer : public LayerWithParameters @@ -17,9 +17,9 @@ class Convolution2dLayer : public LayerWithParameters public: /// A unique pointer to store Weight values. - std::shared_ptr m_Weight; + std::shared_ptr m_Weight; /// A unique pointer to store Bias values. - std::shared_ptr m_Bias; + std::shared_ptr m_Bias; /// Makes a workload for the Convolution2d type. /// @param [in] graph The graph where this layer can be found. diff --git a/src/armnn/layers/DepthwiseConvolution2dLayer.cpp b/src/armnn/layers/DepthwiseConvolution2dLayer.cpp index 3511ab58d0..b96c567504 100644 --- a/src/armnn/layers/DepthwiseConvolution2dLayer.cpp +++ b/src/armnn/layers/DepthwiseConvolution2dLayer.cpp @@ -10,7 +10,7 @@ #include -#include +#include #include #include diff --git a/src/armnn/layers/DepthwiseConvolution2dLayer.hpp b/src/armnn/layers/DepthwiseConvolution2dLayer.hpp index c83aa434d5..51f6ea9453 100644 --- a/src/armnn/layers/DepthwiseConvolution2dLayer.hpp +++ b/src/armnn/layers/DepthwiseConvolution2dLayer.hpp @@ -9,16 +9,16 @@ namespace armnn { -class ScopedCpuTensorHandle; +class ScopedTensorHandle; /// This layer represents a depthwise convolution 2d operation. class DepthwiseConvolution2dLayer : public LayerWithParameters { public: /// A unique pointer to store Weight values. - std::shared_ptr m_Weight; + std::shared_ptr m_Weight; /// A unique pointer to store Bias values. - std::shared_ptr m_Bias; + std::shared_ptr m_Bias; /// Makes a workload for the DepthwiseConvolution2d type. /// @param [in] graph The graph where this layer can be found. diff --git a/src/armnn/layers/DetectionPostProcessLayer.cpp b/src/armnn/layers/DetectionPostProcessLayer.cpp index b5086172dd..bd94d1d281 100644 --- a/src/armnn/layers/DetectionPostProcessLayer.cpp +++ b/src/armnn/layers/DetectionPostProcessLayer.cpp @@ -8,7 +8,7 @@ #include "LayerCloneBase.hpp" #include -#include +#include #include #include diff --git a/src/armnn/layers/DetectionPostProcessLayer.hpp b/src/armnn/layers/DetectionPostProcessLayer.hpp index e40966a19c..b409134c1c 100644 --- a/src/armnn/layers/DetectionPostProcessLayer.hpp +++ b/src/armnn/layers/DetectionPostProcessLayer.hpp @@ -10,14 +10,14 @@ namespace armnn { -class ScopedCpuTensorHandle; +class ScopedTensorHandle; /// This layer represents a detection postprocess operator. class DetectionPostProcessLayer : public LayerWithParameters { public: /// A unique pointer to store Anchor values. - std::shared_ptr m_Anchors; + std::shared_ptr m_Anchors; /// Makes a workload for the DetectionPostProcess type. /// @param [in] graph The graph where this layer can be found. diff --git a/src/armnn/layers/FullyConnectedLayer.cpp b/src/armnn/layers/FullyConnectedLayer.cpp index 79d56c0bd7..9d4f57d260 100644 --- a/src/armnn/layers/FullyConnectedLayer.cpp +++ b/src/armnn/layers/FullyConnectedLayer.cpp @@ -7,7 +7,7 @@ #include "LayerCloneBase.hpp" #include -#include +#include #include #include diff --git a/src/armnn/layers/FullyConnectedLayer.hpp b/src/armnn/layers/FullyConnectedLayer.hpp index c45b081c85..7fc7b0d596 100644 --- a/src/armnn/layers/FullyConnectedLayer.hpp +++ b/src/armnn/layers/FullyConnectedLayer.hpp @@ -9,16 +9,16 @@ namespace armnn { -class ScopedCpuTensorHandle; +class ScopedTensorHandle; /// This layer represents a fully connected operation. class FullyConnectedLayer : public LayerWithParameters { public: /// A unique pointer to store Weight values. - std::shared_ptr m_Weight; + std::shared_ptr m_Weight; /// A unique pointer to store Bias values. - std::shared_ptr m_Bias; + std::shared_ptr m_Bias; /// Makes a workload for the FullyConnected type. /// @param [in] graph The graph where this layer can be found. diff --git a/src/armnn/layers/LstmLayer.cpp b/src/armnn/layers/LstmLayer.cpp index 403d911e7e..0fea668b97 100644 --- a/src/armnn/layers/LstmLayer.cpp +++ b/src/armnn/layers/LstmLayer.cpp @@ -8,7 +8,7 @@ #include #include -#include +#include #include namespace armnn diff --git a/src/armnn/layers/LstmLayer.hpp b/src/armnn/layers/LstmLayer.hpp index 80b57a88f7..f711ea7607 100644 --- a/src/armnn/layers/LstmLayer.hpp +++ b/src/armnn/layers/LstmLayer.hpp @@ -9,68 +9,68 @@ namespace armnn { -class ScopedCpuTensorHandle; +class ScopedTensorHandle; struct LstmOptLayerNormParameters { /// A unique pointer to represent 1D weights tensor with dimensions [num_units]. - std::shared_ptr m_InputLayerNormWeights; + std::shared_ptr m_InputLayerNormWeights; /// A unique pointer to represent 1D weights tensor with dimensions [num_units]. - std::shared_ptr m_ForgetLayerNormWeights; + std::shared_ptr m_ForgetLayerNormWeights; /// A unique pointer to represent 1D weights tensor with dimensions [num_units]. - std::shared_ptr m_CellLayerNormWeights; + std::shared_ptr m_CellLayerNormWeights; /// A unique pointer to represent 1D weights tensor with dimensions [num_units]. - std::shared_ptr m_OutputLayerNormWeights; + std::shared_ptr m_OutputLayerNormWeights; }; struct LstmOptCifgParameters { /// A unique pointer to represent 2D weights tensor with dimensions [input_size, num_units]. - std::shared_ptr m_InputToInputWeights; + std::shared_ptr m_InputToInputWeights; /// A unique pointer to represent 2D weights tensor with dimensions [input_size, num_units]. - std::shared_ptr m_RecurrentToInputWeights; + std::shared_ptr m_RecurrentToInputWeights; /// A unique pointer to represent 1D weights tensor with dimensions [num_units]. - std::shared_ptr m_InputGateBias; + std::shared_ptr m_InputGateBias; }; struct LstmOptProjectionParameters { /// A unique pointer to represent 2D weights tensor with dimensions [output_size, num_units]. - std::shared_ptr m_ProjectionWeights; + std::shared_ptr m_ProjectionWeights; /// A unique pointer to represent 1D weights tensor with dimensions [output_size]. - std::shared_ptr m_ProjectionBias; + std::shared_ptr m_ProjectionBias; }; struct LstmOptPeepholeParameters { /// A unique pointer to represent 1D weights tensor with dimensions [num_units]. - std::shared_ptr m_CellToInputWeights; + std::shared_ptr m_CellToInputWeights; /// A unique pointer to represent 1D weights tensor with dimensions [num_units]. - std::shared_ptr m_CellToForgetWeights; + std::shared_ptr m_CellToForgetWeights; /// A unique pointer to represent 1D weights tensor with dimensions [num_units]. - std::shared_ptr m_CellToOutputWeights; + std::shared_ptr m_CellToOutputWeights; }; struct LstmBasicParameters { /// A unique pointer to represent 2D weights tensor with dimensions [input_size, num_units]. - std::shared_ptr m_InputToForgetWeights; + std::shared_ptr m_InputToForgetWeights; /// A unique pointer to represent 2D weights tensor with dimensions [input_size, num_units]. - std::shared_ptr m_InputToCellWeights; + std::shared_ptr m_InputToCellWeights; /// A unique pointer to represent 2D weights tensor with dimensions [input_size, num_units]. - std::shared_ptr m_InputToOutputWeights; + std::shared_ptr m_InputToOutputWeights; /// A unique pointer to represent 2D weights tensor with dimensions [output_size, num_units]. - std::shared_ptr m_RecurrentToForgetWeights; + std::shared_ptr m_RecurrentToForgetWeights; /// A unique pointer to represent 2D weights tensor with dimensions [output_size, num_units]. - std::shared_ptr m_RecurrentToCellWeights; + std::shared_ptr m_RecurrentToCellWeights; /// A unique pointer to represent 2D weights tensor with dimensions [output_size, num_units]. - std::shared_ptr m_RecurrentToOutputWeights; + std::shared_ptr m_RecurrentToOutputWeights; /// A unique pointer to represent 1D weights tensor with dimensions [num_units]. - std::shared_ptr m_ForgetGateBias; + std::shared_ptr m_ForgetGateBias; /// A unique pointer to represent 1D weights tensor with dimensions [num_units]. - std::shared_ptr m_CellBias; + std::shared_ptr m_CellBias; /// A unique pointer to represent 1D weights tensor with dimensions [num_units]. - std::shared_ptr m_OutputGateBias; + std::shared_ptr m_OutputGateBias; }; /// This layer represents a LSTM operation. diff --git a/src/armnn/layers/MeanLayer.cpp b/src/armnn/layers/MeanLayer.cpp index b5c7708fc3..9d4265cdcf 100644 --- a/src/armnn/layers/MeanLayer.cpp +++ b/src/armnn/layers/MeanLayer.cpp @@ -8,7 +8,7 @@ #include -#include +#include #include #include diff --git a/src/armnn/layers/PadLayer.cpp b/src/armnn/layers/PadLayer.cpp index f620a6e9a4..2c53f20703 100644 --- a/src/armnn/layers/PadLayer.cpp +++ b/src/armnn/layers/PadLayer.cpp @@ -6,7 +6,7 @@ #include "PadLayer.hpp" #include "LayerCloneBase.hpp" -#include +#include #include #include diff --git a/src/armnn/layers/PreluLayer.cpp b/src/armnn/layers/PreluLayer.cpp index f9f534e648..18d81ae9b6 100644 --- a/src/armnn/layers/PreluLayer.cpp +++ b/src/armnn/layers/PreluLayer.cpp @@ -9,9 +9,9 @@ #include +#include #include #include -#include namespace armnn { diff --git a/src/armnn/layers/QLstmLayer.cpp b/src/armnn/layers/QLstmLayer.cpp index 72b020f109..0294afdc0d 100644 --- a/src/armnn/layers/QLstmLayer.cpp +++ b/src/armnn/layers/QLstmLayer.cpp @@ -8,7 +8,7 @@ #include #include -#include +#include #include namespace armnn diff --git a/src/armnn/layers/QLstmLayer.hpp b/src/armnn/layers/QLstmLayer.hpp index 09a020dc1d..38a0464da6 100644 --- a/src/armnn/layers/QLstmLayer.hpp +++ b/src/armnn/layers/QLstmLayer.hpp @@ -9,70 +9,70 @@ namespace armnn { -class ScopedCpuTensorHandle; +class ScopedTensorHandle; struct QLstmBasicParameters { /// A unique pointer to represent 2D weights tensor with dimensions [num_units, inputSize] (QSymmS8). - std::shared_ptr m_InputToForgetWeights; + std::shared_ptr m_InputToForgetWeights; /// A unique pointer to represent 2D weights tensor with dimensions [num_units, inputSize] (QSymmS8). - std::shared_ptr m_InputToCellWeights; + std::shared_ptr m_InputToCellWeights; /// A unique pointer to represent 2D weights tensor with dimensions [num_units, inputSize] (QSymmS8). - std::shared_ptr m_InputToOutputWeights; + std::shared_ptr m_InputToOutputWeights; /// A unique pointer to represent 2D weights tensor with dimensions [num_units, outputSize] (QSymmS8). - std::shared_ptr m_RecurrentToForgetWeights; + std::shared_ptr m_RecurrentToForgetWeights; /// A unique pointer to represent 2D weights tensor with dimensions [num_units, outputSize] (QSymmS8). - std::shared_ptr m_RecurrentToCellWeights; + std::shared_ptr m_RecurrentToCellWeights; /// A unique pointer to represent 2D weights tensor with dimensions [num_units, outputSize] (QSymmS8). - std::shared_ptr m_RecurrentToOutputWeights; + std::shared_ptr m_RecurrentToOutputWeights; /// A unique pointer to represent 1D bias tensor with dimensions [num_units] (int32). - std::shared_ptr m_ForgetGateBias; + std::shared_ptr m_ForgetGateBias; /// A unique pointer to represent 1D bias tensor with dimensions [num_units] (int32). - std::shared_ptr m_CellBias; + std::shared_ptr m_CellBias; /// A unique pointer to represent 1D bias tensor with dimensions [num_units] (int32). - std::shared_ptr m_OutputGateBias; + std::shared_ptr m_OutputGateBias; }; struct QLstmOptProjectionParameters { /// A unique pointer to represent 2D weights tensor with dimensions [output_size, num_units] (QSymmS8). - std::shared_ptr m_ProjectionWeights; + std::shared_ptr m_ProjectionWeights; /// A unique pointer to represent 1D weights tensor with dimensions [output_size] (int32). - std::shared_ptr m_ProjectionBias; + std::shared_ptr m_ProjectionBias; }; struct QLstmOptPeepholeParameters { /// A unique pointer to represent 1D weights tensor with dimensions [num_units] (QSymmS16). - std::shared_ptr m_CellToInputWeights; + std::shared_ptr m_CellToInputWeights; /// A unique pointer to represent 1D weights tensor with dimensions [num_units] (QSymmS16). - std::shared_ptr m_CellToForgetWeights; + std::shared_ptr m_CellToForgetWeights; /// A unique pointer to represent 1D weights tensor with dimensions [num_units] (QSymmS16). - std::shared_ptr m_CellToOutputWeights; + std::shared_ptr m_CellToOutputWeights; }; struct QLstmOptCifgParameters { /// A unique pointer to represent 2D weights tensor with dimensions [input_size, num_units] (QSymmS8). - std::shared_ptr m_InputToInputWeights; + std::shared_ptr m_InputToInputWeights; /// A unique pointer to represent 2D weights tensor with dimensions [input_size, num_units] (QSymmS8). - std::shared_ptr m_RecurrentToInputWeights; + std::shared_ptr m_RecurrentToInputWeights; /// A unique pointer to represent 1D weights tensor with dimensions [num_units] (int32). - std::shared_ptr m_InputGateBias; + std::shared_ptr m_InputGateBias; }; struct QLstmOptLayerNormParameters { /// A unique pointer to represent 1D weights tensor with dimensions [num_units] (QSymmS16). - std::shared_ptr m_InputLayerNormWeights; + std::shared_ptr m_InputLayerNormWeights; /// A unique pointer to represent 1D weights tensor with dimensions [num_units] (QSymmS16). - std::shared_ptr m_ForgetLayerNormWeights; + std::shared_ptr m_ForgetLayerNormWeights; /// A unique pointer to represent 1D weights tensor with dimensions [num_units] (QSymmS16). - std::shared_ptr m_CellLayerNormWeights; + std::shared_ptr m_CellLayerNormWeights; /// A unique pointer to represent 1D weights tensor with dimensions [num_units] (QSymmS16). - std::shared_ptr m_OutputLayerNormWeights; + std::shared_ptr m_OutputLayerNormWeights; }; /// This layer represents a QLstm operation. diff --git a/src/armnn/layers/QuantizedLstmLayer.cpp b/src/armnn/layers/QuantizedLstmLayer.cpp index 4d0dab9505..be50f4863b 100644 --- a/src/armnn/layers/QuantizedLstmLayer.cpp +++ b/src/armnn/layers/QuantizedLstmLayer.cpp @@ -8,7 +8,7 @@ #include #include -#include +#include #include namespace armnn diff --git a/src/armnn/layers/QuantizedLstmLayer.hpp b/src/armnn/layers/QuantizedLstmLayer.hpp index ca97a6bb65..25cc7b7d8b 100644 --- a/src/armnn/layers/QuantizedLstmLayer.hpp +++ b/src/armnn/layers/QuantizedLstmLayer.hpp @@ -9,36 +9,36 @@ namespace armnn { -class ScopedCpuTensorHandle; +class ScopedTensorHandle; struct QuantizedLstmParameters { /// A unique pointer to represent 2D weights tensor with dimensions [outputSize, inputSize] (QAsymm8). - std::shared_ptr m_InputToInputWeights; + std::shared_ptr m_InputToInputWeights; /// A unique pointer to represent 2D weights tensor with dimensions [outputSize, inputSize] (QAsymm8). - std::shared_ptr m_InputToForgetWeights; + std::shared_ptr m_InputToForgetWeights; /// A unique pointer to represent 2D weights tensor with dimensions [outputSize, inputSize] (QAsymm8). - std::shared_ptr m_InputToCellWeights; + std::shared_ptr m_InputToCellWeights; /// A unique pointer to represent 2D weights tensor with dimensions [outputSize, inputSize] (QAsymm8). - std::shared_ptr m_InputToOutputWeights; + std::shared_ptr m_InputToOutputWeights; /// A unique pointer to represent 2D weights tensor with dimensions [outputSize, outputSize] (QAsymm8). - std::shared_ptr m_RecurrentToInputWeights; + std::shared_ptr m_RecurrentToInputWeights; /// A unique pointer to represent 2D weights tensor with dimensions [outputSize, outputSize] (QAsymm8). - std::shared_ptr m_RecurrentToForgetWeights; + std::shared_ptr m_RecurrentToForgetWeights; /// A unique pointer to represent 2D weights tensor with dimensions [outputSize, outputSize] (QAsymm8). - std::shared_ptr m_RecurrentToCellWeights; + std::shared_ptr m_RecurrentToCellWeights; /// A unique pointer to represent 2D weights tensor with dimensions [outputSize, outputSize] (QAsymm8). - std::shared_ptr m_RecurrentToOutputWeights; + std::shared_ptr m_RecurrentToOutputWeights; /// A unique pointer to represent 1D bias tensor with dimensions [outputSize] (int32). - std::shared_ptr m_InputGateBias; + std::shared_ptr m_InputGateBias; /// A unique pointer to represent 1D bias tensor with dimensions [outputSize] (int32). - std::shared_ptr m_ForgetGateBias; + std::shared_ptr m_ForgetGateBias; /// A unique pointer to represent 1D bias tensor with dimensions [outputSize] (int32). - std::shared_ptr m_CellBias; + std::shared_ptr m_CellBias; /// A unique pointer to represent 1D bias tensor with dimensions [outputSize] (int32). - std::shared_ptr m_OutputGateBias; + std::shared_ptr m_OutputGateBias; }; /// This layer represents a QuantizedLstm operation. diff --git a/src/armnn/layers/TransposeConvolution2dLayer.cpp b/src/armnn/layers/TransposeConvolution2dLayer.cpp index c0a7dfa1cd..c774dd0bbf 100644 --- a/src/armnn/layers/TransposeConvolution2dLayer.cpp +++ b/src/armnn/layers/TransposeConvolution2dLayer.cpp @@ -8,7 +8,7 @@ #include -#include +#include #include using namespace armnnUtils; diff --git a/src/armnn/layers/TransposeConvolution2dLayer.hpp b/src/armnn/layers/TransposeConvolution2dLayer.hpp index 53e73491d6..1b17dac3c6 100644 --- a/src/armnn/layers/TransposeConvolution2dLayer.hpp +++ b/src/armnn/layers/TransposeConvolution2dLayer.hpp @@ -9,16 +9,16 @@ namespace armnn { -class ScopedCpuTensorHandle; +class ScopedTensorHandle; /// This layer represents a 2D transpose convolution operation. class TransposeConvolution2dLayer : public LayerWithParameters { public: /// A unique pointer to store weight values. - std::shared_ptr m_Weight; + std::shared_ptr m_Weight; /// A unique pointer to store bias values. - std::shared_ptr m_Bias; + std::shared_ptr m_Bias; /// Makes a workload for the TransposeConvolution2d type. /// @param [in] graph The graph where this layer can be found. diff --git a/src/armnn/optimizations/AddBroadcastReshapeLayer.hpp b/src/armnn/optimizations/AddBroadcastReshapeLayer.hpp index aa00b9913c..4cfe2e4898 100644 --- a/src/armnn/optimizations/AddBroadcastReshapeLayer.hpp +++ b/src/armnn/optimizations/AddBroadcastReshapeLayer.hpp @@ -8,7 +8,7 @@ #include #include -#include +#include namespace armnn { @@ -70,7 +70,7 @@ public: { ConstantLayer& constantLayer = static_cast(parentLayer); - constantLayer.m_LayerOutput = std::make_unique( + constantLayer.m_LayerOutput = std::make_unique( ConstTensor(reshapeInfo, constantLayer.m_LayerOutput.get()->GetConstTensor())); constantLayer.GetOutputSlot().SetTensorInfo(reshapeInfo); } diff --git a/src/armnn/optimizations/ConvertConstants.hpp b/src/armnn/optimizations/ConvertConstants.hpp index df5a5b4f67..66b3d2685a 100644 --- a/src/armnn/optimizations/ConvertConstants.hpp +++ b/src/armnn/optimizations/ConvertConstants.hpp @@ -9,7 +9,7 @@ #include -#include +#include #include @@ -23,7 +23,7 @@ namespace optimizations struct BFloat16ToFloat32 { - static void Func(std::shared_ptr& handle) + static void Func(std::shared_ptr& handle) { const TensorInfo& info = handle->GetTensorInfo(); @@ -37,14 +37,14 @@ struct BFloat16ToFloat32 TensorInfo newInfo(info.GetShape(), DataType::Float32); ConstTensor newInput(newInfo, newValues); - handle.reset(new ScopedCpuTensorHandle(newInput)); + handle.reset(new ScopedTensorHandle(newInput)); } } }; struct Float16ToFloat32 { - static void Func(std::shared_ptr& handle) + static void Func(std::shared_ptr& handle) { const TensorInfo& info = handle->GetTensorInfo(); @@ -58,14 +58,14 @@ struct Float16ToFloat32 TensorInfo newInfo(info.GetShape(), DataType::Float32); ConstTensor newInput(newInfo, newValues); - handle.reset(new ScopedCpuTensorHandle(newInput)); + handle.reset(new ScopedTensorHandle(newInput)); } } }; struct Float32ToBFloat16 { - static void Func(std::shared_ptr& handle) + static void Func(std::shared_ptr& handle) { const TensorInfo& info = handle->GetTensorInfo(); @@ -79,14 +79,14 @@ struct Float32ToBFloat16 TensorInfo newInfo(info.GetShape(), DataType::BFloat16); ConstTensor newInput(newInfo, newValues); - handle.reset(new ScopedCpuTensorHandle(newInput)); + handle.reset(new ScopedTensorHandle(newInput)); } } }; struct Float32ToFloat16 { - static void Func(std::shared_ptr& handle) + static void Func(std::shared_ptr& handle) { const TensorInfo& info = handle->GetTensorInfo(); @@ -100,7 +100,7 @@ struct Float32ToFloat16 TensorInfo newInfo(info.GetShape(), DataType::Float16); ConstTensor newInput(newInfo, newValues); - handle.reset(new ScopedCpuTensorHandle(newInput)); + handle.reset(new ScopedTensorHandle(newInput)); } } }; diff --git a/src/armnn/optimizations/ConvertFp32NetworkToBf16.hpp b/src/armnn/optimizations/ConvertFp32NetworkToBf16.hpp index a0856a485b..6c80e740be 100644 --- a/src/armnn/optimizations/ConvertFp32NetworkToBf16.hpp +++ b/src/armnn/optimizations/ConvertFp32NetworkToBf16.hpp @@ -35,7 +35,7 @@ inline LayerT* ConvertWeight(Layer* l) TensorInfo newInfo(info); newInfo.SetDataType(DataType::BFloat16); ConstTensor newInput(newInfo, newValues); - layer->m_Weight.reset(new ScopedCpuTensorHandle(newInput)); + layer->m_Weight.reset(new ScopedTensorHandle(newInput)); } } return layer; diff --git a/src/armnn/optimizations/FuseBatchNorm.hpp b/src/armnn/optimizations/FuseBatchNorm.hpp index 9d25379930..3fb4b34d28 100644 --- a/src/armnn/optimizations/FuseBatchNorm.hpp +++ b/src/armnn/optimizations/FuseBatchNorm.hpp @@ -162,8 +162,8 @@ public: auto& newConv2dLayer = *graph.InsertNewLayer(base.GetInputSlot(0), convDescriptor, name.c_str()); - newConv2dLayer.m_Weight = std::make_unique(fusedWeightsTensor); - newConv2dLayer.m_Bias = std::make_unique(ConstTensor(fusedBiasTensor)); + newConv2dLayer.m_Weight = std::make_unique(fusedWeightsTensor); + newConv2dLayer.m_Bias = std::make_unique(ConstTensor(fusedBiasTensor)); // Reconnects with original parent. newConv2dLayer.GetOutputSlot().MoveAllConnections(*parentOut); diff --git a/src/armnn/test/CreateWorkload.hpp b/src/armnn/test/CreateWorkload.hpp index 3ea2c35061..12623e62a0 100644 --- a/src/armnn/test/CreateWorkload.hpp +++ b/src/armnn/test/CreateWorkload.hpp @@ -14,9 +14,9 @@ #include #include +#include #include #include -#include #include @@ -353,10 +353,10 @@ std::unique_ptr CreateBatchNormalizationWorkload BatchNormalizationLayer* const layer = graph.AddLayer(layerDesc, "layer"); armnn::TensorInfo weightInfo({3}, DataType); - layer->m_Mean = std::make_unique(weightInfo); - layer->m_Variance = std::make_unique(weightInfo); - layer->m_Beta = std::make_unique(weightInfo); - layer->m_Gamma = std::make_unique(weightInfo); + layer->m_Mean = std::make_unique(weightInfo); + layer->m_Variance = std::make_unique(weightInfo); + layer->m_Beta = std::make_unique(weightInfo); + layer->m_Gamma = std::make_unique(weightInfo); layer->m_Mean->Allocate(); layer->m_Variance->Allocate(); layer->m_Beta->Allocate(); @@ -411,10 +411,10 @@ std::unique_ptr CreateBatchNormalizationWithBlob BatchNormalizationLayer* const layer = graph.AddLayer(layerDesc, "layer"); armnn::TensorInfo weightInfo({3}, DataType); - layer->m_Mean = std::make_unique(weightInfo); - layer->m_Variance = std::make_unique(weightInfo); - layer->m_Beta = std::make_unique(weightInfo); - layer->m_Gamma = std::make_unique(weightInfo); + layer->m_Mean = std::make_unique(weightInfo); + layer->m_Variance = std::make_unique(weightInfo); + layer->m_Beta = std::make_unique(weightInfo); + layer->m_Gamma = std::make_unique(weightInfo); layer->m_Mean->Allocate(); layer->m_Variance->Allocate(); layer->m_Beta->Allocate(); @@ -492,8 +492,8 @@ std::unique_ptr CreateConvolution2dWorkloadTest(armnn::IW TensorShape inputShape = (dataLayout == DataLayout::NCHW) ? TensorShape{2, 3, 8, 16} : TensorShape{2, 8, 16, 3}; TensorShape outputShape = (dataLayout == DataLayout::NCHW) ? TensorShape{2, 2, 2, 10} : TensorShape{2, 2, 10, 2}; - layer->m_Weight = std::make_unique(TensorInfo(weightShape, DataType)); - layer->m_Bias = std::make_unique(TensorInfo({2}, GetBiasDataType(DataType))); + layer->m_Weight = std::make_unique(TensorInfo(weightShape, DataType)); + layer->m_Bias = std::make_unique(TensorInfo({2}, GetBiasDataType(DataType))); layer->m_Weight->Allocate(); layer->m_Bias->Allocate(); @@ -555,8 +555,8 @@ std::unique_ptr CreateConvolution2dFusedActivationWithBlo TensorShape inputShape = (dataLayout == DataLayout::NCHW) ? TensorShape{2, 3, 8, 16} : TensorShape{2, 8, 16, 3}; TensorShape outputShape = (dataLayout == DataLayout::NCHW) ? TensorShape{2, 2, 2, 10} : TensorShape{2, 2, 10, 2}; - layer->m_Weight = std::make_unique(TensorInfo(weightShape, DataType)); - layer->m_Bias = std::make_unique(TensorInfo({2}, GetBiasDataType(DataType))); + layer->m_Weight = std::make_unique(TensorInfo(weightShape, DataType)); + layer->m_Bias = std::make_unique(TensorInfo({2}, GetBiasDataType(DataType))); layer->m_Weight->Allocate(); layer->m_Bias->Allocate(); @@ -639,8 +639,8 @@ std::unique_ptr CreateConvolution2dWorkloadFastMathTest(a TensorShape inputShape = TensorShape{1, 32, 149, 149}; TensorShape outputShape = TensorShape{1, 32, 147, 147}; - layer->m_Weight = std::make_unique(TensorInfo(weightShape, DataType)); - layer->m_Bias = std::make_unique(TensorInfo({2}, GetBiasDataType(DataType))); + layer->m_Weight = std::make_unique(TensorInfo(weightShape, DataType)); + layer->m_Bias = std::make_unique(TensorInfo({2}, GetBiasDataType(DataType))); layer->m_Weight->Allocate(); layer->m_Bias->Allocate(); @@ -692,23 +692,23 @@ std::unique_ptr CreateLstmWorkloadTest(armnn::IWorkloadFactory& fa unsigned int numUnits = 4; unsigned int outputSize = 4; - layer->m_BasicParameters.m_InputToForgetWeights = std::make_unique + layer->m_BasicParameters.m_InputToForgetWeights = std::make_unique (TensorInfo({ numUnits, inputSize }, DataType::Float32)); - layer->m_BasicParameters.m_InputToCellWeights = std::make_unique + layer->m_BasicParameters.m_InputToCellWeights = std::make_unique (TensorInfo({ numUnits, inputSize }, DataType::Float32)); - layer->m_BasicParameters.m_InputToOutputWeights = std::make_unique + layer->m_BasicParameters.m_InputToOutputWeights = std::make_unique (TensorInfo({ numUnits, inputSize }, DataType::Float32)); - layer->m_BasicParameters.m_RecurrentToForgetWeights = std::make_unique + layer->m_BasicParameters.m_RecurrentToForgetWeights = std::make_unique (TensorInfo({ numUnits, outputSize }, DataType::Float32)); - layer->m_BasicParameters.m_RecurrentToCellWeights = std::make_unique + layer->m_BasicParameters.m_RecurrentToCellWeights = std::make_unique (TensorInfo({ numUnits, outputSize }, DataType::Float32)); - layer->m_BasicParameters.m_RecurrentToOutputWeights = std::make_unique + layer->m_BasicParameters.m_RecurrentToOutputWeights = std::make_unique (TensorInfo({ numUnits, outputSize }, DataType::Float32)); - layer->m_BasicParameters.m_ForgetGateBias = std::make_unique + layer->m_BasicParameters.m_ForgetGateBias = std::make_unique (TensorInfo({ numUnits }, DataType::Float32)); - layer->m_BasicParameters.m_CellBias = std::make_unique + layer->m_BasicParameters.m_CellBias = std::make_unique (TensorInfo({ numUnits }, DataType::Float32)); - layer->m_BasicParameters.m_OutputGateBias = std::make_unique + layer->m_BasicParameters.m_OutputGateBias = std::make_unique (TensorInfo({ numUnits }, DataType::Float32)); layer->m_BasicParameters.m_InputToForgetWeights->Allocate(); @@ -724,9 +724,9 @@ std::unique_ptr CreateLstmWorkloadTest(armnn::IWorkloadFactory& fa if (layerDesc.m_PeepholeEnabled) { - layer->m_PeepholeParameters.m_CellToForgetWeights = std::make_unique + layer->m_PeepholeParameters.m_CellToForgetWeights = std::make_unique (TensorInfo({ numUnits }, DataType::Float32)); - layer->m_PeepholeParameters.m_CellToOutputWeights = std::make_unique + layer->m_PeepholeParameters.m_CellToOutputWeights = std::make_unique (TensorInfo({ numUnits }, DataType::Float32)); layer->m_PeepholeParameters.m_CellToForgetWeights->Allocate(); layer->m_PeepholeParameters.m_CellToOutputWeights->Allocate(); @@ -814,27 +814,27 @@ std::unique_ptr CreateQuantizedLstmWorkloadTest(armnn::IW // Weights and bias layer->m_QuantizedLstmParameters.m_InputToInputWeights = - std::make_unique(inputWeightsInfo); + std::make_unique(inputWeightsInfo); layer->m_QuantizedLstmParameters.m_InputToForgetWeights = - std::make_unique(inputWeightsInfo); + std::make_unique(inputWeightsInfo); layer->m_QuantizedLstmParameters.m_InputToCellWeights = - std::make_unique(inputWeightsInfo); + std::make_unique(inputWeightsInfo); layer->m_QuantizedLstmParameters.m_InputToOutputWeights = - std::make_unique(inputWeightsInfo); + std::make_unique(inputWeightsInfo); layer->m_QuantizedLstmParameters.m_RecurrentToInputWeights = - std::make_unique(recurrentWeightsInfo); + std::make_unique(recurrentWeightsInfo); layer->m_QuantizedLstmParameters.m_RecurrentToForgetWeights = - std::make_unique(recurrentWeightsInfo); + std::make_unique(recurrentWeightsInfo); layer->m_QuantizedLstmParameters.m_RecurrentToCellWeights = - std::make_unique(recurrentWeightsInfo); + std::make_unique(recurrentWeightsInfo); layer->m_QuantizedLstmParameters.m_RecurrentToOutputWeights = - std::make_unique(recurrentWeightsInfo); + std::make_unique(recurrentWeightsInfo); - layer->m_QuantizedLstmParameters.m_InputGateBias = std::make_unique(biasInfo); - layer->m_QuantizedLstmParameters.m_ForgetGateBias = std::make_unique(biasInfo); - layer->m_QuantizedLstmParameters.m_CellBias = std::make_unique(biasInfo); - layer->m_QuantizedLstmParameters.m_OutputGateBias = std::make_unique(biasInfo); + layer->m_QuantizedLstmParameters.m_InputGateBias = std::make_unique(biasInfo); + layer->m_QuantizedLstmParameters.m_ForgetGateBias = std::make_unique(biasInfo); + layer->m_QuantizedLstmParameters.m_CellBias = std::make_unique(biasInfo); + layer->m_QuantizedLstmParameters.m_OutputGateBias = std::make_unique(biasInfo); // Allocate weights and bias layer->m_QuantizedLstmParameters.m_InputToInputWeights->Allocate(); @@ -977,27 +977,27 @@ std::unique_ptr CreateQLstmWorkloadTest(armnn::IWorkloadFactory& armnn::TensorInfo layerNormWeightsInfo({numUnits}, armnn::DataType::QSymmS16, layerNormScale, layerNormOffset); // Create and allocate tensors - layer->m_BasicParameters.m_InputToForgetWeights = std::make_unique(inputWeightsInfo); - layer->m_BasicParameters.m_InputToCellWeights = std::make_unique(inputWeightsInfo); - layer->m_BasicParameters.m_InputToOutputWeights = std::make_unique(inputWeightsInfo); + layer->m_BasicParameters.m_InputToForgetWeights = std::make_unique(inputWeightsInfo); + layer->m_BasicParameters.m_InputToCellWeights = std::make_unique(inputWeightsInfo); + layer->m_BasicParameters.m_InputToOutputWeights = std::make_unique(inputWeightsInfo); layer->m_BasicParameters.m_RecurrentToForgetWeights = - std::make_unique(recurrentWeightsInfo); + std::make_unique(recurrentWeightsInfo); layer->m_BasicParameters.m_RecurrentToCellWeights = - std::make_unique(recurrentWeightsInfo); + std::make_unique(recurrentWeightsInfo); layer->m_BasicParameters.m_RecurrentToOutputWeights = - std::make_unique(recurrentWeightsInfo); + std::make_unique(recurrentWeightsInfo); - layer->m_BasicParameters.m_ForgetGateBias = std::make_unique(biasInfo); - layer->m_BasicParameters.m_CellBias = std::make_unique(biasInfo); - layer->m_BasicParameters.m_OutputGateBias = std::make_unique(biasInfo); + layer->m_BasicParameters.m_ForgetGateBias = std::make_unique(biasInfo); + layer->m_BasicParameters.m_CellBias = std::make_unique(biasInfo); + layer->m_BasicParameters.m_OutputGateBias = std::make_unique(biasInfo); layer->m_LayerNormParameters.m_ForgetLayerNormWeights = - std::make_unique(layerNormWeightsInfo); + std::make_unique(layerNormWeightsInfo); layer->m_LayerNormParameters.m_CellLayerNormWeights = - std::make_unique(layerNormWeightsInfo); + std::make_unique(layerNormWeightsInfo); layer->m_LayerNormParameters.m_OutputLayerNormWeights = - std::make_unique(layerNormWeightsInfo); + std::make_unique(layerNormWeightsInfo); layer->m_BasicParameters.m_InputToForgetWeights->Allocate(); layer->m_BasicParameters.m_InputToCellWeights->Allocate(); @@ -1093,8 +1093,8 @@ std::unique_ptr CreateDirectConvolution2dWorkloadTest(arm float inputsQScale = DataType == armnn::DataType::QAsymmU8 ? 1.0f : 0.0; float outputQScale = DataType == armnn::DataType::QAsymmU8 ? 2.0f : 0.0; - layer->m_Weight = std::make_unique(TensorInfo({ 2, 3, 3, 3 }, DataType, inputsQScale)); - layer->m_Bias = std::make_unique + layer->m_Weight = std::make_unique(TensorInfo({ 2, 3, 3, 3 }, DataType, inputsQScale)); + layer->m_Bias = std::make_unique (TensorInfo({2}, GetBiasDataType(DataType), inputsQScale)); layer->m_Weight->Allocate(); layer->m_Bias->Allocate(); @@ -1148,7 +1148,7 @@ std::unique_ptr CreateDepthwiseConvolutio DepthwiseConvolution2dLayer* const layer = graph.AddLayer(layerDesc, "layer"); - layer->m_Weight = std::make_unique(TensorInfo({1, 2, 4, 4}, DataType)); // [ M, I, H, W ] + layer->m_Weight = std::make_unique(TensorInfo({1, 2, 4, 4}, DataType)); // [ M, I, H, W ] layer->m_Weight->Allocate(); // Creates extra layers. @@ -1200,8 +1200,8 @@ std::unique_ptr CreateFullyConnectedWorkloadTest(armnn:: float inputsQScale = DataType == armnn::DataType::QAsymmU8 ? 1.0f : 0.0; float outputQScale = DataType == armnn::DataType::QAsymmU8 ? 2.0f : 0.0; - layer->m_Weight = std::make_unique(TensorInfo({7, 20}, DataType, inputsQScale, 0)); - layer->m_Bias = std::make_unique(TensorInfo({7}, GetBiasDataType(DataType), inputsQScale)); + layer->m_Weight = std::make_unique(TensorInfo({7, 20}, DataType, inputsQScale, 0)); + layer->m_Bias = std::make_unique(TensorInfo({7}, GetBiasDataType(DataType), inputsQScale)); layer->m_Weight->Allocate(); layer->m_Bias->Allocate(); @@ -1245,8 +1245,8 @@ std::unique_ptr CreateFullyConnectedWithBlobWorkloadTest float inputsQScale = DataType == armnn::DataType::QAsymmU8 ? 1.0f : 0.0; float outputQScale = DataType == armnn::DataType::QAsymmU8 ? 2.0f : 0.0; - layer->m_Weight = std::make_unique(TensorInfo({7, 20}, DataType, inputsQScale, 0)); - layer->m_Bias = std::make_unique(TensorInfo({7}, GetBiasDataType(DataType), inputsQScale)); + layer->m_Weight = std::make_unique(TensorInfo({7, 20}, DataType, inputsQScale, 0)); + layer->m_Bias = std::make_unique(TensorInfo({7}, GetBiasDataType(DataType), inputsQScale)); layer->m_Weight->Allocate(); layer->m_Bias->Allocate(); @@ -2108,7 +2108,7 @@ std::unique_ptr CreateConstantWorkloadTest(armnn::IWorkloadFac armnn::TensorInfo outputTensorInfo(outputShape, DataType); auto constant = graph.AddLayer("constant"); - constant->m_LayerOutput = std::make_unique(outputTensorInfo); + constant->m_LayerOutput = std::make_unique(outputTensorInfo); BOOST_TEST_CHECKPOINT("created constant layer"); Layer* const output = graph.AddLayer(0, "output"); diff --git a/src/armnn/test/GraphTests.cpp b/src/armnn/test/GraphTests.cpp index 602575b352..69f96d43a3 100644 --- a/src/armnn/test/GraphTests.cpp +++ b/src/armnn/test/GraphTests.cpp @@ -14,7 +14,7 @@ #include -#include +#include #include #include @@ -603,7 +603,7 @@ BOOST_AUTO_TEST_CASE(CheckGraphConstTensorSharing) float weight = 1.0f; armnn::ConstTensor constTensor({{ 1, 1 }, armnn::DataType::Float32}, &weight); - fcLayer->m_Weight = std::make_shared(constTensor);; + fcLayer->m_Weight = std::make_shared(constTensor);; // point sharedWeightPtr to graph1's const tensor sharedWeightPtr = fcLayer->m_Weight->GetConstTensor(); diff --git a/src/armnn/test/OptimizerTests.cpp b/src/armnn/test/OptimizerTests.cpp index 7e8a898293..d0734d83be 100644 --- a/src/armnn/test/OptimizerTests.cpp +++ b/src/armnn/test/OptimizerTests.cpp @@ -18,9 +18,9 @@ #include #include -#include #include #include +#include #include @@ -45,23 +45,23 @@ void CreateLSTMLayerHelper(Graph &graph, bool CifgEnabled) unsigned int numUnits = 4; unsigned int outputSize = 4; - layer->m_BasicParameters.m_InputToForgetWeights = std::make_unique + layer->m_BasicParameters.m_InputToForgetWeights = std::make_unique (TensorInfo({ numUnits, inputSize }, DataType::Float32)); - layer->m_BasicParameters.m_InputToCellWeights = std::make_unique + layer->m_BasicParameters.m_InputToCellWeights = std::make_unique (TensorInfo({ numUnits, inputSize }, DataType::Float32)); - layer->m_BasicParameters.m_InputToOutputWeights = std::make_unique + layer->m_BasicParameters.m_InputToOutputWeights = std::make_unique (TensorInfo({ numUnits, inputSize }, DataType::Float32)); - layer->m_BasicParameters.m_RecurrentToForgetWeights = std::make_unique + layer->m_BasicParameters.m_RecurrentToForgetWeights = std::make_unique (TensorInfo({ numUnits, outputSize }, DataType::Float32)); - layer->m_BasicParameters.m_RecurrentToCellWeights = std::make_unique + layer->m_BasicParameters.m_RecurrentToCellWeights = std::make_unique (TensorInfo({ numUnits, outputSize }, DataType::Float32)); - layer->m_BasicParameters.m_RecurrentToOutputWeights = std::make_unique + layer->m_BasicParameters.m_RecurrentToOutputWeights = std::make_unique (TensorInfo({ numUnits, outputSize }, DataType::Float32)); - layer->m_BasicParameters.m_ForgetGateBias = std::make_unique + layer->m_BasicParameters.m_ForgetGateBias = std::make_unique (TensorInfo({ numUnits }, DataType::Float32)); - layer->m_BasicParameters.m_CellBias = std::make_unique + layer->m_BasicParameters.m_CellBias = std::make_unique (TensorInfo({ numUnits }, DataType::Float32)); - layer->m_BasicParameters.m_OutputGateBias = std::make_unique + layer->m_BasicParameters.m_OutputGateBias = std::make_unique (TensorInfo({ numUnits }, DataType::Float32)); layer->m_BasicParameters.m_InputToForgetWeights->Allocate(); @@ -76,11 +76,11 @@ void CreateLSTMLayerHelper(Graph &graph, bool CifgEnabled) if (!layerDesc.m_CifgEnabled) { - layer->m_CifgParameters.m_InputToInputWeights = std::make_unique + layer->m_CifgParameters.m_InputToInputWeights = std::make_unique (TensorInfo({ numUnits, inputSize }, DataType::Float32)); - layer->m_CifgParameters.m_RecurrentToInputWeights = std::make_unique + layer->m_CifgParameters.m_RecurrentToInputWeights = std::make_unique (TensorInfo({ numUnits, outputSize }, DataType::Float32)); - layer->m_CifgParameters.m_InputGateBias = std::make_unique + layer->m_CifgParameters.m_InputGateBias = std::make_unique (TensorInfo({ numUnits }, DataType::Float32)); layer->m_CifgParameters.m_InputToInputWeights->Allocate(); layer->m_CifgParameters.m_RecurrentToInputWeights->Allocate(); @@ -89,9 +89,9 @@ void CreateLSTMLayerHelper(Graph &graph, bool CifgEnabled) if (layerDesc.m_ProjectionEnabled) { - layer->m_ProjectionParameters.m_ProjectionWeights = std::make_unique + layer->m_ProjectionParameters.m_ProjectionWeights = std::make_unique (TensorInfo({ outputSize, numUnits }, DataType::Float32)); - layer->m_ProjectionParameters.m_ProjectionBias = std::make_unique + layer->m_ProjectionParameters.m_ProjectionBias = std::make_unique (TensorInfo({ outputSize }, DataType::Float32)); layer->m_ProjectionParameters.m_ProjectionWeights->Allocate(); layer->m_ProjectionParameters.m_ProjectionBias->Allocate(); @@ -101,13 +101,13 @@ void CreateLSTMLayerHelper(Graph &graph, bool CifgEnabled) { if (!layerDesc.m_CifgEnabled) { - layer->m_PeepholeParameters.m_CellToInputWeights = std::make_unique + layer->m_PeepholeParameters.m_CellToInputWeights = std::make_unique (TensorInfo({ numUnits }, DataType::Float32)); layer->m_PeepholeParameters.m_CellToInputWeights->Allocate(); } - layer->m_PeepholeParameters.m_CellToForgetWeights = std::make_unique + layer->m_PeepholeParameters.m_CellToForgetWeights = std::make_unique (TensorInfo({ numUnits }, DataType::Float32)); - layer->m_PeepholeParameters.m_CellToOutputWeights = std::make_unique + layer->m_PeepholeParameters.m_CellToOutputWeights = std::make_unique (TensorInfo({ numUnits }, DataType::Float32)); layer->m_PeepholeParameters.m_CellToForgetWeights->Allocate(); layer->m_PeepholeParameters.m_CellToOutputWeights->Allocate(); @@ -276,7 +276,7 @@ void CreateConvolution2dGraph(Graph &graph, const unsigned int* inputShape, input->GetOutputSlot().SetTensorInfo(inputInfo); Convolution2dLayer* layer = graph.AddLayer(desc, "conv2d"); - layer->m_Weight = std::make_unique(weights); + layer->m_Weight = std::make_unique(weights); layer->GetOutputSlot().SetTensorInfo(outputInfo); Layer* output = graph.AddLayer(0, "output"); @@ -326,7 +326,7 @@ void CreateDepthwiseConvolution2dGraph(Graph &graph, const unsigned int* inputSh input->GetOutputSlot().SetTensorInfo(inputInfo); DepthwiseConvolution2dLayer* layer = graph.AddLayer(desc, "depthwiseConv2d"); - layer->m_Weight = std::make_unique(weights); + layer->m_Weight = std::make_unique(weights); layer->GetOutputSlot().SetTensorInfo(outputInfo); Layer* output = graph.AddLayer(0, "output"); @@ -529,7 +529,7 @@ BOOST_AUTO_TEST_CASE(DetectionPostProcessValidateTensorShapes) descriptor.m_MaxDetections = 3; DetectionPostProcessLayer* layer = graph.AddLayer(descriptor, "detectionPostProcess"); - layer->m_Anchors = std::make_unique(anchors); + layer->m_Anchors = std::make_unique(anchors); layer->GetOutputSlot(0).SetTensorInfo(detectionBoxesInfo); layer->GetOutputSlot(1).SetTensorInfo(detectionScoresInfo); layer->GetOutputSlot(2).SetTensorInfo(detectionClassesInfo); @@ -571,7 +571,7 @@ BOOST_AUTO_TEST_CASE(FoldPadLayerIntoConvolution2dLayer) armnn::ConstTensor weights(armnn::TensorInfo(4, weightsShape, armnn::DataType::Float32), weightsVector); Convolution2dLayer* conv2dLayer = graph.AddLayer(convolution2dDescriptor, "conv2d"); - conv2dLayer->m_Weight = std::make_unique(weights); + conv2dLayer->m_Weight = std::make_unique(weights); conv2dLayer->GetOutputSlot().SetTensorInfo(outputInfo); Layer* output = graph.AddLayer(0, "output"); @@ -1211,16 +1211,16 @@ BOOST_AUTO_TEST_CASE(OptimizeForExclusiveConnectionsFuseTest) input->GetOutputSlot().SetTensorInfo(inputInfo); conv->GetOutputSlot().SetTensorInfo(outputInfo); batchNorm->GetOutputSlot().SetTensorInfo(outputInfo); - conv->m_Weight = std::make_unique(weights); - batchNorm->m_Beta = std::make_unique(beta); - batchNorm->m_Gamma = std::make_unique(gamma); - batchNorm->m_Mean = std::make_unique(mean); - batchNorm->m_Variance = std::make_unique(variance); + conv->m_Weight = std::make_unique(weights); + batchNorm->m_Beta = std::make_unique(beta); + batchNorm->m_Gamma = std::make_unique(gamma); + batchNorm->m_Mean = std::make_unique(mean); + batchNorm->m_Variance = std::make_unique(variance); if (convolution2dDescriptor.m_BiasEnabled) { std::vector biasVector = { 11 }; ConstTensor bias(TensorInfo(1, outputChannelSize, DataType::Float32), biasVector); - conv->m_Bias = std::make_unique(bias); + conv->m_Bias = std::make_unique(bias); } // Connect layers diff --git a/src/armnn/test/ShapeInferenceTests.cpp b/src/armnn/test/ShapeInferenceTests.cpp index 25b0feaded..fa3f400569 100644 --- a/src/armnn/test/ShapeInferenceTests.cpp +++ b/src/armnn/test/ShapeInferenceTests.cpp @@ -9,8 +9,8 @@ #include #include #include +#include #include -#include #include @@ -240,7 +240,7 @@ BOOST_AUTO_TEST_CASE(ConstantTesst) const float Datum = 0.0f; ConstTensor output0({outputShape, DataType::Float32}, &Datum); - layer->m_LayerOutput = std::make_unique(output0); + layer->m_LayerOutput = std::make_unique(output0); layer->GetOutputSlot(0).SetTensorInfo({{1, 1, 3, 3}, DataType::Float32}); @@ -294,7 +294,7 @@ BOOST_AUTO_TEST_CASE(Convolution2dTest) const float Datum = 0.0f; ConstTensor weights({{1, 1, 3, 3}, DataType::Float32}, &Datum); - layer->m_Weight = std::make_unique(weights); + layer->m_Weight = std::make_unique(weights); RunShapeInferenceTest(layer, {{ 1, 1, 4, 4 }}); } @@ -339,7 +339,7 @@ BOOST_AUTO_TEST_CASE(DepthwiseConvolutionTest) const float Datum = 0.0f; ConstTensor weights({{ 2, 5, 3, 2 }, DataType::Float32}, &Datum); - layer->m_Weight = std::make_unique(weights); + layer->m_Weight = std::make_unique(weights); RunShapeInferenceTest(layer, {{ 8, 18, 1, 2 }}); } @@ -379,7 +379,7 @@ BOOST_AUTO_TEST_CASE(DetectionPostProcessTest) descriptor, "detectionpostprocess"); - layer->m_Anchors = std::make_unique(anchorsTensor); + layer->m_Anchors = std::make_unique(anchorsTensor); RunShapeInferenceTest(layer, {{ 1, 3, 4 }, { 1, 3 }, { 1, 3 }, { 1 }}); } @@ -415,7 +415,7 @@ BOOST_AUTO_TEST_CASE(FullyConnectedTest) const float Datum = 0.0f; ConstTensor weights({{inputChannels, outputChannels}, DataType::Float32}, &Datum); - layer->m_Weight = std::make_unique(weights); + layer->m_Weight = std::make_unique(weights); RunShapeInferenceTest(layer, {{ 1, outputChannels }}); } @@ -469,18 +469,18 @@ BOOST_AUTO_TEST_CASE(LstmTest) float Datum = 0.0f; ConstTensor constTensor({{ 2, 5, 3, 2 }, DataType::Float32}, &Datum); - layer->m_BasicParameters.m_InputToCellWeights = std::make_unique(constTensor); - layer->m_BasicParameters.m_InputToForgetWeights = std::make_unique(constTensor); - layer->m_BasicParameters.m_CellBias = std::make_unique(constTensor); - layer->m_BasicParameters.m_ForgetGateBias = std::make_unique(constTensor); - layer->m_CifgParameters.m_InputGateBias = std::make_unique(constTensor); - layer->m_BasicParameters.m_OutputGateBias = std::make_unique(constTensor); - layer->m_BasicParameters.m_RecurrentToForgetWeights = std::make_unique(constTensor); - layer->m_BasicParameters.m_RecurrentToCellWeights = std::make_unique(constTensor); - layer->m_BasicParameters.m_InputToOutputWeights = std::make_unique(constTensor); - layer->m_BasicParameters.m_RecurrentToOutputWeights = std::make_unique(constTensor); - layer->m_CifgParameters.m_RecurrentToInputWeights = std::make_unique(constTensor); - layer->m_CifgParameters.m_InputToInputWeights = std::make_unique(constTensor); + layer->m_BasicParameters.m_InputToCellWeights = std::make_unique(constTensor); + layer->m_BasicParameters.m_InputToForgetWeights = std::make_unique(constTensor); + layer->m_BasicParameters.m_CellBias = std::make_unique(constTensor); + layer->m_BasicParameters.m_ForgetGateBias = std::make_unique(constTensor); + layer->m_CifgParameters.m_InputGateBias = std::make_unique(constTensor); + layer->m_BasicParameters.m_OutputGateBias = std::make_unique(constTensor); + layer->m_BasicParameters.m_RecurrentToForgetWeights = std::make_unique(constTensor); + layer->m_BasicParameters.m_RecurrentToCellWeights = std::make_unique(constTensor); + layer->m_BasicParameters.m_InputToOutputWeights = std::make_unique(constTensor); + layer->m_BasicParameters.m_RecurrentToOutputWeights = std::make_unique(constTensor); + layer->m_CifgParameters.m_RecurrentToInputWeights = std::make_unique(constTensor); + layer->m_CifgParameters.m_InputToInputWeights = std::make_unique(constTensor); RunShapeInferenceTest(layer, {{2, 80}, {2, 20}, {2, 20}, {2, 20}}); } @@ -557,18 +557,18 @@ BOOST_AUTO_TEST_CASE(QLstmTest) float Datum = 0.0f; ConstTensor constTensor({{ 2, 5, 3, 2 }, DataType::Float32}, &Datum); - layer->m_BasicParameters.m_InputToCellWeights = std::make_unique(constTensor); - layer->m_BasicParameters.m_InputToForgetWeights = std::make_unique(constTensor); - layer->m_BasicParameters.m_CellBias = std::make_unique(constTensor); - layer->m_BasicParameters.m_ForgetGateBias = std::make_unique(constTensor); - layer->m_CifgParameters.m_InputGateBias = std::make_unique(constTensor); - layer->m_BasicParameters.m_OutputGateBias = std::make_unique(constTensor); - layer->m_BasicParameters.m_RecurrentToForgetWeights = std::make_unique(constTensor); - layer->m_BasicParameters.m_RecurrentToCellWeights = std::make_unique(constTensor); - layer->m_BasicParameters.m_InputToOutputWeights = std::make_unique(constTensor); - layer->m_BasicParameters.m_RecurrentToOutputWeights = std::make_unique(constTensor); - layer->m_CifgParameters.m_RecurrentToInputWeights = std::make_unique(constTensor); - layer->m_CifgParameters.m_InputToInputWeights = std::make_unique(constTensor); + layer->m_BasicParameters.m_InputToCellWeights = std::make_unique(constTensor); + layer->m_BasicParameters.m_InputToForgetWeights = std::make_unique(constTensor); + layer->m_BasicParameters.m_CellBias = std::make_unique(constTensor); + layer->m_BasicParameters.m_ForgetGateBias = std::make_unique(constTensor); + layer->m_CifgParameters.m_InputGateBias = std::make_unique(constTensor); + layer->m_BasicParameters.m_OutputGateBias = std::make_unique(constTensor); + layer->m_BasicParameters.m_RecurrentToForgetWeights = std::make_unique(constTensor); + layer->m_BasicParameters.m_RecurrentToCellWeights = std::make_unique(constTensor); + layer->m_BasicParameters.m_InputToOutputWeights = std::make_unique(constTensor); + layer->m_BasicParameters.m_RecurrentToOutputWeights = std::make_unique(constTensor); + layer->m_CifgParameters.m_RecurrentToInputWeights = std::make_unique(constTensor); + layer->m_CifgParameters.m_InputToInputWeights = std::make_unique(constTensor); RunShapeInferenceTest(layer, {{2, 20}, {2, 20}, {2, 20}}); } @@ -585,18 +585,18 @@ BOOST_AUTO_TEST_CASE(QuantizedLstmTest) float Datum = 0.0f; ConstTensor constTensor({{ 2, 5, 3, 2 }, DataType::Float32}, &Datum); - layer->m_QuantizedLstmParameters.m_InputToCellWeights = std::make_unique(constTensor); - layer->m_QuantizedLstmParameters.m_InputToForgetWeights = std::make_unique(constTensor); - layer->m_QuantizedLstmParameters.m_CellBias = std::make_unique(constTensor); - layer->m_QuantizedLstmParameters.m_ForgetGateBias = std::make_unique(constTensor); - layer->m_QuantizedLstmParameters.m_InputGateBias = std::make_unique(constTensor); - layer->m_QuantizedLstmParameters.m_OutputGateBias = std::make_unique(constTensor); - layer->m_QuantizedLstmParameters.m_RecurrentToForgetWeights = std::make_unique(constTensor); - layer->m_QuantizedLstmParameters.m_RecurrentToCellWeights = std::make_unique(constTensor); - layer->m_QuantizedLstmParameters.m_InputToOutputWeights = std::make_unique(constTensor); - layer->m_QuantizedLstmParameters.m_RecurrentToOutputWeights = std::make_unique(constTensor); - layer->m_QuantizedLstmParameters.m_RecurrentToInputWeights = std::make_unique(constTensor); - layer->m_QuantizedLstmParameters.m_InputToInputWeights = std::make_unique(constTensor); + layer->m_QuantizedLstmParameters.m_InputToCellWeights = std::make_unique(constTensor); + layer->m_QuantizedLstmParameters.m_InputToForgetWeights = std::make_unique(constTensor); + layer->m_QuantizedLstmParameters.m_CellBias = std::make_unique(constTensor); + layer->m_QuantizedLstmParameters.m_ForgetGateBias = std::make_unique(constTensor); + layer->m_QuantizedLstmParameters.m_InputGateBias = std::make_unique(constTensor); + layer->m_QuantizedLstmParameters.m_OutputGateBias = std::make_unique(constTensor); + layer->m_QuantizedLstmParameters.m_RecurrentToForgetWeights = std::make_unique(constTensor); + layer->m_QuantizedLstmParameters.m_RecurrentToCellWeights = std::make_unique(constTensor); + layer->m_QuantizedLstmParameters.m_InputToOutputWeights = std::make_unique(constTensor); + layer->m_QuantizedLstmParameters.m_RecurrentToOutputWeights = std::make_unique(constTensor); + layer->m_QuantizedLstmParameters.m_RecurrentToInputWeights = std::make_unique(constTensor); + layer->m_QuantizedLstmParameters.m_InputToInputWeights = std::make_unique(constTensor); RunShapeInferenceTest(layer, {{2, 20}, {2, 20}, {2, 20}}); } diff --git a/src/armnn/test/SubgraphViewTests.cpp b/src/armnn/test/SubgraphViewTests.cpp index 73ef8bea91..ecb876dc7a 100644 --- a/src/armnn/test/SubgraphViewTests.cpp +++ b/src/armnn/test/SubgraphViewTests.cpp @@ -10,7 +10,7 @@ #include -#include +#include #include #include #include diff --git a/src/armnn/test/optimizations/AddBroadcastReshapeLayerTests.cpp b/src/armnn/test/optimizations/AddBroadcastReshapeLayerTests.cpp index 4523e70437..d0d728bfab 100644 --- a/src/armnn/test/optimizations/AddBroadcastReshapeLayerTests.cpp +++ b/src/armnn/test/optimizations/AddBroadcastReshapeLayerTests.cpp @@ -299,7 +299,7 @@ BOOST_AUTO_TEST_CASE(ReshapeParentConstLayerTest) uint8_t tensor[] = { 1, 1, 1, 1, 1 }; - constant->m_LayerOutput = std::make_unique(ConstTensor(info1, &tensor)); + constant->m_LayerOutput = std::make_unique(ConstTensor(info1, &tensor)); input->GetOutputSlot().SetTensorInfo(info0); constant->GetOutputSlot().SetTensorInfo(info1); @@ -357,7 +357,7 @@ BOOST_AUTO_TEST_CASE(ReshapeParentConstAddLayerMultipleConnectionsTest) input->GetOutputSlot().SetTensorInfo(inputInfo); constant->GetOutputSlot().SetTensorInfo(constantTermInfo); float tensor[] = { 2.0f }; - constant->m_LayerOutput = std::make_unique(ConstTensor(constantTermInfo, &tensor)); + constant->m_LayerOutput = std::make_unique(ConstTensor(constantTermInfo, &tensor)); add1->GetOutputSlot().SetTensorInfo(outputInfo); input->GetOutputSlot().Connect(add1->GetInputSlot(0)); diff --git a/src/armnn/test/optimizations/ConvertConstantsBFloatTests.cpp b/src/armnn/test/optimizations/ConvertConstantsBFloatTests.cpp index bb8e674b56..e4c1f2f413 100644 --- a/src/armnn/test/optimizations/ConvertConstantsBFloatTests.cpp +++ b/src/armnn/test/optimizations/ConvertConstantsBFloatTests.cpp @@ -38,7 +38,7 @@ BOOST_AUTO_TEST_CASE(ConvertConstantsFloatToBFloatTest) input->GetOutputSlot().SetTensorInfo(info); auto fc = graph.AddLayer(armnn::FullyConnectedDescriptor(), "fc"); - fc->m_Weight = std::make_unique(weights); + fc->m_Weight = std::make_unique(weights); fc->GetOutputSlot().SetTensorInfo(info); auto output = graph.AddLayer(1, "output"); @@ -94,7 +94,7 @@ BOOST_AUTO_TEST_CASE(ConvertConstantsBFloatToFloatTest) input->GetOutputSlot().SetTensorInfo(info); auto fc = graph.AddLayer(armnn::FullyConnectedDescriptor(), "fc"); - fc->m_Weight = std::make_unique(weights); + fc->m_Weight = std::make_unique(weights); fc->GetOutputSlot().SetTensorInfo(info); auto output = graph.AddLayer(1, "output"); diff --git a/src/armnn/test/optimizations/ConvertConstantsFloatToHalfTests.cpp b/src/armnn/test/optimizations/ConvertConstantsFloatToHalfTests.cpp index 12df462456..1dfe7f431c 100644 --- a/src/armnn/test/optimizations/ConvertConstantsFloatToHalfTests.cpp +++ b/src/armnn/test/optimizations/ConvertConstantsFloatToHalfTests.cpp @@ -31,7 +31,7 @@ BOOST_AUTO_TEST_CASE(ConvertConstantsFloatToHalfTest) input->GetOutputSlot().SetTensorInfo(info); auto fc = graph.AddLayer(armnn::FullyConnectedDescriptor(), "fc"); - fc->m_Weight = std::make_unique(weights); + fc->m_Weight = std::make_unique(weights); fc->GetOutputSlot().SetTensorInfo(info); auto output = graph.AddLayer(1, "output"); diff --git a/src/armnn/test/optimizations/ConvertConstantsHalfToFloatTests.cpp b/src/armnn/test/optimizations/ConvertConstantsHalfToFloatTests.cpp index 7d7c6b2b0a..1ddf5262e8 100644 --- a/src/armnn/test/optimizations/ConvertConstantsHalfToFloatTests.cpp +++ b/src/armnn/test/optimizations/ConvertConstantsHalfToFloatTests.cpp @@ -31,7 +31,7 @@ BOOST_AUTO_TEST_CASE(ConvertConstantsHalfToFloatTest) input->GetOutputSlot().SetTensorInfo(info); auto fc = graph.AddLayer(armnn::FullyConnectedDescriptor(), "fc"); - fc->m_Weight = std::make_unique(weights); + fc->m_Weight = std::make_unique(weights); fc->GetOutputSlot().SetTensorInfo(info); auto output = graph.AddLayer(1, "output"); diff --git a/src/armnn/test/optimizations/Fp32NetworkToBf16ConverterTests.cpp b/src/armnn/test/optimizations/Fp32NetworkToBf16ConverterTests.cpp index a65012eef4..f93fa77b0d 100644 --- a/src/armnn/test/optimizations/Fp32NetworkToBf16ConverterTests.cpp +++ b/src/armnn/test/optimizations/Fp32NetworkToBf16ConverterTests.cpp @@ -72,8 +72,8 @@ BOOST_AUTO_TEST_CASE(Fp32NetworkToBf16OptimizationConv2DTest) armnn::Convolution2dDescriptor descriptor; auto conv = graph.AddLayer(descriptor, "conv2d"); - conv->m_Weight = std::make_unique(weights); - conv->m_Bias = std::make_unique(bias); + conv->m_Weight = std::make_unique(weights); + conv->m_Bias = std::make_unique(bias); conv->GetOutputSlot().SetTensorInfo(infoFP32); auto output = graph.AddLayer(1, "output"); @@ -142,8 +142,8 @@ BOOST_AUTO_TEST_CASE(Fp32NetworkToBf16OptimizationFullyConnectedTest) armnn::FullyConnectedDescriptor descriptor; auto fc = graph.AddLayer(descriptor, "fully"); - fc->m_Weight = std::make_unique(weights); - fc->m_Bias = std::make_unique(bias); + fc->m_Weight = std::make_unique(weights); + fc->m_Bias = std::make_unique(bias); fc->GetOutputSlot().SetTensorInfo(infoFP32); auto output = graph.AddLayer(1, "output"); diff --git a/src/backends/backendsCommon/CMakeLists.txt b/src/backends/backendsCommon/CMakeLists.txt index cf6da807ca..2b48532961 100644 --- a/src/backends/backendsCommon/CMakeLists.txt +++ b/src/backends/backendsCommon/CMakeLists.txt @@ -4,9 +4,8 @@ # list(APPEND armnnBackendsCommon_sources - CpuTensorHandle.cpp - CpuTensorHandle.hpp - CpuTensorHandleFwd.hpp + TensorHandle.cpp + TensorHandle.hpp DynamicBackend.cpp DynamicBackend.hpp DynamicBackendUtils.cpp diff --git a/src/backends/backendsCommon/CpuTensorHandle.cpp b/src/backends/backendsCommon/CpuTensorHandle.cpp deleted file mode 100644 index 192469a633..0000000000 --- a/src/backends/backendsCommon/CpuTensorHandle.cpp +++ /dev/null @@ -1,141 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// -#include -#include - -#include - -#include - -namespace armnn -{ - -TensorShape GetUnpaddedTensorStrides(const TensorInfo& tensorInfo) -{ - TensorShape shape(tensorInfo.GetShape()); - auto size = GetDataTypeSize(tensorInfo.GetDataType()); - auto runningSize = size; - std::vector strides(shape.GetNumDimensions()); - auto lastIdx = shape.GetNumDimensions()-1; - for (unsigned int i=0; i < lastIdx ; i++) - { - strides[lastIdx-i] = runningSize; - runningSize *= shape[lastIdx-i]; - } - strides[0] = runningSize; - return TensorShape(shape.GetNumDimensions(), strides.data()); -} - -ConstCpuTensorHandle::ConstCpuTensorHandle(const TensorInfo& tensorInfo) -: m_TensorInfo(tensorInfo) -, m_Memory(nullptr) -{ -} - -template <> -const void* ConstCpuTensorHandle::GetConstTensor() const -{ - return m_Memory; -} - -CpuTensorHandle::CpuTensorHandle(const TensorInfo& tensorInfo) -: ConstCpuTensorHandle(tensorInfo) -, m_MutableMemory(nullptr) -{ -} - -template <> -void* CpuTensorHandle::GetTensor() const -{ - return m_MutableMemory; -} - -ScopedCpuTensorHandle::ScopedCpuTensorHandle(const TensorInfo& tensorInfo) -: CpuTensorHandle(tensorInfo) -{ -} - -ScopedCpuTensorHandle::ScopedCpuTensorHandle(const ConstTensor& tensor) -: ScopedCpuTensorHandle(tensor.GetInfo()) -{ - CopyFrom(tensor.GetMemoryArea(), tensor.GetNumBytes()); -} - -ScopedCpuTensorHandle::ScopedCpuTensorHandle(const ConstCpuTensorHandle& tensorHandle) -: ScopedCpuTensorHandle(tensorHandle.GetTensorInfo()) -{ - CopyFrom(tensorHandle.GetConstTensor(), tensorHandle.GetTensorInfo().GetNumBytes()); -} - -ScopedCpuTensorHandle::ScopedCpuTensorHandle(const ScopedCpuTensorHandle& other) -: CpuTensorHandle(other.GetTensorInfo()) -{ - CopyFrom(other); -} - -ScopedCpuTensorHandle& ScopedCpuTensorHandle::operator=(const ScopedCpuTensorHandle& other) -{ - ::operator delete(GetTensor()); - SetMemory(nullptr); - CopyFrom(other); - return *this; -} - -ScopedCpuTensorHandle::~ScopedCpuTensorHandle() -{ - ::operator delete(GetTensor()); -} - -void ScopedCpuTensorHandle::Allocate() -{ - if (GetTensor() == nullptr) - { - SetMemory(::operator new(GetTensorInfo().GetNumBytes())); - } - else - { - throw InvalidArgumentException("CpuTensorHandle::Allocate Trying to allocate a CpuTensorHandle" - "that already has allocated memory."); - } -} - -void ScopedCpuTensorHandle::CopyOutTo(void* memory) const -{ - memcpy(memory, GetTensor(), GetTensorInfo().GetNumBytes()); -} - -void ScopedCpuTensorHandle::CopyInFrom(const void* memory) -{ - memcpy(GetTensor(), memory, GetTensorInfo().GetNumBytes()); -} - -void ScopedCpuTensorHandle::CopyFrom(const ScopedCpuTensorHandle& other) -{ - CopyFrom(other.GetTensor(), other.GetTensorInfo().GetNumBytes()); -} - -void ScopedCpuTensorHandle::CopyFrom(const void* srcMemory, unsigned int numBytes) -{ - ARMNN_ASSERT(GetTensor() == nullptr); - ARMNN_ASSERT(GetTensorInfo().GetNumBytes() == numBytes); - - if (srcMemory) - { - Allocate(); - memcpy(GetTensor(), srcMemory, numBytes); - } -} - -void PassthroughCpuTensorHandle::Allocate() -{ - throw InvalidArgumentException("PassthroughCpuTensorHandle::Allocate() should never be called"); -} - -void ConstPassthroughCpuTensorHandle::Allocate() -{ - throw InvalidArgumentException("ConstPassthroughCpuTensorHandle::Allocate() should never be called"); -} - -} // namespace armnn diff --git a/src/backends/backendsCommon/CpuTensorHandle.hpp b/src/backends/backendsCommon/CpuTensorHandle.hpp deleted file mode 100644 index fdd2439b41..0000000000 --- a/src/backends/backendsCommon/CpuTensorHandle.hpp +++ /dev/null @@ -1,245 +0,0 @@ -// -// Copyright © 2017 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -#pragma once - -#include -#include - -#include - -#include - -#include - -#include - -namespace armnn -{ - -// Get a TensorShape representing the strides (in bytes) for each dimension -// of a tensor, assuming fully packed data with no padding -TensorShape GetUnpaddedTensorStrides(const TensorInfo& tensorInfo); - -// Abstract tensor handles wrapping a CPU-readable region of memory, interpreting it as tensor data. -class ConstCpuTensorHandle : public ITensorHandle -{ -public: - template - const T* GetConstTensor() const - { - ARMNN_ASSERT(CompatibleTypes(GetTensorInfo().GetDataType())); - return reinterpret_cast(m_Memory); - } - - const TensorInfo& GetTensorInfo() const - { - return m_TensorInfo; - } - - virtual void Manage() override {} - - virtual ITensorHandle* GetParent() const override { return nullptr; } - - virtual const void* Map(bool /* blocking = true */) const override { return m_Memory; } - virtual void Unmap() const override {} - - TensorShape GetStrides() const override - { - return GetUnpaddedTensorStrides(m_TensorInfo); - } - TensorShape GetShape() const override { return m_TensorInfo.GetShape(); } - -protected: - ConstCpuTensorHandle(const TensorInfo& tensorInfo); - - void SetConstMemory(const void* mem) { m_Memory = mem; } - -private: - // Only used for testing - void CopyOutTo(void *) const override { ARMNN_ASSERT_MSG(false, "Unimplemented"); } - void CopyInFrom(const void*) override { ARMNN_ASSERT_MSG(false, "Unimplemented"); } - - ConstCpuTensorHandle(const ConstCpuTensorHandle& other) = delete; - ConstCpuTensorHandle& operator=(const ConstCpuTensorHandle& other) = delete; - - TensorInfo m_TensorInfo; - const void* m_Memory; -}; - -template<> -const void* ConstCpuTensorHandle::GetConstTensor() const; - -// Abstract specialization of ConstCpuTensorHandle that allows write access to the same data. -class CpuTensorHandle : public ConstCpuTensorHandle -{ -public: - template - T* GetTensor() const - { - ARMNN_ASSERT(CompatibleTypes(GetTensorInfo().GetDataType())); - return reinterpret_cast(m_MutableMemory); - } - -protected: - CpuTensorHandle(const TensorInfo& tensorInfo); - - void SetMemory(void* mem) - { - m_MutableMemory = mem; - SetConstMemory(m_MutableMemory); - } - -private: - - CpuTensorHandle(const CpuTensorHandle& other) = delete; - CpuTensorHandle& operator=(const CpuTensorHandle& other) = delete; - void* m_MutableMemory; -}; - -template <> -void* CpuTensorHandle::GetTensor() const; - -// A CpuTensorHandle that owns the wrapped memory region. -class ScopedCpuTensorHandle : public CpuTensorHandle -{ -public: - explicit ScopedCpuTensorHandle(const TensorInfo& tensorInfo); - - // Copies contents from Tensor. - explicit ScopedCpuTensorHandle(const ConstTensor& tensor); - - // Copies contents from ConstCpuTensorHandle - explicit ScopedCpuTensorHandle(const ConstCpuTensorHandle& tensorHandle); - - ScopedCpuTensorHandle(const ScopedCpuTensorHandle& other); - ScopedCpuTensorHandle& operator=(const ScopedCpuTensorHandle& other); - ~ScopedCpuTensorHandle(); - - virtual void Allocate() override; - -private: - // Only used for testing - void CopyOutTo(void* memory) const override; - void CopyInFrom(const void* memory) override; - - void CopyFrom(const ScopedCpuTensorHandle& other); - void CopyFrom(const void* srcMemory, unsigned int numBytes); -}; - -// A CpuTensorHandle that wraps an already allocated memory region. -// -// Clients must make sure the passed in memory region stays alive for the lifetime of -// the PassthroughCpuTensorHandle instance. -// -// Note there is no polymorphism to/from ConstPassthroughCpuTensorHandle. -class PassthroughCpuTensorHandle : public CpuTensorHandle -{ -public: - PassthroughCpuTensorHandle(const TensorInfo& tensorInfo, void* mem) - : CpuTensorHandle(tensorInfo) - { - SetMemory(mem); - } - - virtual void Allocate() override; -}; - -// A ConstCpuTensorHandle that wraps an already allocated memory region. -// -// This allows users to pass in const memory to a network. -// Clients must make sure the passed in memory region stays alive for the lifetime of -// the PassthroughCpuTensorHandle instance. -// -// Note there is no polymorphism to/from PassthroughCpuTensorHandle. -class ConstPassthroughCpuTensorHandle : public ConstCpuTensorHandle -{ -public: - ConstPassthroughCpuTensorHandle(const TensorInfo& tensorInfo, const void* mem) - : ConstCpuTensorHandle(tensorInfo) - { - SetConstMemory(mem); - } - - virtual void Allocate() override; -}; - - -// Template specializations. - -template <> -const void* ConstCpuTensorHandle::GetConstTensor() const; - -template <> -void* CpuTensorHandle::GetTensor() const; - -class ManagedConstTensorHandle -{ - -public: - explicit ManagedConstTensorHandle(std::shared_ptr ptr) - : m_Mapped(false) - , m_TensorHandle(std::move(ptr)) {}; - - /// RAII Managed resource Unmaps MemoryArea once out of scope - const void* Map(bool blocking = true) - { - if (m_TensorHandle) - { - auto pRet = m_TensorHandle->Map(blocking); - m_Mapped = true; - return pRet; - } - else - { - throw armnn::Exception("Attempting to Map null TensorHandle"); - } - - } - - // Delete copy constructor as it's unnecessary - ManagedConstTensorHandle(const ConstCpuTensorHandle& other) = delete; - - // Delete copy assignment as it's unnecessary - ManagedConstTensorHandle& operator=(const ManagedConstTensorHandle& other) = delete; - - // Delete move assignment as it's unnecessary - ManagedConstTensorHandle& operator=(ManagedConstTensorHandle&& other) noexcept = delete; - - ~ManagedConstTensorHandle() - { - // Bias tensor handles need to be initialized empty before entering scope of if statement checking if enabled - if (m_TensorHandle) - { - Unmap(); - } - } - - void Unmap() - { - // Only unmap if mapped and TensorHandle exists. - if (m_Mapped && m_TensorHandle) - { - m_TensorHandle->Unmap(); - m_Mapped = false; - } - } - - const TensorInfo& GetTensorInfo() const - { - return m_TensorHandle->GetTensorInfo(); - } - - bool IsMapped() const - { - return m_Mapped; - } - -private: - bool m_Mapped; - std::shared_ptr m_TensorHandle; -}; - -} // namespace armnn diff --git a/src/backends/backendsCommon/CpuTensorHandleFwd.hpp b/src/backends/backendsCommon/CpuTensorHandleFwd.hpp deleted file mode 100644 index aef48b5a92..0000000000 --- a/src/backends/backendsCommon/CpuTensorHandleFwd.hpp +++ /dev/null @@ -1,9 +0,0 @@ -// -// Copyright © 2019 Arm Ltd. All rights reserved. -// SPDX-License-Identifier: MIT -// - -// This file is depricated and will be removed soon. -// Please use the new header in armnn/backends instead. -// This will use the new armnn/backends header. -#include diff --git a/src/backends/backendsCommon/MemCopyWorkload.cpp b/src/backends/backendsCommon/MemCopyWorkload.cpp index 813adefed7..946de30430 100644 --- a/src/backends/backendsCommon/MemCopyWorkload.cpp +++ b/src/backends/backendsCommon/MemCopyWorkload.cpp @@ -6,7 +6,7 @@ #include #include -#include +#include #include diff --git a/src/backends/backendsCommon/MemCopyWorkload.hpp b/src/backends/backendsCommon/MemCopyWorkload.hpp index 12664fd527..99845f397f 100644 --- a/src/backends/backendsCommon/MemCopyWorkload.hpp +++ b/src/backends/backendsCommon/MemCopyWorkload.hpp @@ -7,7 +7,7 @@ #include "Workload.hpp" #include "WorkloadUtils.hpp" -#include +#include #include diff --git a/src/backends/backendsCommon/MemImportWorkload.cpp b/src/backends/backendsCommon/MemImportWorkload.cpp index 6584e407e9..844908f27b 100644 --- a/src/backends/backendsCommon/MemImportWorkload.cpp +++ b/src/backends/backendsCommon/MemImportWorkload.cpp @@ -6,7 +6,7 @@ #include #include -#include +#include #include diff --git a/src/backends/backendsCommon/MemImportWorkload.hpp b/src/backends/backendsCommon/MemImportWorkload.hpp index 33297fbc6f..d3c57239bd 100644 --- a/src/backends/backendsCommon/MemImportWorkload.hpp +++ b/src/backends/backendsCommon/MemImportWorkload.hpp @@ -7,7 +7,7 @@ #include "Workload.hpp" #include "WorkloadUtils.hpp" -#include +#include #include diff --git a/src/backends/backendsCommon/MemSyncWorkload.cpp b/src/backends/backendsCommon/MemSyncWorkload.cpp index fe04a3024b..9025e665c9 100644 --- a/src/backends/backendsCommon/MemSyncWorkload.cpp +++ b/src/backends/backendsCommon/MemSyncWorkload.cpp @@ -6,7 +6,7 @@ #include #include -#include +#include #include diff --git a/src/backends/backendsCommon/MemSyncWorkload.hpp b/src/backends/backendsCommon/MemSyncWorkload.hpp index 8142f180a6..7b59a0b55f 100644 --- a/src/backends/backendsCommon/MemSyncWorkload.hpp +++ b/src/backends/backendsCommon/MemSyncWorkload.hpp @@ -7,7 +7,7 @@ #include "Workload.hpp" #include "WorkloadUtils.hpp" -#include +#include #include diff --git a/src/backends/backendsCommon/TensorHandle.cpp b/src/backends/backendsCommon/TensorHandle.cpp new file mode 100644 index 0000000000..d4660d6de3 --- /dev/null +++ b/src/backends/backendsCommon/TensorHandle.cpp @@ -0,0 +1,141 @@ +// +// Copyright © 2021 Arm Ltd and Contributors. All rights reserved. +// SPDX-License-Identifier: MIT +// +#include +#include + +#include + +#include + +namespace armnn +{ + +TensorShape GetUnpaddedTensorStrides(const TensorInfo& tensorInfo) +{ + TensorShape shape(tensorInfo.GetShape()); + auto size = GetDataTypeSize(tensorInfo.GetDataType()); + auto runningSize = size; + std::vector strides(shape.GetNumDimensions()); + auto lastIdx = shape.GetNumDimensions()-1; + for (unsigned int i=0; i < lastIdx ; i++) + { + strides[lastIdx-i] = runningSize; + runningSize *= shape[lastIdx-i]; + } + strides[0] = runningSize; + return TensorShape(shape.GetNumDimensions(), strides.data()); +} + +ConstTensorHandle::ConstTensorHandle(const TensorInfo& tensorInfo) +: m_TensorInfo(tensorInfo) +, m_Memory(nullptr) +{ +} + +template <> +const void* ConstTensorHandle::GetConstTensor() const +{ + return m_Memory; +} + +TensorHandle::TensorHandle(const TensorInfo& tensorInfo) +: ConstTensorHandle(tensorInfo) +, m_MutableMemory(nullptr) +{ +} + +template <> +void* TensorHandle::GetTensor() const +{ + return m_MutableMemory; +} + +ScopedTensorHandle::ScopedTensorHandle(const TensorInfo& tensorInfo) +: TensorHandle(tensorInfo) +{ +} + +ScopedTensorHandle::ScopedTensorHandle(const ConstTensor& tensor) +: ScopedTensorHandle(tensor.GetInfo()) +{ + CopyFrom(tensor.GetMemoryArea(), tensor.GetNumBytes()); +} + +ScopedTensorHandle::ScopedTensorHandle(const ConstTensorHandle& tensorHandle) +: ScopedTensorHandle(tensorHandle.GetTensorInfo()) +{ + CopyFrom(tensorHandle.GetConstTensor(), tensorHandle.GetTensorInfo().GetNumBytes()); +} + +ScopedTensorHandle::ScopedTensorHandle(const ScopedTensorHandle& other) +: TensorHandle(other.GetTensorInfo()) +{ + CopyFrom(other); +} + +ScopedTensorHandle& ScopedTensorHandle::operator=(const ScopedTensorHandle& other) +{ + ::operator delete(GetTensor()); + SetMemory(nullptr); + CopyFrom(other); + return *this; +} + +ScopedTensorHandle::~ScopedTensorHandle() +{ + ::operator delete(GetTensor()); +} + +void ScopedTensorHandle::Allocate() +{ + if (GetTensor() == nullptr) + { + SetMemory(::operator new(GetTensorInfo().GetNumBytes())); + } + else + { + throw InvalidArgumentException("TensorHandle::Allocate Trying to allocate a TensorHandle" + "that already has allocated memory."); + } +} + +void ScopedTensorHandle::CopyOutTo(void* memory) const +{ + memcpy(memory, GetTensor(), GetTensorInfo().GetNumBytes()); +} + +void ScopedTensorHandle::CopyInFrom(const void* memory) +{ + memcpy(GetTensor(), memory, GetTensorInfo().GetNumBytes()); +} + +void ScopedTensorHandle::CopyFrom(const ScopedTensorHandle& other) +{ + CopyFrom(other.GetTensor(), other.GetTensorInfo().GetNumBytes()); +} + +void ScopedTensorHandle::CopyFrom(const void* srcMemory, unsigned int numBytes) +{ + ARMNN_ASSERT(GetTensor() == nullptr); + ARMNN_ASSERT(GetTensorInfo().GetNumBytes() == numBytes); + + if (srcMemory) + { + Allocate(); + memcpy(GetTensor(), srcMemory, numBytes); + } +} + +void PassthroughTensorHandle::Allocate() +{ + throw InvalidArgumentException("PassthroughTensorHandle::Allocate() should never be called"); +} + +void ConstPassthroughTensorHandle::Allocate() +{ + throw InvalidArgumentException("ConstPassthroughTensorHandle::Allocate() should never be called"); +} + +} // namespace armnn diff --git a/src/backends/backendsCommon/TensorHandle.hpp b/src/backends/backendsCommon/TensorHandle.hpp new file mode 100644 index 0000000000..4e9d87d6eb --- /dev/null +++ b/src/backends/backendsCommon/TensorHandle.hpp @@ -0,0 +1,257 @@ +// +// Copyright © 2021 Arm Ltd and Contributors. All rights reserved. +// SPDX-License-Identifier: MIT +// + +#pragma once + +#include +#include + +#include + +#include + +#include + +#include + +namespace armnn +{ + +// Get a TensorShape representing the strides (in bytes) for each dimension +// of a tensor, assuming fully packed data with no padding +TensorShape GetUnpaddedTensorStrides(const TensorInfo& tensorInfo); + +// Abstract tensor handles wrapping a readable region of memory, interpreting it as tensor data. +class ConstTensorHandle : public ITensorHandle +{ +public: + template + const T* GetConstTensor() const + { + ARMNN_ASSERT(CompatibleTypes(GetTensorInfo().GetDataType())); + return reinterpret_cast(m_Memory); + } + + const TensorInfo& GetTensorInfo() const + { + return m_TensorInfo; + } + + virtual void Manage() override {} + + virtual ITensorHandle* GetParent() const override { return nullptr; } + + virtual const void* Map(bool /* blocking = true */) const override { return m_Memory; } + virtual void Unmap() const override {} + + TensorShape GetStrides() const override + { + return GetUnpaddedTensorStrides(m_TensorInfo); + } + TensorShape GetShape() const override { return m_TensorInfo.GetShape(); } + +protected: + ConstTensorHandle(const TensorInfo& tensorInfo); + + void SetConstMemory(const void* mem) { m_Memory = mem; } + +private: + // Only used for testing + void CopyOutTo(void *) const override { ARMNN_ASSERT_MSG(false, "Unimplemented"); } + void CopyInFrom(const void*) override { ARMNN_ASSERT_MSG(false, "Unimplemented"); } + + ConstTensorHandle(const ConstTensorHandle& other) = delete; + ConstTensorHandle& operator=(const ConstTensorHandle& other) = delete; + + TensorInfo m_TensorInfo; + const void* m_Memory; +}; + +template<> +const void* ConstTensorHandle::GetConstTensor() const; + +// Abstract specialization of ConstTensorHandle that allows write access to the same data. +class TensorHandle : public ConstTensorHandle +{ +public: + template + T* GetTensor() const + { + ARMNN_ASSERT(CompatibleTypes(GetTensorInfo().GetDataType())); + return reinterpret_cast(m_MutableMemory); + } + +protected: + TensorHandle(const TensorInfo& tensorInfo); + + void SetMemory(void* mem) + { + m_MutableMemory = mem; + SetConstMemory(m_MutableMemory); + } + +private: + + TensorHandle(const TensorHandle& other) = delete; + TensorHandle& operator=(const TensorHandle& other) = delete; + void* m_MutableMemory; +}; + +template <> +void* TensorHandle::GetTensor() const; + +// A TensorHandle that owns the wrapped memory region. +class ScopedTensorHandle : public TensorHandle +{ +public: + explicit ScopedTensorHandle(const TensorInfo& tensorInfo); + + // Copies contents from Tensor. + explicit ScopedTensorHandle(const ConstTensor& tensor); + + // Copies contents from ConstTensorHandle + explicit ScopedTensorHandle(const ConstTensorHandle& tensorHandle); + + ScopedTensorHandle(const ScopedTensorHandle& other); + ScopedTensorHandle& operator=(const ScopedTensorHandle& other); + ~ScopedTensorHandle(); + + virtual void Allocate() override; + +private: + // Only used for testing + void CopyOutTo(void* memory) const override; + void CopyInFrom(const void* memory) override; + + void CopyFrom(const ScopedTensorHandle& other); + void CopyFrom(const void* srcMemory, unsigned int numBytes); +}; + +// A TensorHandle that wraps an already allocated memory region. +// +// Clients must make sure the passed in memory region stays alive for the lifetime of +// the PassthroughTensorHandle instance. +// +// Note there is no polymorphism to/from ConstPassthroughTensorHandle. +class PassthroughTensorHandle : public TensorHandle +{ +public: + PassthroughTensorHandle(const TensorInfo& tensorInfo, void* mem) + : TensorHandle(tensorInfo) + { + SetMemory(mem); + } + + virtual void Allocate() override; +}; + +// A ConstTensorHandle that wraps an already allocated memory region. +// +// This allows users to pass in const memory to a network. +// Clients must make sure the passed in memory region stays alive for the lifetime of +// the PassthroughTensorHandle instance. +// +// Note there is no polymorphism to/from PassthroughTensorHandle. +class ConstPassthroughTensorHandle : public ConstTensorHandle +{ +public: + ConstPassthroughTensorHandle(const TensorInfo& tensorInfo, const void* mem) + : ConstTensorHandle(tensorInfo) + { + SetConstMemory(mem); + } + + virtual void Allocate() override; +}; + + +// Template specializations. + +template <> +const void* ConstTensorHandle::GetConstTensor() const; + +template <> +void* TensorHandle::GetTensor() const; + +class ManagedConstTensorHandle +{ + +public: + explicit ManagedConstTensorHandle(std::shared_ptr ptr) + : m_Mapped(false) + , m_TensorHandle(std::move(ptr)) {}; + + /// RAII Managed resource Unmaps MemoryArea once out of scope + const void* Map(bool blocking = true) + { + if (m_TensorHandle) + { + auto pRet = m_TensorHandle->Map(blocking); + m_Mapped = true; + return pRet; + } + else + { + throw armnn::Exception("Attempting to Map null TensorHandle"); + } + + } + + // Delete copy constructor as it's unnecessary + ManagedConstTensorHandle(const ConstTensorHandle& other) = delete; + + // Delete copy assignment as it's unnecessary + ManagedConstTensorHandle& operator=(const ManagedConstTensorHandle& other) = delete; + + // Delete move assignment as it's unnecessary + ManagedConstTensorHandle& operator=(ManagedConstTensorHandle&& other) noexcept = delete; + + ~ManagedConstTensorHandle() + { + // Bias tensor handles need to be initialized empty before entering scope of if statement checking if enabled + if (m_TensorHandle) + { + Unmap(); + } + } + + void Unmap() + { + // Only unmap if mapped and TensorHandle exists. + if (m_Mapped && m_TensorHandle) + { + m_TensorHandle->Unmap(); + m_Mapped = false; + } + } + + const TensorInfo& GetTensorInfo() const + { + return m_TensorHandle->GetTensorInfo(); + } + + bool IsMapped() const + { + return m_Mapped; + } + +private: + bool m_Mapped; + std::shared_ptr m_TensorHandle; +}; + +using ConstCpuTensorHandle ARMNN_DEPRECATED_MSG("ConstCpuTensorHandle is deprecated, " + "use ConstTensorHandle instead") = ConstTensorHandle; +using CpuTensorHandle ARMNN_DEPRECATED_MSG("CpuTensorHandle is deprecated, " + "use TensorHandle instead") = TensorHandle; +using ScopedCpuTensorHandle ARMNN_DEPRECATED_MSG("ScopedCpuTensorHandle is deprecated, " + "use ScopedTensorHandle instead") = ScopedTensorHandle; +using PassthroughCpuTensorHandle ARMNN_DEPRECATED_MSG("PassthroughCpuTensorHandle is deprecated, use " + "PassthroughTensorHandle instead") = PassthroughTensorHandle; +using ConstPassthroughCpuTensorHandle ARMNN_DEPRECATED_MSG("ConstPassthroughCpuTensorHandle is " + "deprecated, use ConstPassthroughTensorHandle " + "instead") = ConstPassthroughTensorHandle; + +} // namespace armnn diff --git a/src/backends/backendsCommon/WorkloadData.cpp b/src/backends/backendsCommon/WorkloadData.cpp index 470d460ef3..be0ac707a8 100644 --- a/src/backends/backendsCommon/WorkloadData.cpp +++ b/src/backends/backendsCommon/WorkloadData.cpp @@ -3,8 +3,8 @@ // SPDX-License-Identifier: MIT // +#include #include -#include #include #include #include diff --git a/src/backends/backendsCommon/WorkloadData.hpp b/src/backends/backendsCommon/WorkloadData.hpp index abaa4f5185..77d4209657 100644 --- a/src/backends/backendsCommon/WorkloadData.hpp +++ b/src/backends/backendsCommon/WorkloadData.hpp @@ -4,7 +4,7 @@ // #pragma once -#include +#include #include #include @@ -175,8 +175,8 @@ struct FullyConnectedQueueDescriptor : QueueDescriptorWithParameters { } - const ConstCpuTensorHandle* m_InputToInputWeights; - const ConstCpuTensorHandle* m_InputToForgetWeights; - const ConstCpuTensorHandle* m_InputToCellWeights; - const ConstCpuTensorHandle* m_InputToOutputWeights; - const ConstCpuTensorHandle* m_RecurrentToInputWeights; - const ConstCpuTensorHandle* m_RecurrentToForgetWeights; - const ConstCpuTensorHandle* m_RecurrentToCellWeights; - const ConstCpuTensorHandle* m_RecurrentToOutputWeights; - const ConstCpuTensorHandle* m_CellToInputWeights; - const ConstCpuTensorHandle* m_CellToForgetWeights; - const ConstCpuTensorHandle* m_CellToOutputWeights; - const ConstCpuTensorHandle* m_InputGateBias; - const ConstCpuTensorHandle* m_ForgetGateBias; - const ConstCpuTensorHandle* m_CellBias; - const ConstCpuTensorHandle* m_OutputGateBias; - const ConstCpuTensorHandle* m_ProjectionWeights; - const ConstCpuTensorHandle* m_ProjectionBias; - const ConstCpuTensorHandle* m_InputLayerNormWeights; - const ConstCpuTensorHandle* m_ForgetLayerNormWeights; - const ConstCpuTensorHandle* m_CellLayerNormWeights; - const ConstCpuTensorHandle* m_OutputLayerNormWeights; + const ConstTensorHandle* m_InputToInputWeights; + const ConstTensorHandle* m_InputToForgetWeights; + const ConstTensorHandle* m_InputToCellWeights; + const ConstTensorHandle* m_InputToOutputWeights; + const ConstTensorHandle* m_RecurrentToInputWeights; + const ConstTensorHandle* m_RecurrentToForgetWeights; + const ConstTensorHandle* m_RecurrentToCellWeights; + const ConstTensorHandle* m_RecurrentToOutputWeights; + const ConstTensorHandle* m_CellToInputWeights; + const ConstTensorHandle* m_CellToForgetWeights; + const ConstTensorHandle* m_CellToOutputWeights; + const ConstTensorHandle* m_InputGateBias; + const ConstTensorHandle* m_ForgetGateBias; + const ConstTensorHandle* m_CellBias; + const ConstTensorHandle* m_OutputGateBias; + const ConstTensorHandle* m_ProjectionWeights; + const ConstTensorHandle* m_ProjectionBias; + const ConstTensorHandle* m_InputLayerNormWeights; + const ConstTensorHandle* m_ForgetLayerNormWeights; + const ConstTensorHandle* m_CellLayerNormWeights; + const ConstTensorHandle* m_OutputLayerNormWeights; void Validate(const WorkloadInfo& workloadInfo) const; }; @@ -543,8 +543,8 @@ struct TransposeConvolution2dQueueDescriptor : QueueDescriptorWithParameters { } - const ConstCpuTensorHandle* m_InputToInputWeights; - const ConstCpuTensorHandle* m_InputToForgetWeights; - const ConstCpuTensorHandle* m_InputToCellWeights; - const ConstCpuTensorHandle* m_InputToOutputWeights; - const ConstCpuTensorHandle* m_RecurrentToInputWeights; - const ConstCpuTensorHandle* m_RecurrentToForgetWeights; - const ConstCpuTensorHandle* m_RecurrentToCellWeights; - const ConstCpuTensorHandle* m_RecurrentToOutputWeights; - const ConstCpuTensorHandle* m_CellToInputWeights; - const ConstCpuTensorHandle* m_CellToForgetWeights; - const ConstCpuTensorHandle* m_CellToOutputWeights; - const ConstCpuTensorHandle* m_InputGateBias; - const ConstCpuTensorHandle* m_ForgetGateBias; - const ConstCpuTensorHandle* m_CellBias; - const ConstCpuTensorHandle* m_OutputGateBias; - const ConstCpuTensorHandle* m_ProjectionWeights; - const ConstCpuTensorHandle* m_ProjectionBias; - const ConstCpuTensorHandle* m_InputLayerNormWeights; - const ConstCpuTensorHandle* m_ForgetLayerNormWeights; - const ConstCpuTensorHandle* m_CellLayerNormWeights; - const ConstCpuTensorHandle* m_OutputLayerNormWeights; + const ConstTensorHandle* m_InputToInputWeights; + const ConstTensorHandle* m_InputToForgetWeights; + const ConstTensorHandle* m_InputToCellWeights; + const ConstTensorHandle* m_InputToOutputWeights; + const ConstTensorHandle* m_RecurrentToInputWeights; + const ConstTensorHandle* m_RecurrentToForgetWeights; + const ConstTensorHandle* m_RecurrentToCellWeights; + const ConstTensorHandle* m_RecurrentToOutputWeights; + const ConstTensorHandle* m_CellToInputWeights; + const ConstTensorHandle* m_CellToForgetWeights; + const ConstTensorHandle* m_CellToOutputWeights; + const ConstTensorHandle* m_InputGateBias; + const ConstTensorHandle* m_ForgetGateBias; + const ConstTensorHandle* m_CellBias; + const ConstTensorHandle* m_OutputGateBias; + const ConstTensorHandle* m_ProjectionWeights; + const ConstTensorHandle* m_ProjectionBias; + const ConstTensorHandle* m_InputLayerNormWeights; + const ConstTensorHandle* m_ForgetLayerNormWeights; + const ConstTensorHandle* m_CellLayerNormWeights; + const ConstTensorHandle* m_OutputLayerNormWeights; void Validate(const WorkloadInfo& workloadInfo) const; }; @@ -625,20 +625,20 @@ struct QuantizedLstmQueueDescriptor : QueueDescriptor , m_OutputGateBias(nullptr) {} - const ConstCpuTensorHandle* m_InputToInputWeights; - const ConstCpuTensorHandle* m_InputToForgetWeights; - const ConstCpuTensorHandle* m_InputToCellWeights; - const ConstCpuTensorHandle* m_InputToOutputWeights; + const ConstTensorHandle* m_InputToInputWeights; + const ConstTensorHandle* m_InputToForgetWeights; + const ConstTensorHandle* m_InputToCellWeights; + const ConstTensorHandle* m_InputToOutputWeights; - const ConstCpuTensorHandle* m_RecurrentToInputWeights; - const ConstCpuTensorHandle* m_RecurrentToForgetWeights; - const ConstCpuTensorHandle* m_RecurrentToCellWeights; - const ConstCpuTensorHandle* m_RecurrentToOutputWeights; + const ConstTensorHandle* m_RecurrentToInputWeights; + const ConstTensorHandle* m_RecurrentToForgetWeights; + const ConstTensorHandle* m_RecurrentToCellWeights; + const ConstTensorHandle* m_RecurrentToOutputWeights; - const ConstCpuTensorHandle* m_InputGateBias; - const ConstCpuTensorHandle* m_ForgetGateBias; - const ConstCpuTensorHandle* m_CellBias; - const ConstCpuTensorHandle* m_OutputGateBias; + const ConstTensorHandle* m_InputGateBias; + const ConstTensorHandle* m_ForgetGateBias; + const ConstTensorHandle* m_CellBias; + const ConstTensorHandle* m_OutputGateBias; void Validate(const WorkloadInfo& workloadInfo) const; }; diff --git a/src/backends/backendsCommon/WorkloadFactory.cpp b/src/backends/backendsCommon/WorkloadFactory.cpp index 733d77e427..c5fc9d0fe2 100644 --- a/src/backends/backendsCommon/WorkloadFactory.cpp +++ b/src/backends/backendsCommon/WorkloadFactory.cpp @@ -15,7 +15,7 @@ #include #include -#include +#include #include diff --git a/src/backends/backendsCommon/WorkloadUtils.cpp b/src/backends/backendsCommon/WorkloadUtils.cpp index 5886630cd9..c8105aea04 100644 --- a/src/backends/backendsCommon/WorkloadUtils.cpp +++ b/src/backends/backendsCommon/WorkloadUtils.cpp @@ -11,7 +11,7 @@ namespace armnn { -armnn::ConstTensor PermuteTensor(const ConstCpuTensorHandle* tensor, +armnn::ConstTensor PermuteTensor(const ConstTensorHandle* tensor, const PermutationVector& permutationVector, void* permuteBuffer) { ARMNN_ASSERT_MSG(tensor, "Invalid input tensor"); @@ -130,7 +130,7 @@ TensorInfo ConvertWeightTensorInfoFromArmnnToAcl(const TensorInfo& weightInfo, D return weightPermutedInfo; } -armnn::ConstTensor ConvertWeightTensorFromArmnnToAcl(const ConstCpuTensorHandle* weightTensor, +armnn::ConstTensor ConvertWeightTensorFromArmnnToAcl(const ConstTensorHandle* weightTensor, DataLayout dataLayout, void* permuteBuffer) { diff --git a/src/backends/backendsCommon/WorkloadUtils.hpp b/src/backends/backendsCommon/WorkloadUtils.hpp index 354362ec8f..06d2eccf3e 100644 --- a/src/backends/backendsCommon/WorkloadUtils.hpp +++ b/src/backends/backendsCommon/WorkloadUtils.hpp @@ -5,7 +5,7 @@ #pragma once -#include "CpuTensorHandle.hpp" +#include "TensorHandle.hpp" #include #include @@ -206,7 +206,7 @@ void GatherTensorHandlePairs(const DescriptorType& descriptor, int32_t ConvertMaskToACLFormat(int32_t mask, int32_t numDim); -armnn::ConstTensor PermuteTensor(const ConstCpuTensorHandle* tensor, +armnn::ConstTensor PermuteTensor(const ConstTensorHandle* tensor, const PermutationVector& permutationVector, void* permuteBuffer); @@ -214,7 +214,7 @@ void ReshapeWeightsForAcl(TensorInfo& weightInfo, DataLayout dataLayout); TensorInfo ConvertWeightTensorInfoFromArmnnToAcl(const TensorInfo& weightInfo, DataLayout dataLayout); -armnn::ConstTensor ConvertWeightTensorFromArmnnToAcl(const ConstCpuTensorHandle* weightTensor, +armnn::ConstTensor ConvertWeightTensorFromArmnnToAcl(const ConstTensorHandle* weightTensor, DataLayout dataLayout, void* permuteBuffer); diff --git a/src/backends/backendsCommon/common.mk b/src/backends/backendsCommon/common.mk index 6e4a8c75d2..63d768eca5 100644 --- a/src/backends/backendsCommon/common.mk +++ b/src/backends/backendsCommon/common.mk @@ -8,7 +8,7 @@ # file in the root of ArmNN COMMON_SOURCES := \ - CpuTensorHandle.cpp \ + TensorHandle.cpp \ DynamicBackend.cpp \ DynamicBackendUtils.cpp \ IBackendInternal.cpp \ diff --git a/src/backends/backendsCommon/test/CommonTestUtils.hpp b/src/backends/backendsCommon/test/CommonTestUtils.hpp index 8c4da621ed..99412b9694 100644 --- a/src/backends/backendsCommon/test/CommonTestUtils.hpp +++ b/src/backends/backendsCommon/test/CommonTestUtils.hpp @@ -13,7 +13,7 @@ #include #include -#include +#include #include @@ -72,8 +72,8 @@ bool Compare(T a, T b, float tolerance = 0.000001f) template void SetWeightAndBias(ConvolutionLayer* layer, const armnn::TensorInfo& weightInfo, const armnn::TensorInfo& biasInfo) { - layer->m_Weight = std::make_unique(weightInfo); - layer->m_Bias = std::make_unique(biasInfo); + layer->m_Weight = std::make_unique(weightInfo); + layer->m_Bias = std::make_unique(biasInfo); layer->m_Weight->Allocate(); layer->m_Bias->Allocate(); diff --git a/src/backends/backendsCommon/test/DefaultAsyncExecuteTest.cpp b/src/backends/backendsCommon/test/DefaultAsyncExecuteTest.cpp index 56a794e77c..2dd5298059 100644 --- a/src/backends/backendsCommon/test/DefaultAsyncExecuteTest.cpp +++ b/src/backends/backendsCommon/test/DefaultAsyncExecuteTest.cpp @@ -5,7 +5,7 @@ #include -#include +#include #include #include @@ -121,15 +121,15 @@ BOOST_AUTO_TEST_CASE(TestAsyncExecute) ConstTensor constInputTensor(info, inVals); ConstTensor constOutputTensor(info, outVals); - ScopedCpuTensorHandle syncInput0(constInputTensor); - ScopedCpuTensorHandle syncOutput0(constOutputTensor); + ScopedTensorHandle syncInput0(constInputTensor); + ScopedTensorHandle syncOutput0(constOutputTensor); std::unique_ptr workload0 = CreateWorkload(info, &syncInput0, &syncOutput0); workload0.get()->Execute(); - ScopedCpuTensorHandle asyncInput0(constInputTensor); - ScopedCpuTensorHandle asyncOutput0(constOutputTensor); + ScopedTensorHandle asyncInput0(constInputTensor); + ScopedTensorHandle asyncOutput0(constOutputTensor); WorkingMemDescriptor workingMemDescriptor0; workingMemDescriptor0.m_Inputs = std::vector{&asyncInput0}; @@ -159,13 +159,13 @@ BOOST_AUTO_TEST_CASE(TestDefaultAsyncExecute) ConstTensor constOutputTensor(info, outVals); ConstTensor defaultTensor(info, &defaultVals); - ScopedCpuTensorHandle defaultInput = ScopedCpuTensorHandle(defaultTensor); - ScopedCpuTensorHandle defaultOutput = ScopedCpuTensorHandle(defaultTensor); + ScopedTensorHandle defaultInput = ScopedTensorHandle(defaultTensor); + ScopedTensorHandle defaultOutput = ScopedTensorHandle(defaultTensor); std::unique_ptr workload1 = CreateWorkload(info, &defaultInput, &defaultOutput); - ScopedCpuTensorHandle asyncInput(constInputTensor); - ScopedCpuTensorHandle asyncOutput(constOutputTensor); + ScopedTensorHandle asyncInput(constInputTensor); + ScopedTensorHandle asyncOutput(constOutputTensor); WorkingMemDescriptor workingMemDescriptor; workingMemDescriptor.m_Inputs = std::vector{&asyncInput}; @@ -202,20 +202,20 @@ BOOST_AUTO_TEST_CASE(TestDefaultAsyncExeuteWithThreads) ConstTensor defaultTensor(info, &defaultVals); - ScopedCpuTensorHandle defaultInput = ScopedCpuTensorHandle(defaultTensor); - ScopedCpuTensorHandle defaultOutput = ScopedCpuTensorHandle(defaultTensor); + ScopedTensorHandle defaultInput = ScopedTensorHandle(defaultTensor); + ScopedTensorHandle defaultOutput = ScopedTensorHandle(defaultTensor); std::unique_ptr workload = CreateWorkload(info, &defaultInput, &defaultOutput); - ScopedCpuTensorHandle asyncInput1(constInputTensor1); - ScopedCpuTensorHandle asyncOutput1(constOutputTensor1); + ScopedTensorHandle asyncInput1(constInputTensor1); + ScopedTensorHandle asyncOutput1(constOutputTensor1); WorkingMemDescriptor workingMemDescriptor1; workingMemDescriptor1.m_Inputs = std::vector{&asyncInput1}; workingMemDescriptor1.m_Outputs = std::vector{&asyncOutput1}; - ScopedCpuTensorHandle asyncInput2(constInputTensor2); - ScopedCpuTensorHandle asyncOutput2(constOutputTensor2); + ScopedTensorHandle asyncInput2(constInputTensor2); + ScopedTensorHandle asyncOutput2(constOutputTensor2); WorkingMemDescriptor workingMemDescriptor2; workingMemDescriptor2.m_Inputs = std::vector{&asyncInput2}; diff --git a/src/backends/backendsCommon/test/DynamicBackendTests.hpp b/src/backends/backendsCommon/test/DynamicBackendTests.hpp index 8302bfd57d..a4f1613a58 100644 --- a/src/backends/backendsCommon/test/DynamicBackendTests.hpp +++ b/src/backends/backendsCommon/test/DynamicBackendTests.hpp @@ -9,8 +9,8 @@ #include #include #include -#include #include +#include #include #include #include @@ -1473,7 +1473,7 @@ void CreateReferenceDynamicBackendTestImpl() { outputInfo } }; convolution2dQueueDescriptor.m_Inputs.push_back(nullptr); - auto weights = std::make_unique(weightInfo); + auto weights = std::make_unique(weightInfo); convolution2dQueueDescriptor.m_Weight = weights.get(); // Create a convolution workload with the dummy settings diff --git a/src/backends/backendsCommon/test/IsLayerSupportedTestImpl.hpp b/src/backends/backendsCommon/test/IsLayerSupportedTestImpl.hpp index b73efbe26c..4240bb1061 100644 --- a/src/backends/backendsCommon/test/IsLayerSupportedTestImpl.hpp +++ b/src/backends/backendsCommon/test/IsLayerSupportedTestImpl.hpp @@ -83,13 +83,13 @@ struct DummyLayer DummyLayer() { m_Layer = dummyGraph.AddLayer(armnn::BatchNormalizationDescriptor(), ""); - m_Layer->m_Mean = std::make_unique( + m_Layer->m_Mean = std::make_unique( armnn::TensorInfo(armnn::TensorShape({1,1,1,1}), armnn::DataType::Float32)); - m_Layer->m_Variance = std::make_unique( + m_Layer->m_Variance = std::make_unique( armnn::TensorInfo(armnn::TensorShape({1,1,1,1}), armnn::DataType::Float32)); - m_Layer->m_Beta = std::make_unique( + m_Layer->m_Beta = std::make_unique( armnn::TensorInfo(armnn::TensorShape({1,1,1,1}), armnn::DataType::Float32)); - m_Layer->m_Gamma = std::make_unique( + m_Layer->m_Gamma = std::make_unique( armnn::TensorInfo(armnn::TensorShape({1,1,1,1}), armnn::DataType::Float32)); } @@ -240,9 +240,9 @@ struct DummyConvolutionLayer desc.m_StrideX = 1; desc.m_StrideY = 1; m_Layer = dummyGraph.AddLayer(desc, ""); - m_Layer->m_Weight = std::make_unique( + m_Layer->m_Weight = std::make_unique( armnn::TensorInfo(armnn::TensorShape({1,1,1,1}), armnn::DataType::Float32)); - m_Layer->m_Bias = std::make_unique( + m_Layer->m_Bias = std::make_unique( armnn::TensorInfo(armnn::TensorShape({1,1,1,1}), armnn::DataType::Float32)); } @@ -278,7 +278,7 @@ struct DummyLayer DummyLayer() { m_Layer = dummyGraph.AddLayer(armnn::DetectionPostProcessDescriptor(), ""); - m_Layer->m_Anchors = std::make_unique( + m_Layer->m_Anchors = std::make_unique( armnn::TensorInfo(armnn::TensorShape({1,1,1,1}), armnn::DataType::Float32)); } @@ -299,30 +299,30 @@ struct DummyLstmLayer desc.m_CifgEnabled = false; m_Layer = dummyGraph.AddLayer(armnn::LstmDescriptor(), ""); - m_Layer->m_BasicParameters.m_InputToForgetWeights = std::make_unique( + m_Layer->m_BasicParameters.m_InputToForgetWeights = std::make_unique( armnn::TensorInfo(armnn::TensorShape({1,1,1,1}), armnn::DataType::Float32)); - m_Layer->m_BasicParameters.m_InputToCellWeights = std::make_unique( + m_Layer->m_BasicParameters.m_InputToCellWeights = std::make_unique( armnn::TensorInfo(armnn::TensorShape({1,1,1,1}), armnn::DataType::Float32)); - m_Layer->m_BasicParameters.m_InputToOutputWeights = std::make_unique( + m_Layer->m_BasicParameters.m_InputToOutputWeights = std::make_unique( armnn::TensorInfo(armnn::TensorShape({1,1,1,1}), armnn::DataType::Float32)); - m_Layer->m_BasicParameters.m_RecurrentToForgetWeights = std::make_unique( + m_Layer->m_BasicParameters.m_RecurrentToForgetWeights = std::make_unique( armnn::TensorInfo(armnn::TensorShape({1,1,1,1}), armnn::DataType::Float32)); - m_Layer->m_BasicParameters.m_RecurrentToCellWeights = std::make_unique( + m_Layer->m_BasicParameters.m_RecurrentToCellWeights = std::make_unique( armnn::TensorInfo(armnn::TensorShape({1,1,1,1}), armnn::DataType::Float32)); - m_Layer->m_BasicParameters.m_RecurrentToOutputWeights = std::make_unique( + m_Layer->m_BasicParameters.m_RecurrentToOutputWeights = std::make_unique( armnn::TensorInfo(armnn::TensorShape({1,1,1,1}), armnn::DataType::Float32)); - m_Layer->m_BasicParameters.m_ForgetGateBias = std::make_unique( + m_Layer->m_BasicParameters.m_ForgetGateBias = std::make_unique( armnn::TensorInfo(armnn::TensorShape({1,1,1,1}), armnn::DataType::Float32)); - m_Layer->m_BasicParameters.m_CellBias = std::make_unique( + m_Layer->m_BasicParameters.m_CellBias = std::make_unique( armnn::TensorInfo(armnn::TensorShape({1,1,1,1}), armnn::DataType::Float32)); - m_Layer->m_BasicParameters.m_OutputGateBias = std::make_unique( + m_Layer->m_BasicParameters.m_OutputGateBias = std::make_unique( armnn::TensorInfo(armnn::TensorShape({1,1,1,1}), armnn::DataType::Float32)); - m_Layer->m_CifgParameters.m_InputToInputWeights = std::make_unique( + m_Layer->m_CifgParameters.m_InputToInputWeights = std::make_unique( armnn::TensorInfo(armnn::TensorShape({1,1,1,1}), armnn::DataType::Float32)); - m_Layer->m_CifgParameters.m_RecurrentToInputWeights = std::make_unique( + m_Layer->m_CifgParameters.m_RecurrentToInputWeights = std::make_unique( armnn::TensorInfo(armnn::TensorShape({1,1,1,1}), armnn::DataType::Float32)); - m_Layer->m_CifgParameters.m_InputGateBias = std::make_unique( + m_Layer->m_CifgParameters.m_InputGateBias = std::make_unique( armnn::TensorInfo(armnn::TensorShape({1,1,1,1}), armnn::DataType::Float32)); } @@ -354,57 +354,57 @@ struct DummyQLstmLayer m_Layer = dummyGraph.AddLayer(armnn::QLstmDescriptor(), "qLstm"); // Basic params - m_Layer->m_BasicParameters.m_InputToForgetWeights = std::make_unique( + m_Layer->m_BasicParameters.m_InputToForgetWeights = std::make_unique( armnn::TensorInfo(armnn::TensorShape({1,1,1,1}), armnn::DataType::QSymmS8)); - m_Layer->m_BasicParameters.m_InputToCellWeights = std::make_unique( + m_Layer->m_BasicParameters.m_InputToCellWeights = std::make_unique( armnn::TensorInfo(armnn::TensorShape({1,1,1,1}), armnn::DataType::QSymmS8)); - m_Layer->m_BasicParameters.m_InputToOutputWeights = std::make_unique( + m_Layer->m_BasicParameters.m_InputToOutputWeights = std::make_unique( armnn::TensorInfo(armnn::TensorShape({1,1,1,1}), armnn::DataType::QSymmS8)); - m_Layer->m_BasicParameters.m_RecurrentToForgetWeights = std::make_unique( + m_Layer->m_BasicParameters.m_RecurrentToForgetWeights = std::make_unique( armnn::TensorInfo(armnn::TensorShape({1,1,1,1}), armnn::DataType::QSymmS8)); - m_Layer->m_BasicParameters.m_RecurrentToCellWeights = std::make_unique( + m_Layer->m_BasicParameters.m_RecurrentToCellWeights = std::make_unique( armnn::TensorInfo(armnn::TensorShape({1,1,1,1}), armnn::DataType::QSymmS8)); - m_Layer->m_BasicParameters.m_RecurrentToOutputWeights = std::make_unique( + m_Layer->m_BasicParameters.m_RecurrentToOutputWeights = std::make_unique( armnn::TensorInfo(armnn::TensorShape({1,1,1,1}), armnn::DataType::QSymmS8)); - m_Layer->m_BasicParameters.m_ForgetGateBias = std::make_unique( + m_Layer->m_BasicParameters.m_ForgetGateBias = std::make_unique( armnn::TensorInfo(armnn::TensorShape({1,1,1,1}), armnn::DataType::Signed32)); - m_Layer->m_BasicParameters.m_CellBias = std::make_unique( + m_Layer->m_BasicParameters.m_CellBias = std::make_unique( armnn::TensorInfo(armnn::TensorShape({1,1,1,1}), armnn::DataType::Signed32)); - m_Layer->m_BasicParameters.m_OutputGateBias = std::make_unique( + m_Layer->m_BasicParameters.m_OutputGateBias = std::make_unique( armnn::TensorInfo(armnn::TensorShape({1,1,1,1}), armnn::DataType::Signed32)); // CIFG optional params - m_Layer->m_CifgParameters.m_InputToInputWeights = std::make_unique( + m_Layer->m_CifgParameters.m_InputToInputWeights = std::make_unique( armnn::TensorInfo(armnn::TensorShape({1,1,1,1}), armnn::DataType::QSymmS8)); - m_Layer->m_CifgParameters.m_RecurrentToInputWeights = std::make_unique( + m_Layer->m_CifgParameters.m_RecurrentToInputWeights = std::make_unique( armnn::TensorInfo(armnn::TensorShape({1,1,1,1}), armnn::DataType::QSymmS8)); - m_Layer->m_CifgParameters.m_InputGateBias = std::make_unique( + m_Layer->m_CifgParameters.m_InputGateBias = std::make_unique( armnn::TensorInfo(armnn::TensorShape({1,1,1,1}), armnn::DataType::Signed32)); // Projection optional params - m_Layer->m_ProjectionParameters.m_ProjectionWeights = std::make_unique( + m_Layer->m_ProjectionParameters.m_ProjectionWeights = std::make_unique( armnn::TensorInfo(armnn::TensorShape({1,1,1,1}), armnn::DataType::QSymmS8)); - m_Layer->m_ProjectionParameters.m_ProjectionBias = std::make_unique( + m_Layer->m_ProjectionParameters.m_ProjectionBias = std::make_unique( armnn::TensorInfo(armnn::TensorShape({1,1,1,1}), armnn::DataType::Signed32)); // Peephole optional params - m_Layer->m_PeepholeParameters.m_CellToInputWeights = std::make_unique( + m_Layer->m_PeepholeParameters.m_CellToInputWeights = std::make_unique( armnn::TensorInfo(armnn::TensorShape({1,1,1,1}), armnn::DataType::QSymmS16)); - m_Layer->m_PeepholeParameters.m_CellToForgetWeights = std::make_unique( + m_Layer->m_PeepholeParameters.m_CellToForgetWeights = std::make_unique( armnn::TensorInfo(armnn::TensorShape({1,1,1,1}), armnn::DataType::QSymmS16)); - m_Layer->m_PeepholeParameters.m_CellToOutputWeights = std::make_unique( + m_Layer->m_PeepholeParameters.m_CellToOutputWeights = std::make_unique( armnn::TensorInfo(armnn::TensorShape({1,1,1,1}), armnn::DataType::QSymmS16)); // Layer normalization optional params - m_Layer->m_LayerNormParameters.m_InputLayerNormWeights = std::make_unique( + m_Layer->m_LayerNormParameters.m_InputLayerNormWeights = std::make_unique( armnn::TensorInfo(armnn::TensorShape({1,1,1,1}), armnn::DataType::QSymmS16)); - m_Layer->m_LayerNormParameters.m_ForgetLayerNormWeights = std::make_unique( + m_Layer->m_LayerNormParameters.m_ForgetLayerNormWeights = std::make_unique( armnn::TensorInfo(armnn::TensorShape({1,1,1,1}), armnn::DataType::QSymmS16)); - m_Layer->m_LayerNormParameters.m_CellLayerNormWeights = std::make_unique( + m_Layer->m_LayerNormParameters.m_CellLayerNormWeights = std::make_unique( armnn::TensorInfo(armnn::TensorShape({1,1,1,1}), armnn::DataType::QSymmS16)); - m_Layer->m_LayerNormParameters.m_OutputLayerNormWeights = std::make_unique( + m_Layer->m_LayerNormParameters.m_OutputLayerNormWeights = std::make_unique( armnn::TensorInfo(armnn::TensorShape({1,1,1,1}), armnn::DataType::QSymmS16)); } @@ -423,31 +423,31 @@ struct DummyLayer { m_Layer = dummyGraph.AddLayer(""); - m_Layer->m_QuantizedLstmParameters.m_InputToInputWeights = std::make_unique( + m_Layer->m_QuantizedLstmParameters.m_InputToInputWeights = std::make_unique( armnn::TensorInfo(armnn::TensorShape({1,1,1,1}), armnn::DataType::QAsymmU8)); - m_Layer->m_QuantizedLstmParameters.m_InputToForgetWeights = std::make_unique( + m_Layer->m_QuantizedLstmParameters.m_InputToForgetWeights = std::make_unique( armnn::TensorInfo(armnn::TensorShape({1,1,1,1}), armnn::DataType::QAsymmU8)); - m_Layer->m_QuantizedLstmParameters.m_InputToCellWeights = std::make_unique( + m_Layer->m_QuantizedLstmParameters.m_InputToCellWeights = std::make_unique( armnn::TensorInfo(armnn::TensorShape({1,1,1,1}), armnn::DataType::QAsymmU8)); - m_Layer->m_QuantizedLstmParameters.m_InputToOutputWeights = std::make_unique( + m_Layer->m_QuantizedLstmParameters.m_InputToOutputWeights = std::make_unique( armnn::TensorInfo(armnn::TensorShape({1,1,1,1}), armnn::DataType::QAsymmU8)); - m_Layer->m_QuantizedLstmParameters.m_RecurrentToInputWeights = std::make_unique( + m_Layer->m_QuantizedLstmParameters.m_RecurrentToInputWeights = std::make_unique( armnn::TensorInfo(armnn::TensorShape({1,1,1,1}), armnn::DataType::QAsymmU8)); - m_Layer->m_QuantizedLstmParameters.m_RecurrentToForgetWeights = std::make_unique( + m_Layer->m_QuantizedLstmParameters.m_RecurrentToForgetWeights = std::make_unique( armnn::TensorInfo(armnn::TensorShape({1,1,1,1}), armnn::DataType::QAsymmU8)); - m_Layer->m_QuantizedLstmParameters.m_RecurrentToCellWeights = std::make_unique( + m_Layer->m_QuantizedLstmParameters.m_RecurrentToCellWeights = std::make_unique( armnn::TensorInfo(armnn::TensorShape({1,1,1,1}), armnn::DataType::QAsymmU8)); - m_Layer->m_QuantizedLstmParameters.m_RecurrentToOutputWeights = std::make_unique( + m_Layer->m_QuantizedLstmParameters.m_RecurrentToOutputWeights = std::make_unique( armnn::TensorInfo(armnn::TensorShape({1,1,1,1}), armnn::DataType::QAsymmU8)); - m_Layer->m_QuantizedLstmParameters.m_InputGateBias = std::make_unique( + m_Layer->m_QuantizedLstmParameters.m_InputGateBias = std::make_unique( armnn::TensorInfo(armnn::TensorShape({1,1,1,1}), armnn::DataType::Signed32)); - m_Layer->m_QuantizedLstmParameters.m_ForgetGateBias = std::make_unique( + m_Layer->m_QuantizedLstmParameters.m_ForgetGateBias = std::make_unique( armnn::TensorInfo(armnn::TensorShape({1,1,1,1}), armnn::DataType::Signed32)); - m_Layer->m_QuantizedLstmParameters.m_CellBias = std::make_unique( + m_Layer->m_QuantizedLstmParameters.m_CellBias = std::make_unique( armnn::TensorInfo(armnn::TensorShape({1,1,1,1}), armnn::DataType::Signed32)); - m_Layer->m_QuantizedLstmParameters.m_OutputGateBias = std::make_unique( + m_Layer->m_QuantizedLstmParameters.m_OutputGateBias = std::make_unique( armnn::TensorInfo(armnn::TensorShape({1,1,1,1}), armnn::DataType::Signed32)); } @@ -466,7 +466,7 @@ struct DummyLayer { armnn::FullyConnectedLayer::DescriptorType desc; m_Layer = dummyGraph.AddLayer(desc, ""); - m_Layer->m_Weight = std::make_unique( + m_Layer->m_Weight = std::make_unique( armnn::TensorInfo(armnn::TensorShape({1,1,1,1}), armnn::DataType::Float32)); } diff --git a/src/backends/backendsCommon/test/LayerReleaseConstantDataTest.cpp b/src/backends/backendsCommon/test/LayerReleaseConstantDataTest.cpp index 817cdeed79..0ca4b0a7f9 100644 --- a/src/backends/backendsCommon/test/LayerReleaseConstantDataTest.cpp +++ b/src/backends/backendsCommon/test/LayerReleaseConstantDataTest.cpp @@ -7,7 +7,7 @@ #include -#include +#include #include #include @@ -35,10 +35,10 @@ BOOST_AUTO_TEST_CASE(ReleaseBatchNormalizationLayerConstantDataTest) BatchNormalizationLayer* const layer = graph.AddLayer(layerDesc, "layer"); armnn::TensorInfo weightInfo({3}, armnn::DataType::Float32); - layer->m_Mean = std::make_unique(weightInfo); - layer->m_Variance = std::make_unique(weightInfo); - layer->m_Beta = std::make_unique(weightInfo); - layer->m_Gamma = std::make_unique(weightInfo); + layer->m_Mean = std::make_unique(weightInfo); + layer->m_Variance = std::make_unique(weightInfo); + layer->m_Beta = std::make_unique(weightInfo); + layer->m_Gamma = std::make_unique(weightInfo); layer->m_Mean->Allocate(); layer->m_Variance->Allocate(); layer->m_Beta->Allocate(); @@ -87,9 +87,9 @@ BOOST_AUTO_TEST_CASE(ReleaseBatchNormalizationLayerConstantDataTest) Convolution2dLayer* const layer = graph.AddLayer(layerDesc, "layer"); - layer->m_Weight = std::make_unique(TensorInfo({2, 3, 5, 3}, + layer->m_Weight = std::make_unique(TensorInfo({2, 3, 5, 3}, armnn::DataType::Float32)); - layer->m_Bias = std::make_unique + layer->m_Bias = std::make_unique (TensorInfo({2}, GetBiasDataType(armnn::DataType::Float32))); layer->m_Weight->Allocate(); @@ -131,8 +131,8 @@ BOOST_AUTO_TEST_CASE(ReleaseDepthwiseConvolution2dLayerConstantDataTest) DepthwiseConvolution2dLayer* const layer = graph.AddLayer(layerDesc, "layer"); - layer->m_Weight = std::make_unique(TensorInfo({3, 3, 5, 3}, DataType::Float32)); - layer->m_Bias = std::make_unique(TensorInfo({9}, DataType::Float32)); + layer->m_Weight = std::make_unique(TensorInfo({3, 3, 5, 3}, DataType::Float32)); + layer->m_Bias = std::make_unique(TensorInfo({9}, DataType::Float32)); layer->m_Weight->Allocate(); layer->m_Bias->Allocate(); @@ -170,9 +170,9 @@ BOOST_AUTO_TEST_CASE(ReleaseFullyConnectedLayerConstantDataTest) float inputsQScale = 1.0f; float outputQScale = 2.0f; - layer->m_Weight = std::make_unique(TensorInfo({7, 20}, + layer->m_Weight = std::make_unique(TensorInfo({7, 20}, DataType::QAsymmU8, inputsQScale, 0)); - layer->m_Bias = std::make_unique(TensorInfo({7}, + layer->m_Bias = std::make_unique(TensorInfo({7}, GetBiasDataType(DataType::QAsymmU8), inputsQScale)); layer->m_Weight->Allocate(); layer->m_Bias->Allocate(); diff --git a/src/backends/backendsCommon/test/WorkloadDataValidation.cpp b/src/backends/backendsCommon/test/WorkloadDataValidation.cpp index 5ac548f42a..182c913777 100644 --- a/src/backends/backendsCommon/test/WorkloadDataValidation.cpp +++ b/src/backends/backendsCommon/test/WorkloadDataValidation.cpp @@ -7,7 +7,7 @@ #include -#include +#include #include #include @@ -32,7 +32,7 @@ BOOST_AUTO_TEST_CASE(BatchNormalizationQueueDescriptor_Validate_DifferentQuantiz unsigned int sameShape[] = { 10 }; TensorInfo sameInfo = armnn::TensorInfo(1, sameShape, armnn::DataType::QAsymmU8); - ScopedCpuTensorHandle sameTensor(sameInfo); + ScopedTensorHandle sameTensor(sameInfo); AddInputToWorkload(invalidData, invalidInfo, inputTensorInfo, nullptr); AddOutputToWorkload(invalidData, invalidInfo, outputTensorInfo, nullptr); @@ -136,8 +136,8 @@ BOOST_AUTO_TEST_CASE(FullyConnectedQueueDescriptor_Validate_RequiredDataMissing) FullyConnectedQueueDescriptor invalidData; WorkloadInfo invalidInfo; - ScopedCpuTensorHandle weightTensor(weightsDesc); - ScopedCpuTensorHandle biasTensor(biasesDesc); + ScopedTensorHandle weightTensor(weightsDesc); + ScopedTensorHandle biasTensor(biasesDesc); AddInputToWorkload(invalidData, invalidInfo, inputTensorInfo, nullptr); AddOutputToWorkload(invalidData, invalidInfo, outputTensorInfo, nullptr); @@ -515,27 +515,27 @@ BOOST_AUTO_TEST_CASE(LstmQueueDescriptor_Validate) AddOutputToWorkload(data, info, cellStateOutTensorInfo, nullptr); // AddOutputToWorkload(data, info, outputTensorInfo, nullptr); is left out - armnn::ScopedCpuTensorHandle inputToInputWeightsTensor(tensorInfo4x5); - armnn::ScopedCpuTensorHandle inputToForgetWeightsTensor(tensorInfo4x5); - armnn::ScopedCpuTensorHandle inputToCellWeightsTensor(tensorInfo4x5); - armnn::ScopedCpuTensorHandle inputToOutputWeightsTensor(tensorInfo4x5); - armnn::ScopedCpuTensorHandle recurrentToForgetWeightsTensor(tensorInfo4x3); - armnn::ScopedCpuTensorHandle recurrentToInputWeightsTensor(tensorInfo4x3); - armnn::ScopedCpuTensorHandle recurrentToCellWeightsTensor(tensorInfo4x3); - armnn::ScopedCpuTensorHandle recurrentToOutputWeightsTensor(tensorInfo4x3); - armnn::ScopedCpuTensorHandle cellToInputWeightsTensor(tensorInfo4); - armnn::ScopedCpuTensorHandle inputGateBiasTensor(tensorInfo4); - armnn::ScopedCpuTensorHandle forgetGateBiasTensor(tensorInfo4); - armnn::ScopedCpuTensorHandle cellBiasTensor(tensorInfo4); - armnn::ScopedCpuTensorHandle outputGateBiasTensor(tensorInfo4); - armnn::ScopedCpuTensorHandle cellToForgetWeightsTensor(tensorInfo4); - armnn::ScopedCpuTensorHandle cellToOutputWeightsTensor(tensorInfo4); - armnn::ScopedCpuTensorHandle projectionWeightsTensor(tensorInfo3x4); - armnn::ScopedCpuTensorHandle projectionBiasTensor(tensorInfo3); - armnn::ScopedCpuTensorHandle inputLayerNormWeightsTensor(tensorInfo4); - armnn::ScopedCpuTensorHandle forgetLayerNormWeightsTensor(tensorInfo4); - armnn::ScopedCpuTensorHandle cellLayerNormWeightsTensor(tensorInfo4); - armnn::ScopedCpuTensorHandle outputLayerNormWeightsTensor(tensorInfo4); + armnn::ScopedTensorHandle inputToInputWeightsTensor(tensorInfo4x5); + armnn::ScopedTensorHandle inputToForgetWeightsTensor(tensorInfo4x5); + armnn::ScopedTensorHandle inputToCellWeightsTensor(tensorInfo4x5); + armnn::ScopedTensorHandle inputToOutputWeightsTensor(tensorInfo4x5); + armnn::ScopedTensorHandle recurrentToForgetWeightsTensor(tensorInfo4x3); + armnn::ScopedTensorHandle recurrentToInputWeightsTensor(tensorInfo4x3); + armnn::ScopedTensorHandle recurrentToCellWeightsTensor(tensorInfo4x3); + armnn::ScopedTensorHandle recurrentToOutputWeightsTensor(tensorInfo4x3); + armnn::ScopedTensorHandle cellToInputWeightsTensor(tensorInfo4); + armnn::ScopedTensorHandle inputGateBiasTensor(tensorInfo4); + armnn::ScopedTensorHandle forgetGateBiasTensor(tensorInfo4); + armnn::ScopedTensorHandle cellBiasTensor(tensorInfo4); + armnn::ScopedTensorHandle outputGateBiasTensor(tensorInfo4); + armnn::ScopedTensorHandle cellToForgetWeightsTensor(tensorInfo4); + armnn::ScopedTensorHandle cellToOutputWeightsTensor(tensorInfo4); + armnn::ScopedTensorHandle projectionWeightsTensor(tensorInfo3x4); + armnn::ScopedTensorHandle projectionBiasTensor(tensorInfo3); + armnn::ScopedTensorHandle inputLayerNormWeightsTensor(tensorInfo4); + armnn::ScopedTensorHandle forgetLayerNormWeightsTensor(tensorInfo4); + armnn::ScopedTensorHandle cellLayerNormWeightsTensor(tensorInfo4); + armnn::ScopedTensorHandle outputLayerNormWeightsTensor(tensorInfo4); data.m_InputToInputWeights = &inputToInputWeightsTensor; data.m_InputToForgetWeights = &inputToForgetWeightsTensor; @@ -657,14 +657,14 @@ BOOST_AUTO_TEST_CASE(BiasPerAxisQuantization_Validate) AddInputToWorkload(queueDescriptor, workloadInfo, inputInfo, nullptr); AddOutputToWorkload(queueDescriptor, workloadInfo, outputInfo, nullptr); - ScopedCpuTensorHandle weightTensor(weightInfo); + ScopedTensorHandle weightTensor(weightInfo); queueDescriptor.m_Weight = &weightTensor; // Test 1: correct per-axis quantization values const std::vector biasPerAxisScales1 = { 3.75f, 5.25f }; const TensorInfo biasInfo1(biasShape, biasType, biasPerAxisScales1, 0); - ScopedCpuTensorHandle biasHandle1(biasInfo1); + ScopedTensorHandle biasHandle1(biasInfo1); queueDescriptor.m_Bias = &biasHandle1; BOOST_CHECK_NO_THROW(queueDescriptor.Validate(workloadInfo)); @@ -673,7 +673,7 @@ BOOST_AUTO_TEST_CASE(BiasPerAxisQuantization_Validate) const std::vector biasPerAxisScales2 = { 4.00f, 5.00f }; const TensorInfo biasInfo2(biasShape, biasType, biasPerAxisScales2, 0); - ScopedCpuTensorHandle biasHandle2(biasInfo2); + ScopedTensorHandle biasHandle2(biasInfo2); queueDescriptor.m_Bias = &biasHandle2; BOOST_CHECK_NO_THROW(queueDescriptor.Validate(workloadInfo)); @@ -682,7 +682,7 @@ BOOST_AUTO_TEST_CASE(BiasPerAxisQuantization_Validate) const std::vector biasPerAxisScales3 = { 3.75f, 5.25f, 5.25f }; const TensorInfo biasInfo3(biasShape, biasType, biasPerAxisScales3, 0); - ScopedCpuTensorHandle biasHandle3(biasInfo3); + ScopedTensorHandle biasHandle3(biasInfo3); queueDescriptor.m_Bias = &biasHandle3; BOOST_CHECK_THROW(queueDescriptor.Validate(workloadInfo), InvalidArgumentException); diff --git a/src/backends/backendsCommon/test/layerTests/BatchNormalizationTestImpl.cpp b/src/backends/backendsCommon/test/layerTests/BatchNormalizationTestImpl.cpp index eb4f461eb9..969d5dbcd1 100644 --- a/src/backends/backendsCommon/test/layerTests/BatchNormalizationTestImpl.cpp +++ b/src/backends/backendsCommon/test/layerTests/BatchNormalizationTestImpl.cpp @@ -11,7 +11,7 @@ #include #include -#include +#include #include #include #include @@ -74,10 +74,10 @@ LayerTestResult BatchNormTestImpl( std::unique_ptr inputHandle = tensorHandleFactory.CreateTensorHandle(inputTensorInfo); std::unique_ptr outputHandle = tensorHandleFactory.CreateTensorHandle(outputTensorInfo); - armnn::ScopedCpuTensorHandle meanTensor(tensorInfo); - armnn::ScopedCpuTensorHandle varianceTensor(tensorInfo); - armnn::ScopedCpuTensorHandle betaTensor(tensorInfo); - armnn::ScopedCpuTensorHandle gammaTensor(tensorInfo); + armnn::ScopedTensorHandle meanTensor(tensorInfo); + armnn::ScopedTensorHandle varianceTensor(tensorInfo); + armnn::ScopedTensorHandle betaTensor(tensorInfo); + armnn::ScopedTensorHandle gammaTensor(tensorInfo); armnn::BatchNormalizationQueueDescriptor descriptor; descriptor.m_Mean = &meanTensor; @@ -160,10 +160,10 @@ LayerTestResult BatchNormTestNhwcImpl( armnn::BatchNormalizationQueueDescriptor data; armnn::WorkloadInfo info; - armnn::ScopedCpuTensorHandle meanTensor(tensorInfo); - armnn::ScopedCpuTensorHandle varianceTensor(tensorInfo); - armnn::ScopedCpuTensorHandle betaTensor(tensorInfo); - armnn::ScopedCpuTensorHandle gammaTensor(tensorInfo); + armnn::ScopedTensorHandle meanTensor(tensorInfo); + armnn::ScopedTensorHandle varianceTensor(tensorInfo); + armnn::ScopedTensorHandle betaTensor(tensorInfo); + armnn::ScopedTensorHandle gammaTensor(tensorInfo); AllocateAndCopyDataToITensorHandle(&meanTensor, &mean[0]); AllocateAndCopyDataToITensorHandle(&varianceTensor, &variance[0]); @@ -644,10 +644,10 @@ LayerTestResult CompareBatchNormTest( armnn::BatchNormalizationQueueDescriptor data; armnn::WorkloadInfo info; - armnn::ScopedCpuTensorHandle meanTensor(tensorInfo); - armnn::ScopedCpuTensorHandle varianceTensor(tensorInfo); - armnn::ScopedCpuTensorHandle betaTensor(tensorInfo); - armnn::ScopedCpuTensorHandle gammaTensor(tensorInfo); + armnn::ScopedTensorHandle meanTensor(tensorInfo); + armnn::ScopedTensorHandle varianceTensor(tensorInfo); + armnn::ScopedTensorHandle betaTensor(tensorInfo); + armnn::ScopedTensorHandle gammaTensor(tensorInfo); AllocateAndCopyDataToITensorHandle(&meanTensor, &mean[0]); AllocateAndCopyDataToITensorHandle(&varianceTensor, &variance[0]); diff --git a/src/backends/backendsCommon/test/layerTests/ConstantTestImpl.cpp b/src/backends/backendsCommon/test/layerTests/ConstantTestImpl.cpp index 45c94d345b..c28ef40b45 100644 --- a/src/backends/backendsCommon/test/layerTests/ConstantTestImpl.cpp +++ b/src/backends/backendsCommon/test/layerTests/ConstantTestImpl.cpp @@ -11,7 +11,7 @@ #include -#include +#include #include #include @@ -101,7 +101,7 @@ LayerTestResult ConstantTestImpl( std::unique_ptr outputHandle = tensorHandleFactory.CreateTensorHandle(outputTensorInfo); - armnn::ScopedCpuTensorHandle constantTensor(inputTensorInfo); + armnn::ScopedTensorHandle constantTensor(inputTensorInfo); AllocateAndCopyDataToITensorHandle(&constantTensor, &input[0][0][0][0]); armnn::ConstantQueueDescriptor descriptor; diff --git a/src/backends/backendsCommon/test/layerTests/Conv2dTestImpl.cpp b/src/backends/backendsCommon/test/layerTests/Conv2dTestImpl.cpp index 4641e67aad..8f60415a66 100644 --- a/src/backends/backendsCommon/test/layerTests/Conv2dTestImpl.cpp +++ b/src/backends/backendsCommon/test/layerTests/Conv2dTestImpl.cpp @@ -13,7 +13,7 @@ #include #include -#include +#include #include #include @@ -318,8 +318,8 @@ LayerTestResult SimpleConvolution2dTestImpl( armnn::Convolution2dQueueDescriptor data; armnn::WorkloadInfo info; - armnn::ScopedCpuTensorHandle weightsTensor(kernelDesc); - armnn::ScopedCpuTensorHandle biasTensor(biasDesc); + armnn::ScopedTensorHandle weightsTensor(kernelDesc); + armnn::ScopedTensorHandle biasTensor(biasDesc); // Permute the kernel if necessary boost::multi_array kernel = boost::multi_array(originalKernel); if (layout == armnn::DataLayout::NHWC) @@ -423,10 +423,10 @@ LayerTestResult SimpleConvolution2dNhwcTestImpl( std::unique_ptr inputHandle = tensorHandleFactory.CreateTensorHandle(inputTensorInfo); std::unique_ptr outputHandle = tensorHandleFactory.CreateTensorHandle(outputTensorInfo); - armnn::ScopedCpuTensorHandle weightsTensor(kernelDesc); + armnn::ScopedTensorHandle weightsTensor(kernelDesc); AllocateAndCopyDataToITensorHandle(&weightsTensor, &kernel[0][0][0][0]); - armnn::ScopedCpuTensorHandle biasTensor(biasDesc); + armnn::ScopedTensorHandle biasTensor(biasDesc); armnn::Convolution2dQueueDescriptor data; @@ -547,8 +547,8 @@ LayerTestResult Convolution1dTestImpl( armnn::Convolution2dQueueDescriptor data; armnn::WorkloadInfo info; - armnn::ScopedCpuTensorHandle weightsTensor(kernelInfo); - armnn::ScopedCpuTensorHandle biasTensor(biasInfo); + armnn::ScopedTensorHandle weightsTensor(kernelInfo); + armnn::ScopedTensorHandle biasTensor(biasInfo); AllocateAndCopyDataToITensorHandle(&weightsTensor, kernelData.data()); AllocateAndCopyDataToITensorHandle(&biasTensor, biasData.data()); @@ -1349,8 +1349,8 @@ LayerTestResult CompareConvolution2dTestImpl( armnn::Convolution2dQueueDescriptor data; armnn::WorkloadInfo info; - armnn::ScopedCpuTensorHandle weightsTensor(kernelDesc); - armnn::ScopedCpuTensorHandle biasTensor(biasDesc); + armnn::ScopedTensorHandle weightsTensor(kernelDesc); + armnn::ScopedTensorHandle biasTensor(biasDesc); AllocateAndCopyDataToITensorHandle(&weightsTensor, &kernel[0][0][0][0]); AllocateAndCopyDataToITensorHandle(&biasTensor, &bias[0]); @@ -1722,11 +1722,11 @@ LayerTestResult DepthwiseConvolution2dAsymmetricTestImpl( std::unique_ptr inputHandle = tensorHandleFactory.CreateTensorHandle(inputTensorInfo); std::unique_ptr outputHandle = tensorHandleFactory.CreateTensorHandle(outputTensorInfo); - armnn::ScopedCpuTensorHandle weightsTensor(kernelDesc); + armnn::ScopedTensorHandle weightsTensor(kernelDesc); AllocateAndCopyDataToITensorHandle(&weightsTensor, &kernel[0][0][0][0]); - armnn::ScopedCpuTensorHandle biasTensor(biasDesc); + armnn::ScopedTensorHandle biasTensor(biasDesc); if (biasEnabled) { AllocateAndCopyDataToITensorHandle(&biasTensor, &bias[0]); @@ -1882,8 +1882,8 @@ LayerTestResult DepthwiseConvolution2dDepthMul1TestImpl( armnn::DepthwiseConvolution2dQueueDescriptor data; armnn::WorkloadInfo info; - armnn::ScopedCpuTensorHandle weightsTensor(kernelDesc); - armnn::ScopedCpuTensorHandle biasTensor(biasDesc); + armnn::ScopedTensorHandle weightsTensor(kernelDesc); + armnn::ScopedTensorHandle biasTensor(biasDesc); AllocateAndCopyDataToITensorHandle(&weightsTensor, &kernel[0][0][0][0]); AllocateAndCopyDataToITensorHandle(&biasTensor, &bias[0]); @@ -2095,8 +2095,8 @@ LayerTestResult DepthwiseConvolution2dTestImpl( armnn::DepthwiseConvolution2dQueueDescriptor data; armnn::WorkloadInfo info; - armnn::ScopedCpuTensorHandle weightsTensor(kernelDesc); - armnn::ScopedCpuTensorHandle biasTensor(biasDesc); + armnn::ScopedTensorHandle weightsTensor(kernelDesc); + armnn::ScopedTensorHandle biasTensor(biasDesc); AllocateAndCopyDataToITensorHandle(&weightsTensor, &kernel[0][0][0][0]); AllocateAndCopyDataToITensorHandle(&biasTensor, &bias[0]); @@ -2252,8 +2252,8 @@ LayerTestResult DepthwiseConvolution2dTestImpl( armnn::DepthwiseConvolution2dQueueDescriptor data; armnn::WorkloadInfo info; - armnn::ScopedCpuTensorHandle weightsTensor(kernelDesc); - armnn::ScopedCpuTensorHandle biasTensor(biasDesc); + armnn::ScopedTensorHandle weightsTensor(kernelDesc); + armnn::ScopedTensorHandle biasTensor(biasDesc); boost::multi_array kernel = boost::multi_array(originalKernel); AllocateAndCopyDataToITensorHandle(&weightsTensor, &kernel[0][0][0][0]); @@ -3007,8 +3007,8 @@ LayerTestResult CompareDepthwiseConvolution2dTestImpl( armnn::DepthwiseConvolution2dQueueDescriptor data; armnn::WorkloadInfo info; - armnn::ScopedCpuTensorHandle weightsTensor(kernelDesc); - armnn::ScopedCpuTensorHandle biasTensor(biasDesc); + armnn::ScopedTensorHandle weightsTensor(kernelDesc); + armnn::ScopedTensorHandle biasTensor(biasDesc); AllocateAndCopyDataToITensorHandle(&weightsTensor, &kernel[0][0][0][0]); AllocateAndCopyDataToITensorHandle(&biasTensor, &bias[0]); @@ -3502,8 +3502,8 @@ LayerTestResult Convolution2dPerAxisQuantTest( WorkloadInfo workloadInfo; - ScopedCpuTensorHandle weightTensor(kernelInfo); - ScopedCpuTensorHandle biasTensor(biasInfo); + ScopedTensorHandle weightTensor(kernelInfo); + ScopedTensorHandle biasTensor(biasInfo); AllocateAndCopyDataToITensorHandle(&weightTensor, kernelData.data()); AllocateAndCopyDataToITensorHandle(&biasTensor, biasData.data()); @@ -3756,8 +3756,8 @@ LayerTestResult DepthwiseConvolution2dPerAxisQuantTest( std::unique_ptr outputHandle = tensorHandleFactory.CreateTensorHandle(outputInfo); WorkloadInfo workloadInfo; - ScopedCpuTensorHandle weightTensor(kernelInfo); - ScopedCpuTensorHandle biasTensor(biasInfo); + ScopedTensorHandle weightTensor(kernelInfo); + ScopedTensorHandle biasTensor(biasInfo); AllocateAndCopyDataToITensorHandle(&weightTensor, kernelData.data()); AllocateAndCopyDataToITensorHandle(&biasTensor, biasData.data()); diff --git a/src/backends/backendsCommon/test/layerTests/DetectionPostProcessTestImpl.hpp b/src/backends/backendsCommon/test/layerTests/DetectionPostProcessTestImpl.hpp index 3ee1fadd81..f68082762c 100644 --- a/src/backends/backendsCommon/test/layerTests/DetectionPostProcessTestImpl.hpp +++ b/src/backends/backendsCommon/test/layerTests/DetectionPostProcessTestImpl.hpp @@ -8,7 +8,7 @@ #include -#include +#include #include #include @@ -181,7 +181,7 @@ void DetectionPostProcessImpl(const armnn::TensorInfo& boxEncodingsInfo, auto outputScoresHandle = tensorHandleFactory.CreateTensorHandle(detectionScoresInfo); auto numDetectionHandle = tensorHandleFactory.CreateTensorHandle(numDetectionInfo); - armnn::ScopedCpuTensorHandle anchorsTensor(anchorsInfo); + armnn::ScopedTensorHandle anchorsTensor(anchorsInfo); AllocateAndCopyDataToITensorHandle(&anchorsTensor, &anchors[0][0]); armnn::DetectionPostProcessQueueDescriptor data; diff --git a/src/backends/backendsCommon/test/layerTests/FakeQuantizationTestImpl.cpp b/src/backends/backendsCommon/test/layerTests/FakeQuantizationTestImpl.cpp index f8644007f2..157df99d64 100644 --- a/src/backends/backendsCommon/test/layerTests/FakeQuantizationTestImpl.cpp +++ b/src/backends/backendsCommon/test/layerTests/FakeQuantizationTestImpl.cpp @@ -6,7 +6,7 @@ #include "FakeQuantizationTestImpl.hpp" -#include +#include #include #include @@ -48,7 +48,7 @@ LayerTestResult FakeQuantizationTest( data.m_Parameters.m_Min = min; data.m_Parameters.m_Max = max; - armnn::PassthroughCpuTensorHandle refHandle(tensorInfo, &ret.outputExpected[0][0]); + armnn::PassthroughTensorHandle refHandle(tensorInfo, &ret.outputExpected[0][0]); armnn::FakeQuantizationQueueDescriptor refData = data; armnn::WorkloadInfo refInfo = info; SetWorkloadOutput(refData, refInfo, 0, tensorInfo, &refHandle); diff --git a/src/backends/backendsCommon/test/layerTests/FullyConnectedTestImpl.cpp b/src/backends/backendsCommon/test/layerTests/FullyConnectedTestImpl.cpp index 9176094eb2..cd7f4efe31 100644 --- a/src/backends/backendsCommon/test/layerTests/FullyConnectedTestImpl.cpp +++ b/src/backends/backendsCommon/test/layerTests/FullyConnectedTestImpl.cpp @@ -8,7 +8,7 @@ #include -#include +#include #include #include @@ -40,8 +40,8 @@ LayerTestResult SimpleFullyConnectedTestImpl( armnn::FullyConnectedQueueDescriptor data; armnn::WorkloadInfo info; - armnn::ScopedCpuTensorHandle weightsTensor(weightsDesc); - armnn::ScopedCpuTensorHandle biasTensor(biasesDesc); + armnn::ScopedTensorHandle weightsTensor(weightsDesc); + armnn::ScopedTensorHandle biasTensor(biasesDesc); AllocateAndCopyDataToITensorHandle(&weightsTensor, &weights[0][0]); AllocateAndCopyDataToITensorHandle(&biasTensor, &bias[0]); diff --git a/src/backends/backendsCommon/test/layerTests/InstanceNormalizationTestImpl.cpp b/src/backends/backendsCommon/test/layerTests/InstanceNormalizationTestImpl.cpp index 2e205dd58e..24a4dc4789 100644 --- a/src/backends/backendsCommon/test/layerTests/InstanceNormalizationTestImpl.cpp +++ b/src/backends/backendsCommon/test/layerTests/InstanceNormalizationTestImpl.cpp @@ -9,7 +9,7 @@ #include -#include +#include #include #include diff --git a/src/backends/backendsCommon/test/layerTests/LogSoftmaxTestImpl.cpp b/src/backends/backendsCommon/test/layerTests/LogSoftmaxTestImpl.cpp index 7ee7a3465b..f32d367d37 100644 --- a/src/backends/backendsCommon/test/layerTests/LogSoftmaxTestImpl.cpp +++ b/src/backends/backendsCommon/test/layerTests/LogSoftmaxTestImpl.cpp @@ -10,7 +10,7 @@ #include -#include +#include #include #include diff --git a/src/backends/backendsCommon/test/layerTests/LstmTestImpl.cpp b/src/backends/backendsCommon/test/layerTests/LstmTestImpl.cpp index 07a1f1e879..7a9652a8ea 100644 --- a/src/backends/backendsCommon/test/layerTests/LstmTestImpl.cpp +++ b/src/backends/backendsCommon/test/layerTests/LstmTestImpl.cpp @@ -9,7 +9,7 @@ #include -#include +#include #include #include @@ -269,19 +269,19 @@ LstmNoCifgNoPeepholeNoProjectionTestImpl( auto outputGateBias = MakeTensor(tensorInfo4, {0., 0., 0., 0.}); - armnn::ScopedCpuTensorHandle inputToInputWeightsTensor(tensorInfo8); - armnn::ScopedCpuTensorHandle inputToForgetWeightsTensor(tensorInfo8); - armnn::ScopedCpuTensorHandle inputToCellWeightsTensor(tensorInfo8); - armnn::ScopedCpuTensorHandle inputToOutputWeightsTensor(tensorInfo8); - armnn::ScopedCpuTensorHandle recurrentToInputWeightsTensor(tensorInfo16); - armnn::ScopedCpuTensorHandle recurrentToForgetWeightsTensor(tensorInfo16); - armnn::ScopedCpuTensorHandle recurrentToCellWeightsTensor(tensorInfo16); - armnn::ScopedCpuTensorHandle recurrentToOutputWeightsTensor(tensorInfo16); - armnn::ScopedCpuTensorHandle cellToInputWeightsTensor(tensorInfo4); - armnn::ScopedCpuTensorHandle inputGateBiasTensor(tensorInfo4); - armnn::ScopedCpuTensorHandle forgetGateBiasTensor(tensorInfo4); - armnn::ScopedCpuTensorHandle cellBiasTensor(tensorInfo4); - armnn::ScopedCpuTensorHandle outputGateBiasTensor(tensorInfo4); + armnn::ScopedTensorHandle inputToInputWeightsTensor(tensorInfo8); + armnn::ScopedTensorHandle inputToForgetWeightsTensor(tensorInfo8); + armnn::ScopedTensorHandle inputToCellWeightsTensor(tensorInfo8); + armnn::ScopedTensorHandle inputToOutputWeightsTensor(tensorInfo8); + armnn::ScopedTensorHandle recurrentToInputWeightsTensor(tensorInfo16); + armnn::ScopedTensorHandle recurrentToForgetWeightsTensor(tensorInfo16); + armnn::ScopedTensorHandle recurrentToCellWeightsTensor(tensorInfo16); + armnn::ScopedTensorHandle recurrentToOutputWeightsTensor(tensorInfo16); + armnn::ScopedTensorHandle cellToInputWeightsTensor(tensorInfo4); + armnn::ScopedTensorHandle inputGateBiasTensor(tensorInfo4); + armnn::ScopedTensorHandle forgetGateBiasTensor(tensorInfo4); + armnn::ScopedTensorHandle cellBiasTensor(tensorInfo4); + armnn::ScopedTensorHandle outputGateBiasTensor(tensorInfo4); AllocateAndCopyDataToITensorHandle(&inputToInputWeightsTensor, &inputToInputWeights[0][0]); AllocateAndCopyDataToITensorHandle(&inputToForgetWeightsTensor, &inputToForgetWeights[0][0]); @@ -971,23 +971,23 @@ LstmLayerNoCifgWithPeepholeWithProjectionTestImpl(armnn::IWorkloadFactory& workl std::vector projectionBiasVector(outputSize, 0.f); auto projectionBias = MakeTensor(tensorInfo16, projectionBiasVector); - armnn::ScopedCpuTensorHandle inputToInputWeightsTensor(tensorInfo20x5); - armnn::ScopedCpuTensorHandle inputToForgetWeightsTensor(tensorInfo20x5); - armnn::ScopedCpuTensorHandle inputToCellWeightsTensor(tensorInfo20x5); - armnn::ScopedCpuTensorHandle inputToOutputWeightsTensor(tensorInfo20x5); - armnn::ScopedCpuTensorHandle recurrentToForgetWeightsTensor(tensorInfo20x16); - armnn::ScopedCpuTensorHandle recurrentToInputWeightsTensor(tensorInfo20x16); - armnn::ScopedCpuTensorHandle recurrentToCellWeightsTensor(tensorInfo20x16); - armnn::ScopedCpuTensorHandle recurrentToOutputWeightsTensor(tensorInfo20x16); - armnn::ScopedCpuTensorHandle cellToInputWeightsTensor(tensorInfo20); - armnn::ScopedCpuTensorHandle inputGateBiasTensor(tensorInfo20); - armnn::ScopedCpuTensorHandle forgetGateBiasTensor(tensorInfo20); - armnn::ScopedCpuTensorHandle cellBiasTensor(tensorInfo20); - armnn::ScopedCpuTensorHandle outputGateBiasTensor(tensorInfo20); - armnn::ScopedCpuTensorHandle cellToForgetWeightsTensor(tensorInfo20); - armnn::ScopedCpuTensorHandle cellToOutputWeightsTensor(tensorInfo20); - armnn::ScopedCpuTensorHandle projectionWeightsTensor(tensorInfo16x20); - armnn::ScopedCpuTensorHandle projectionBiasTensor(tensorInfo16); + armnn::ScopedTensorHandle inputToInputWeightsTensor(tensorInfo20x5); + armnn::ScopedTensorHandle inputToForgetWeightsTensor(tensorInfo20x5); + armnn::ScopedTensorHandle inputToCellWeightsTensor(tensorInfo20x5); + armnn::ScopedTensorHandle inputToOutputWeightsTensor(tensorInfo20x5); + armnn::ScopedTensorHandle recurrentToForgetWeightsTensor(tensorInfo20x16); + armnn::ScopedTensorHandle recurrentToInputWeightsTensor(tensorInfo20x16); + armnn::ScopedTensorHandle recurrentToCellWeightsTensor(tensorInfo20x16); + armnn::ScopedTensorHandle recurrentToOutputWeightsTensor(tensorInfo20x16); + armnn::ScopedTensorHandle cellToInputWeightsTensor(tensorInfo20); + armnn::ScopedTensorHandle inputGateBiasTensor(tensorInfo20); + armnn::ScopedTensorHandle forgetGateBiasTensor(tensorInfo20); + armnn::ScopedTensorHandle cellBiasTensor(tensorInfo20); + armnn::ScopedTensorHandle outputGateBiasTensor(tensorInfo20); + armnn::ScopedTensorHandle cellToForgetWeightsTensor(tensorInfo20); + armnn::ScopedTensorHandle cellToOutputWeightsTensor(tensorInfo20); + armnn::ScopedTensorHandle projectionWeightsTensor(tensorInfo16x20); + armnn::ScopedTensorHandle projectionBiasTensor(tensorInfo16); AllocateAndCopyDataToITensorHandle(&inputToInputWeightsTensor, &inputToInputWeights[0][0]); AllocateAndCopyDataToITensorHandle(&inputToForgetWeightsTensor, &inputToForgetWeights[0][0]); @@ -1142,21 +1142,21 @@ LayerTestResult LstmLayerWithCifgWithPeepholeNoProjectionTestImpl( auto cellToOutputWeights = MakeTensor(tensorInfoNumUnits, {-0.17135078f, 0.82760304f, 0.85573703f, -0.77109635f}); - armnn::ScopedCpuTensorHandle inputToCellWeightsTensor(tensorInfoInput); - armnn::ScopedCpuTensorHandle inputToForgetWeightsTensor(tensorInfoInput); - armnn::ScopedCpuTensorHandle inputToOutputWeightsTensor(tensorInfoInput); + armnn::ScopedTensorHandle inputToCellWeightsTensor(tensorInfoInput); + armnn::ScopedTensorHandle inputToForgetWeightsTensor(tensorInfoInput); + armnn::ScopedTensorHandle inputToOutputWeightsTensor(tensorInfoInput); - armnn::ScopedCpuTensorHandle cellBiasTensor(tensorInfoNumUnits); - armnn::ScopedCpuTensorHandle forgetGateBiasTensor(tensorInfoNumUnits); - armnn::ScopedCpuTensorHandle outputGateBiasTensor(tensorInfoNumUnits); + armnn::ScopedTensorHandle cellBiasTensor(tensorInfoNumUnits); + armnn::ScopedTensorHandle forgetGateBiasTensor(tensorInfoNumUnits); + armnn::ScopedTensorHandle outputGateBiasTensor(tensorInfoNumUnits); - armnn::ScopedCpuTensorHandle recurrentToCellWeightsTensor(tensorInfoOutput); - armnn::ScopedCpuTensorHandle recurrentToForgetWeightsTensor(tensorInfoOutput); - armnn::ScopedCpuTensorHandle recurrentToOutputWeightsTensor(tensorInfoOutput); + armnn::ScopedTensorHandle recurrentToCellWeightsTensor(tensorInfoOutput); + armnn::ScopedTensorHandle recurrentToForgetWeightsTensor(tensorInfoOutput); + armnn::ScopedTensorHandle recurrentToOutputWeightsTensor(tensorInfoOutput); - armnn::ScopedCpuTensorHandle cellToForgetWeightsTensor(tensorInfoNumUnits); - armnn::ScopedCpuTensorHandle cellToOutputWeightsTensor(tensorInfoNumUnits); + armnn::ScopedTensorHandle cellToForgetWeightsTensor(tensorInfoNumUnits); + armnn::ScopedTensorHandle cellToOutputWeightsTensor(tensorInfoNumUnits); AllocateAndCopyDataToITensorHandle(&inputToCellWeightsTensor, &inputToCellWeights[0][0]); AllocateAndCopyDataToITensorHandle(&inputToForgetWeightsTensor, &inputToForgetWeights[0][0]); @@ -1455,28 +1455,28 @@ LstmLayerNoCifgWithPeepholeWithProjectionWithLayerNormTestImpl(armnn::IWorkloadF MakeTensor(tensorInfo4, {0.6f, 0.2f, 0.2f, 0.5f}); //{numUnits} - armnn::ScopedCpuTensorHandle inputToInputWeightsTensor(tensorInfo4x5); - armnn::ScopedCpuTensorHandle inputToForgetWeightsTensor(tensorInfo4x5); - armnn::ScopedCpuTensorHandle inputToCellWeightsTensor(tensorInfo4x5); - armnn::ScopedCpuTensorHandle inputToOutputWeightsTensor(tensorInfo4x5); - armnn::ScopedCpuTensorHandle recurrentToForgetWeightsTensor(tensorInfo4x3); - armnn::ScopedCpuTensorHandle recurrentToInputWeightsTensor(tensorInfo4x3); - armnn::ScopedCpuTensorHandle recurrentToCellWeightsTensor(tensorInfo4x3); - armnn::ScopedCpuTensorHandle recurrentToOutputWeightsTensor(tensorInfo4x3); - armnn::ScopedCpuTensorHandle cellToInputWeightsTensor(tensorInfo4); - armnn::ScopedCpuTensorHandle inputGateBiasTensor(tensorInfo4); - armnn::ScopedCpuTensorHandle forgetGateBiasTensor(tensorInfo4); - armnn::ScopedCpuTensorHandle cellBiasTensor(tensorInfo4); - armnn::ScopedCpuTensorHandle outputGateBiasTensor(tensorInfo4); - armnn::ScopedCpuTensorHandle cellToForgetWeightsTensor(tensorInfo4); - armnn::ScopedCpuTensorHandle cellToOutputWeightsTensor(tensorInfo4); - armnn::ScopedCpuTensorHandle projectionWeightsTensor(tensorInfo3x4); - armnn::ScopedCpuTensorHandle projectionBiasTensor(tensorInfo3); - - armnn::ScopedCpuTensorHandle inputLayerNormWeightsTensor(tensorInfo4); - armnn::ScopedCpuTensorHandle forgetLayerNormWeightsTensor(tensorInfo4); - armnn::ScopedCpuTensorHandle cellLayerNormWeightsTensor(tensorInfo4); - armnn::ScopedCpuTensorHandle outputLayerNormWeightsTensor(tensorInfo4); + armnn::ScopedTensorHandle inputToInputWeightsTensor(tensorInfo4x5); + armnn::ScopedTensorHandle inputToForgetWeightsTensor(tensorInfo4x5); + armnn::ScopedTensorHandle inputToCellWeightsTensor(tensorInfo4x5); + armnn::ScopedTensorHandle inputToOutputWeightsTensor(tensorInfo4x5); + armnn::ScopedTensorHandle recurrentToForgetWeightsTensor(tensorInfo4x3); + armnn::ScopedTensorHandle recurrentToInputWeightsTensor(tensorInfo4x3); + armnn::ScopedTensorHandle recurrentToCellWeightsTensor(tensorInfo4x3); + armnn::ScopedTensorHandle recurrentToOutputWeightsTensor(tensorInfo4x3); + armnn::ScopedTensorHandle cellToInputWeightsTensor(tensorInfo4); + armnn::ScopedTensorHandle inputGateBiasTensor(tensorInfo4); + armnn::ScopedTensorHandle forgetGateBiasTensor(tensorInfo4); + armnn::ScopedTensorHandle cellBiasTensor(tensorInfo4); + armnn::ScopedTensorHandle outputGateBiasTensor(tensorInfo4); + armnn::ScopedTensorHandle cellToForgetWeightsTensor(tensorInfo4); + armnn::ScopedTensorHandle cellToOutputWeightsTensor(tensorInfo4); + armnn::ScopedTensorHandle projectionWeightsTensor(tensorInfo3x4); + armnn::ScopedTensorHandle projectionBiasTensor(tensorInfo3); + + armnn::ScopedTensorHandle inputLayerNormWeightsTensor(tensorInfo4); + armnn::ScopedTensorHandle forgetLayerNormWeightsTensor(tensorInfo4); + armnn::ScopedTensorHandle cellLayerNormWeightsTensor(tensorInfo4); + armnn::ScopedTensorHandle outputLayerNormWeightsTensor(tensorInfo4); AllocateAndCopyDataToITensorHandle(&inputToInputWeightsTensor, &inputToInputWeights[0][0]); AllocateAndCopyDataToITensorHandle(&inputToForgetWeightsTensor, &inputToForgetWeights[0][0]); @@ -1673,21 +1673,21 @@ LayerTestResult QuantizedLstmTestImpl( auto cellBias = MakeTensor(biasInfo, {39481, 48624, 48976, -21419}); auto outputGateBias = MakeTensor(biasInfo, {-58999, -17050, -41852, -40538}); - // ScopedCpuTensorHandles - armnn::ScopedCpuTensorHandle inputToInputWeightsTensor(inputWeightsInfo); - armnn::ScopedCpuTensorHandle inputToForgetWeightsTensor(inputWeightsInfo); - armnn::ScopedCpuTensorHandle inputToCellWeightsTensor(inputWeightsInfo); - armnn::ScopedCpuTensorHandle inputToOutputWeightsTensor(inputWeightsInfo); + // ScopedTensorHandles + armnn::ScopedTensorHandle inputToInputWeightsTensor(inputWeightsInfo); + armnn::ScopedTensorHandle inputToForgetWeightsTensor(inputWeightsInfo); + armnn::ScopedTensorHandle inputToCellWeightsTensor(inputWeightsInfo); + armnn::ScopedTensorHandle inputToOutputWeightsTensor(inputWeightsInfo); - armnn::ScopedCpuTensorHandle recurrentToInputWeightsTensor(recurrentWeightsInfo); - armnn::ScopedCpuTensorHandle recurrentToForgetWeightsTensor(recurrentWeightsInfo); - armnn::ScopedCpuTensorHandle recurrentToCellWeightsTensor(recurrentWeightsInfo); - armnn::ScopedCpuTensorHandle recurrentToOutputWeightsTensor(recurrentWeightsInfo); + armnn::ScopedTensorHandle recurrentToInputWeightsTensor(recurrentWeightsInfo); + armnn::ScopedTensorHandle recurrentToForgetWeightsTensor(recurrentWeightsInfo); + armnn::ScopedTensorHandle recurrentToCellWeightsTensor(recurrentWeightsInfo); + armnn::ScopedTensorHandle recurrentToOutputWeightsTensor(recurrentWeightsInfo); - armnn::ScopedCpuTensorHandle inputGateBiasTensor(biasInfo); - armnn::ScopedCpuTensorHandle forgetGateBiasTensor(biasInfo); - armnn::ScopedCpuTensorHandle cellBiasTensor(biasInfo); - armnn::ScopedCpuTensorHandle outputGateBiasTensor(biasInfo); + armnn::ScopedTensorHandle inputGateBiasTensor(biasInfo); + armnn::ScopedTensorHandle forgetGateBiasTensor(biasInfo); + armnn::ScopedTensorHandle cellBiasTensor(biasInfo); + armnn::ScopedTensorHandle outputGateBiasTensor(biasInfo); // Allocate and copy data AllocateAndCopyDataToITensorHandle(&inputToInputWeightsTensor, &inputToInputWeights[0][0]); @@ -1891,22 +1891,22 @@ LayerTestResult QLstmTestImpl( auto cellLayerNormWeights = MakeTensor(layerNormWeightsInfo, {22937, 6553, 9830, 26214}); auto outputLayerNormWeights = MakeTensor(layerNormWeightsInfo, {19660, 6553, 6553, 16384}); - // ScopedCpuTensorHandles - armnn::ScopedCpuTensorHandle inputToForgetWeightsTensor(inputWeightsInfo); - armnn::ScopedCpuTensorHandle inputToCellWeightsTensor(inputWeightsInfo); - armnn::ScopedCpuTensorHandle inputToOutputWeightsTensor(inputWeightsInfo); + // ScopedTensorHandles + armnn::ScopedTensorHandle inputToForgetWeightsTensor(inputWeightsInfo); + armnn::ScopedTensorHandle inputToCellWeightsTensor(inputWeightsInfo); + armnn::ScopedTensorHandle inputToOutputWeightsTensor(inputWeightsInfo); - armnn::ScopedCpuTensorHandle recurrentToForgetWeightsTensor(recurrentWeightsInfo); - armnn::ScopedCpuTensorHandle recurrentToCellWeightsTensor(recurrentWeightsInfo); - armnn::ScopedCpuTensorHandle recurrentToOutputWeightsTensor(recurrentWeightsInfo); + armnn::ScopedTensorHandle recurrentToForgetWeightsTensor(recurrentWeightsInfo); + armnn::ScopedTensorHandle recurrentToCellWeightsTensor(recurrentWeightsInfo); + armnn::ScopedTensorHandle recurrentToOutputWeightsTensor(recurrentWeightsInfo); - armnn::ScopedCpuTensorHandle forgetGateBiasTensor(biasInfo); - armnn::ScopedCpuTensorHandle cellBiasTensor(biasInfo); - armnn::ScopedCpuTensorHandle outputGateBiasTensor(biasInfo); + armnn::ScopedTensorHandle forgetGateBiasTensor(biasInfo); + armnn::ScopedTensorHandle cellBiasTensor(biasInfo); + armnn::ScopedTensorHandle outputGateBiasTensor(biasInfo); - armnn::ScopedCpuTensorHandle forgetLayerNormWeightsTensor(layerNormWeightsInfo); - armnn::ScopedCpuTensorHandle cellLayerNormWeightsTensor(layerNormWeightsInfo); - armnn::ScopedCpuTensorHandle outputLayerNormWeightsTensor(layerNormWeightsInfo); + armnn::ScopedTensorHandle forgetLayerNormWeightsTensor(layerNormWeightsInfo); + armnn::ScopedTensorHandle cellLayerNormWeightsTensor(layerNormWeightsInfo); + armnn::ScopedTensorHandle outputLayerNormWeightsTensor(layerNormWeightsInfo); // Allocate and copy data AllocateAndCopyDataToITensorHandle(&inputToForgetWeightsTensor, &inputToForgetWeights[0][0]); @@ -2145,28 +2145,28 @@ LayerTestResult QLstmTestImpl1( auto projectionWeights = MakeTensor(projectionWeightsInfo, {-25, 51, 3, -51, 25, 127, 77, 20, 18, 51, -102, 51}); - // ScopedCpuTensorHandles - armnn::ScopedCpuTensorHandle inputToInputWeightsTensor(inputWeightsInfo); - armnn::ScopedCpuTensorHandle inputToForgetWeightsTensor(inputWeightsInfo); - armnn::ScopedCpuTensorHandle inputToCellWeightsTensor(inputWeightsInfo); - armnn::ScopedCpuTensorHandle inputToOutputWeightsTensor(inputWeightsInfo); + // ScopedTensorHandles + armnn::ScopedTensorHandle inputToInputWeightsTensor(inputWeightsInfo); + armnn::ScopedTensorHandle inputToForgetWeightsTensor(inputWeightsInfo); + armnn::ScopedTensorHandle inputToCellWeightsTensor(inputWeightsInfo); + armnn::ScopedTensorHandle inputToOutputWeightsTensor(inputWeightsInfo); - armnn::ScopedCpuTensorHandle recurrentToInputWeightsTensor(recurrentWeightsInfo); - armnn::ScopedCpuTensorHandle recurrentToForgetWeightsTensor(recurrentWeightsInfo); - armnn::ScopedCpuTensorHandle recurrentToCellWeightsTensor(recurrentWeightsInfo); - armnn::ScopedCpuTensorHandle recurrentToOutputWeightsTensor(recurrentWeightsInfo); + armnn::ScopedTensorHandle recurrentToInputWeightsTensor(recurrentWeightsInfo); + armnn::ScopedTensorHandle recurrentToForgetWeightsTensor(recurrentWeightsInfo); + armnn::ScopedTensorHandle recurrentToCellWeightsTensor(recurrentWeightsInfo); + armnn::ScopedTensorHandle recurrentToOutputWeightsTensor(recurrentWeightsInfo); - armnn::ScopedCpuTensorHandle inputGateBiasTensor(biasInfo); - armnn::ScopedCpuTensorHandle forgetGateBiasTensor(biasInfo); - armnn::ScopedCpuTensorHandle cellBiasTensor(biasInfo); - armnn::ScopedCpuTensorHandle outputGateBiasTensor(biasInfo); + armnn::ScopedTensorHandle inputGateBiasTensor(biasInfo); + armnn::ScopedTensorHandle forgetGateBiasTensor(biasInfo); + armnn::ScopedTensorHandle cellBiasTensor(biasInfo); + armnn::ScopedTensorHandle outputGateBiasTensor(biasInfo); - armnn::ScopedCpuTensorHandle inputLayerNormWeightsTensor(layerNormWeightsInfo); - armnn::ScopedCpuTensorHandle forgetLayerNormWeightsTensor(layerNormWeightsInfo); - armnn::ScopedCpuTensorHandle cellLayerNormWeightsTensor(layerNormWeightsInfo); - armnn::ScopedCpuTensorHandle outputLayerNormWeightsTensor(layerNormWeightsInfo); + armnn::ScopedTensorHandle inputLayerNormWeightsTensor(layerNormWeightsInfo); + armnn::ScopedTensorHandle forgetLayerNormWeightsTensor(layerNormWeightsInfo); + armnn::ScopedTensorHandle cellLayerNormWeightsTensor(layerNormWeightsInfo); + armnn::ScopedTensorHandle outputLayerNormWeightsTensor(layerNormWeightsInfo); - armnn::ScopedCpuTensorHandle projectionWeightsTensor(projectionWeightsInfo); + armnn::ScopedTensorHandle projectionWeightsTensor(projectionWeightsInfo); // Allocate and copy data AllocateAndCopyDataToITensorHandle(&inputToInputWeightsTensor, &inputToInputWeights[0][0]); @@ -2411,24 +2411,24 @@ LayerTestResult QLstmTestImpl2( auto projectionWeights = MakeTensor(projectionWeightsInfo, {-25, 51, 3, -51, 25, 127, 77, 20, 18, 51, -102, 51}); - // ScopedCpuTensorHandles - armnn::ScopedCpuTensorHandle inputToForgetWeightsTensor(inputWeightsInfo); - armnn::ScopedCpuTensorHandle inputToCellWeightsTensor(inputWeightsInfo); - armnn::ScopedCpuTensorHandle inputToOutputWeightsTensor(inputWeightsInfo); + // ScopedTensorHandles + armnn::ScopedTensorHandle inputToForgetWeightsTensor(inputWeightsInfo); + armnn::ScopedTensorHandle inputToCellWeightsTensor(inputWeightsInfo); + armnn::ScopedTensorHandle inputToOutputWeightsTensor(inputWeightsInfo); - armnn::ScopedCpuTensorHandle recurrentToForgetWeightsTensor(recurrentWeightsInfo); - armnn::ScopedCpuTensorHandle recurrentToCellWeightsTensor(recurrentWeightsInfo); - armnn::ScopedCpuTensorHandle recurrentToOutputWeightsTensor(recurrentWeightsInfo); + armnn::ScopedTensorHandle recurrentToForgetWeightsTensor(recurrentWeightsInfo); + armnn::ScopedTensorHandle recurrentToCellWeightsTensor(recurrentWeightsInfo); + armnn::ScopedTensorHandle recurrentToOutputWeightsTensor(recurrentWeightsInfo); - armnn::ScopedCpuTensorHandle forgetGateBiasTensor(biasInfo); - armnn::ScopedCpuTensorHandle cellBiasTensor(biasInfo); - armnn::ScopedCpuTensorHandle outputGateBiasTensor(biasInfo); + armnn::ScopedTensorHandle forgetGateBiasTensor(biasInfo); + armnn::ScopedTensorHandle cellBiasTensor(biasInfo); + armnn::ScopedTensorHandle outputGateBiasTensor(biasInfo); - armnn::ScopedCpuTensorHandle forgetLayerNormWeightsTensor(layerNormWeightsInfo); - armnn::ScopedCpuTensorHandle cellLayerNormWeightsTensor(layerNormWeightsInfo); - armnn::ScopedCpuTensorHandle outputLayerNormWeightsTensor(layerNormWeightsInfo); + armnn::ScopedTensorHandle forgetLayerNormWeightsTensor(layerNormWeightsInfo); + armnn::ScopedTensorHandle cellLayerNormWeightsTensor(layerNormWeightsInfo); + armnn::ScopedTensorHandle outputLayerNormWeightsTensor(layerNormWeightsInfo); - armnn::ScopedCpuTensorHandle projectionWeightsTensor(projectionWeightsInfo); + armnn::ScopedTensorHandle projectionWeightsTensor(projectionWeightsInfo); // Allocate and copy data AllocateAndCopyDataToITensorHandle(&inputToForgetWeightsTensor, &inputToForgetWeights[0][0]); diff --git a/src/backends/backendsCommon/test/layerTests/NormalizationTestImpl.cpp b/src/backends/backendsCommon/test/layerTests/NormalizationTestImpl.cpp index 2e8e16f0c2..b52dcd5303 100644 --- a/src/backends/backendsCommon/test/layerTests/NormalizationTestImpl.cpp +++ b/src/backends/backendsCommon/test/layerTests/NormalizationTestImpl.cpp @@ -10,7 +10,7 @@ #include -#include +#include #include #include @@ -75,7 +75,7 @@ LayerTestResult SimpleNormalizationTestImpl( data.m_Parameters.m_K = kappa; data.m_Parameters.m_DataLayout = armnn::DataLayout::NCHW; - armnn::PassthroughCpuTensorHandle refHandle(outputTensorInfo, &ret.outputExpected[0][0][0][0]); + armnn::PassthroughTensorHandle refHandle(outputTensorInfo, &ret.outputExpected[0][0][0][0]); armnn::NormalizationQueueDescriptor refData = data; armnn::WorkloadInfo refInfo = info; SetWorkloadOutput(refData, refInfo, 0, outputTensorInfo, &refHandle); @@ -219,7 +219,7 @@ LayerTestResult SimpleNormalizationNhwcTestImpl( data.m_Parameters.m_K = kappa; data.m_Parameters.m_DataLayout = armnn::DataLayout::NHWC; - armnn::PassthroughCpuTensorHandle refHandle(outputTensorInfo, &ret.outputExpected[0][0][0][0]); + armnn::PassthroughTensorHandle refHandle(outputTensorInfo, &ret.outputExpected[0][0][0][0]); armnn::NormalizationQueueDescriptor refData = data; armnn::WorkloadInfo refInfo = info; SetWorkloadOutput(refData, refInfo, 0, outputTensorInfo, &refHandle); diff --git a/src/backends/backendsCommon/test/layerTests/SoftmaxTestImpl.cpp b/src/backends/backendsCommon/test/layerTests/SoftmaxTestImpl.cpp index c4cc914115..9688ce49f2 100644 --- a/src/backends/backendsCommon/test/layerTests/SoftmaxTestImpl.cpp +++ b/src/backends/backendsCommon/test/layerTests/SoftmaxTestImpl.cpp @@ -9,7 +9,7 @@ #include -#include +#include #include #include diff --git a/src/backends/backendsCommon/test/layerTests/TransposeConvolution2dTestImpl.cpp b/src/backends/backendsCommon/test/layerTests/TransposeConvolution2dTestImpl.cpp index 328e724b54..85ce7e5e6f 100644 --- a/src/backends/backendsCommon/test/layerTests/TransposeConvolution2dTestImpl.cpp +++ b/src/backends/backendsCommon/test/layerTests/TransposeConvolution2dTestImpl.cpp @@ -10,7 +10,7 @@ #include -#include +#include #include #include @@ -68,7 +68,7 @@ void TransposeConvolution2dTestImpl(armnn::IWorkloadFactory& workloadFactory, } // set up weights - ScopedCpuTensorHandle weightsTensor(weights.first); + ScopedTensorHandle weightsTensor(weights.first); TransposeConvolution2dQueueDescriptor queueDescriptor; queueDescriptor.m_Parameters = descriptor; @@ -76,11 +76,11 @@ void TransposeConvolution2dTestImpl(armnn::IWorkloadFactory& workloadFactory, AllocateAndCopyDataToITensorHandle(&weightsTensor, weights.second.data()); - std::unique_ptr biasesTensor; + std::unique_ptr biasesTensor; if (descriptor.m_BiasEnabled) { // set up biases - biasesTensor = std::make_unique(biases.value().first); + biasesTensor = std::make_unique(biases.value().first); queueDescriptor.m_Bias = biasesTensor.get(); AllocateAndCopyDataToITensorHandle(biasesTensor.get(), biases.value().second.data()); @@ -643,8 +643,8 @@ LayerTestResult TransposeConvolution2dPerAxisQuantTest( std::unique_ptr outputHandle = tensorHandleFactory.CreateTensorHandle(outputInfo); WorkloadInfo workloadInfo; - ScopedCpuTensorHandle weightTensor(kernelInfo); - ScopedCpuTensorHandle biasTensor(biasInfo); + ScopedTensorHandle weightTensor(kernelInfo); + ScopedTensorHandle biasTensor(biasInfo); AllocateAndCopyDataToITensorHandle(&weightTensor, kernelData.data()); AllocateAndCopyDataToITensorHandle(&biasTensor, biasData.data()); diff --git a/src/backends/cl/ClWorkloadFactory.cpp b/src/backends/cl/ClWorkloadFactory.cpp index 19ad773338..0d8d0a7c28 100644 --- a/src/backends/cl/ClWorkloadFactory.cpp +++ b/src/backends/cl/ClWorkloadFactory.cpp @@ -16,10 +16,10 @@ #include #include -#include #include #include #include +#include #include #include diff --git a/src/backends/cl/test/ClCreateWorkloadTests.cpp b/src/backends/cl/test/ClCreateWorkloadTests.cpp index e22479c25b..47e2f4e8d7 100644 --- a/src/backends/cl/test/ClCreateWorkloadTests.cpp +++ b/src/backends/cl/test/ClCreateWorkloadTests.cpp @@ -395,8 +395,8 @@ BOOST_AUTO_TEST_CASE(CreateConvolution2dClCompiledContextWorkload) WorkloadInfo workloadInfo; - ScopedCpuTensorHandle weightTensor(kernelInfo); - ScopedCpuTensorHandle biasTensor(biasInfo); + ScopedTensorHandle weightTensor(kernelInfo); + ScopedTensorHandle biasTensor(biasInfo); AllocateAndCopyDataToITensorHandle(&weightTensor, kernelData.data()); AllocateAndCopyDataToITensorHandle(&biasTensor, biasData.data()); diff --git a/src/backends/cl/test/ClLayerSupportTests.cpp b/src/backends/cl/test/ClLayerSupportTests.cpp index 2b8b0d48a7..794a45fa48 100644 --- a/src/backends/cl/test/ClLayerSupportTests.cpp +++ b/src/backends/cl/test/ClLayerSupportTests.cpp @@ -10,7 +10,7 @@ #include #include -#include +#include #include #include #include diff --git a/src/backends/cl/test/Fp16SupportTest.cpp b/src/backends/cl/test/Fp16SupportTest.cpp index b7d274fdca..5afafcb783 100644 --- a/src/backends/cl/test/Fp16SupportTest.cpp +++ b/src/backends/cl/test/Fp16SupportTest.cpp @@ -10,7 +10,7 @@ #include #include -#include +#include #include #include diff --git a/src/backends/cl/test/OpenClTimerTest.cpp b/src/backends/cl/test/OpenClTimerTest.cpp index 0e1f28ec4e..1b86d2e304 100644 --- a/src/backends/cl/test/OpenClTimerTest.cpp +++ b/src/backends/cl/test/OpenClTimerTest.cpp @@ -9,7 +9,7 @@ #include -#include +#include #include #include @@ -79,10 +79,10 @@ BOOST_AUTO_TEST_CASE(OpenClTimerBatchNorm) BatchNormalizationQueueDescriptor data; WorkloadInfo info; - ScopedCpuTensorHandle meanTensor(tensorInfo); - ScopedCpuTensorHandle varianceTensor(tensorInfo); - ScopedCpuTensorHandle betaTensor(tensorInfo); - ScopedCpuTensorHandle gammaTensor(tensorInfo); + ScopedTensorHandle meanTensor(tensorInfo); + ScopedTensorHandle varianceTensor(tensorInfo); + ScopedTensorHandle betaTensor(tensorInfo); + ScopedTensorHandle gammaTensor(tensorInfo); AllocateAndCopyDataToITensorHandle(&meanTensor, &mean[0]); AllocateAndCopyDataToITensorHandle(&varianceTensor, &variance[0]); diff --git a/src/backends/cl/workloads/ClActivationWorkload.cpp b/src/backends/cl/workloads/ClActivationWorkload.cpp index 8997a9720d..e2f64a9d7e 100644 --- a/src/backends/cl/workloads/ClActivationWorkload.cpp +++ b/src/backends/cl/workloads/ClActivationWorkload.cpp @@ -7,7 +7,7 @@ #include "ClWorkloadUtils.hpp" -#include +#include #include #include #include diff --git a/src/backends/cl/workloads/ClAdditionWorkload.cpp b/src/backends/cl/workloads/ClAdditionWorkload.cpp index 0ab7446026..4793cc6f8f 100644 --- a/src/backends/cl/workloads/ClAdditionWorkload.cpp +++ b/src/backends/cl/workloads/ClAdditionWorkload.cpp @@ -6,7 +6,7 @@ #include "ClAdditionWorkload.hpp" #include -#include +#include #include #include diff --git a/src/backends/cl/workloads/ClArgMinMaxWorkload.cpp b/src/backends/cl/workloads/ClArgMinMaxWorkload.cpp index 8974930afa..7475cfa315 100644 --- a/src/backends/cl/workloads/ClArgMinMaxWorkload.cpp +++ b/src/backends/cl/workloads/ClArgMinMaxWorkload.cpp @@ -8,7 +8,7 @@ #include -#include +#include #include #include diff --git a/src/backends/cl/workloads/ClBatchNormalizationFloatWorkload.cpp b/src/backends/cl/workloads/ClBatchNormalizationFloatWorkload.cpp index daaed17a90..361d6f87a5 100644 --- a/src/backends/cl/workloads/ClBatchNormalizationFloatWorkload.cpp +++ b/src/backends/cl/workloads/ClBatchNormalizationFloatWorkload.cpp @@ -8,7 +8,7 @@ #include #include -#include +#include #include #include diff --git a/src/backends/cl/workloads/ClBatchToSpaceNdWorkload.cpp b/src/backends/cl/workloads/ClBatchToSpaceNdWorkload.cpp index 8978c5a66e..b9736db642 100644 --- a/src/backends/cl/workloads/ClBatchToSpaceNdWorkload.cpp +++ b/src/backends/cl/workloads/ClBatchToSpaceNdWorkload.cpp @@ -6,7 +6,7 @@ #include "ClBatchToSpaceNdWorkload.hpp" #include -#include +#include #include #include diff --git a/src/backends/cl/workloads/ClComparisonWorkload.cpp b/src/backends/cl/workloads/ClComparisonWorkload.cpp index 20e5669807..35e6d68733 100644 --- a/src/backends/cl/workloads/ClComparisonWorkload.cpp +++ b/src/backends/cl/workloads/ClComparisonWorkload.cpp @@ -10,7 +10,7 @@ #include #include -#include +#include #include #include diff --git a/src/backends/cl/workloads/ClConcatWorkload.cpp b/src/backends/cl/workloads/ClConcatWorkload.cpp index 3c5f23742a..1c2d476e0c 100644 --- a/src/backends/cl/workloads/ClConcatWorkload.cpp +++ b/src/backends/cl/workloads/ClConcatWorkload.cpp @@ -6,7 +6,7 @@ #include "ClWorkloadUtils.hpp" #include #include -#include +#include #include #include diff --git a/src/backends/cl/workloads/ClConstantWorkload.cpp b/src/backends/cl/workloads/ClConstantWorkload.cpp index 40acb8ebd0..60dcd59268 100644 --- a/src/backends/cl/workloads/ClConstantWorkload.cpp +++ b/src/backends/cl/workloads/ClConstantWorkload.cpp @@ -8,7 +8,7 @@ #include #include #include -#include +#include #include "ClWorkloadUtils.hpp" diff --git a/src/backends/cl/workloads/ClConvolution2dWorkload.cpp b/src/backends/cl/workloads/ClConvolution2dWorkload.cpp index 99a981bd0c..5c731aa0a1 100644 --- a/src/backends/cl/workloads/ClConvolution2dWorkload.cpp +++ b/src/backends/cl/workloads/ClConvolution2dWorkload.cpp @@ -12,7 +12,7 @@ #include #include #include -#include +#include #include diff --git a/src/backends/cl/workloads/ClDepthwiseConvolutionWorkload.cpp b/src/backends/cl/workloads/ClDepthwiseConvolutionWorkload.cpp index 655f0c9c35..50cdb0a626 100644 --- a/src/backends/cl/workloads/ClDepthwiseConvolutionWorkload.cpp +++ b/src/backends/cl/workloads/ClDepthwiseConvolutionWorkload.cpp @@ -12,7 +12,7 @@ #include #include #include -#include +#include #include #include @@ -137,7 +137,7 @@ ClDepthwiseConvolutionWorkload::ClDepthwiseConvolutionWorkload( ARMNN_ASSERT(m_DepthwiseConvolutionLayer); - ScopedCpuTensorHandle weightsPermutedHandle(weightPermuted); + ScopedTensorHandle weightsPermutedHandle(weightPermuted); InitializeArmComputeClTensorData(*m_KernelTensor, &weightsPermutedHandle); if (m_BiasTensor) diff --git a/src/backends/cl/workloads/ClDequantizeWorkload.cpp b/src/backends/cl/workloads/ClDequantizeWorkload.cpp index 52d8fab93c..42cc579a8c 100644 --- a/src/backends/cl/workloads/ClDequantizeWorkload.cpp +++ b/src/backends/cl/workloads/ClDequantizeWorkload.cpp @@ -8,7 +8,7 @@ #include #include -#include +#include #include diff --git a/src/backends/cl/workloads/ClDivisionWorkload.cpp b/src/backends/cl/workloads/ClDivisionWorkload.cpp index be5f3b8225..76220a1b64 100644 --- a/src/backends/cl/workloads/ClDivisionWorkload.cpp +++ b/src/backends/cl/workloads/ClDivisionWorkload.cpp @@ -6,7 +6,7 @@ #include "ClDivisionWorkload.hpp" #include -#include +#include #include diff --git a/src/backends/cl/workloads/ClFullyConnectedWorkload.cpp b/src/backends/cl/workloads/ClFullyConnectedWorkload.cpp index 9135d27376..d1d911ac13 100644 --- a/src/backends/cl/workloads/ClFullyConnectedWorkload.cpp +++ b/src/backends/cl/workloads/ClFullyConnectedWorkload.cpp @@ -5,7 +5,7 @@ #include "ClFullyConnectedWorkload.hpp" #include -#include +#include #include #include #include diff --git a/src/backends/cl/workloads/ClL2NormalizationFloatWorkload.cpp b/src/backends/cl/workloads/ClL2NormalizationFloatWorkload.cpp index bd38219a3e..984f21a4db 100644 --- a/src/backends/cl/workloads/ClL2NormalizationFloatWorkload.cpp +++ b/src/backends/cl/workloads/ClL2NormalizationFloatWorkload.cpp @@ -5,7 +5,7 @@ #include "ClL2NormalizationFloatWorkload.hpp" #include -#include +#include #include #include "ClWorkloadUtils.hpp" diff --git a/src/backends/cl/workloads/ClLstmFloatWorkload.cpp b/src/backends/cl/workloads/ClLstmFloatWorkload.cpp index 58cc735704..908f20bfe5 100644 --- a/src/backends/cl/workloads/ClLstmFloatWorkload.cpp +++ b/src/backends/cl/workloads/ClLstmFloatWorkload.cpp @@ -5,7 +5,7 @@ #include "ClLstmFloatWorkload.hpp" #include -#include +#include #include #include diff --git a/src/backends/cl/workloads/ClMaximumWorkload.cpp b/src/backends/cl/workloads/ClMaximumWorkload.cpp index 85bea47f21..0aa15e5dd3 100644 --- a/src/backends/cl/workloads/ClMaximumWorkload.cpp +++ b/src/backends/cl/workloads/ClMaximumWorkload.cpp @@ -10,7 +10,7 @@ #include #include -#include +#include #include #include diff --git a/src/backends/cl/workloads/ClMinimumWorkload.cpp b/src/backends/cl/workloads/ClMinimumWorkload.cpp index 07a78b5008..4924002432 100644 --- a/src/backends/cl/workloads/ClMinimumWorkload.cpp +++ b/src/backends/cl/workloads/ClMinimumWorkload.cpp @@ -10,7 +10,7 @@ #include #include -#include +#include #include #include diff --git a/src/backends/cl/workloads/ClMultiplicationWorkload.cpp b/src/backends/cl/workloads/ClMultiplicationWorkload.cpp index 31e9d022cc..2bd1e1615a 100644 --- a/src/backends/cl/workloads/ClMultiplicationWorkload.cpp +++ b/src/backends/cl/workloads/ClMultiplicationWorkload.cpp @@ -6,7 +6,7 @@ #include "ClMultiplicationWorkload.hpp" #include -#include +#include #include diff --git a/src/backends/cl/workloads/ClNormalizationFloatWorkload.cpp b/src/backends/cl/workloads/ClNormalizationFloatWorkload.cpp index 290d29ae52..e9b2caf6ee 100644 --- a/src/backends/cl/workloads/ClNormalizationFloatWorkload.cpp +++ b/src/backends/cl/workloads/ClNormalizationFloatWorkload.cpp @@ -5,7 +5,7 @@ #include "ClNormalizationFloatWorkload.hpp" #include -#include +#include #include #include #include diff --git a/src/backends/cl/workloads/ClPreluWorkload.cpp b/src/backends/cl/workloads/ClPreluWorkload.cpp index 73fa887532..9b45441b02 100644 --- a/src/backends/cl/workloads/ClPreluWorkload.cpp +++ b/src/backends/cl/workloads/ClPreluWorkload.cpp @@ -5,7 +5,7 @@ #include "ClPreluWorkload.hpp" #include "ClWorkloadUtils.hpp" -#include +#include #include #include #include diff --git a/src/backends/cl/workloads/ClQuantizeWorkload.cpp b/src/backends/cl/workloads/ClQuantizeWorkload.cpp index 5c945e0921..527c64013b 100644 --- a/src/backends/cl/workloads/ClQuantizeWorkload.cpp +++ b/src/backends/cl/workloads/ClQuantizeWorkload.cpp @@ -9,7 +9,7 @@ #include #include -#include +#include #include #include diff --git a/src/backends/cl/workloads/ClQuantizedLstmWorkload.cpp b/src/backends/cl/workloads/ClQuantizedLstmWorkload.cpp index 636bdecbeb..d50414b1cf 100644 --- a/src/backends/cl/workloads/ClQuantizedLstmWorkload.cpp +++ b/src/backends/cl/workloads/ClQuantizedLstmWorkload.cpp @@ -6,7 +6,7 @@ #include "ClQuantizedLstmWorkload.hpp" #include "ClWorkloadUtils.hpp" -#include +#include #include #include diff --git a/src/backends/cl/workloads/ClReshapeWorkload.cpp b/src/backends/cl/workloads/ClReshapeWorkload.cpp index 0988babf23..1f82cfbee2 100644 --- a/src/backends/cl/workloads/ClReshapeWorkload.cpp +++ b/src/backends/cl/workloads/ClReshapeWorkload.cpp @@ -5,7 +5,7 @@ #include "ClReshapeWorkload.hpp" #include -#include +#include #include "ClWorkloadUtils.hpp" diff --git a/src/backends/cl/workloads/ClResizeWorkload.cpp b/src/backends/cl/workloads/ClResizeWorkload.cpp index e47740624e..3406011d04 100644 --- a/src/backends/cl/workloads/ClResizeWorkload.cpp +++ b/src/backends/cl/workloads/ClResizeWorkload.cpp @@ -10,7 +10,7 @@ #include #include -#include +#include #include diff --git a/src/backends/cl/workloads/ClSpaceToBatchNdWorkload.cpp b/src/backends/cl/workloads/ClSpaceToBatchNdWorkload.cpp index 7b29cded0f..3aa8ebd2a8 100644 --- a/src/backends/cl/workloads/ClSpaceToBatchNdWorkload.cpp +++ b/src/backends/cl/workloads/ClSpaceToBatchNdWorkload.cpp @@ -11,7 +11,7 @@ #include #include #include -#include +#include #include #include #include diff --git a/src/backends/cl/workloads/ClSpaceToDepthWorkload.cpp b/src/backends/cl/workloads/ClSpaceToDepthWorkload.cpp index 7a590d26b6..67487c4bf1 100644 --- a/src/backends/cl/workloads/ClSpaceToDepthWorkload.cpp +++ b/src/backends/cl/workloads/ClSpaceToDepthWorkload.cpp @@ -8,7 +8,7 @@ #include #include -#include +#include #include #include diff --git a/src/backends/cl/workloads/ClSplitterWorkload.cpp b/src/backends/cl/workloads/ClSplitterWorkload.cpp index 70a817825e..8eb58c967e 100644 --- a/src/backends/cl/workloads/ClSplitterWorkload.cpp +++ b/src/backends/cl/workloads/ClSplitterWorkload.cpp @@ -10,7 +10,7 @@ #include #include #include -#include +#include #include diff --git a/src/backends/cl/workloads/ClStackWorkload.cpp b/src/backends/cl/workloads/ClStackWorkload.cpp index 749282f53a..38c76eb648 100644 --- a/src/backends/cl/workloads/ClStackWorkload.cpp +++ b/src/backends/cl/workloads/ClStackWorkload.cpp @@ -7,7 +7,7 @@ #include #include #include -#include +#include #include #include diff --git a/src/backends/cl/workloads/ClStridedSliceWorkload.cpp b/src/backends/cl/workloads/ClStridedSliceWorkload.cpp index 92e860fc42..adf32ce1fc 100644 --- a/src/backends/cl/workloads/ClStridedSliceWorkload.cpp +++ b/src/backends/cl/workloads/ClStridedSliceWorkload.cpp @@ -10,7 +10,7 @@ #include #include -#include +#include #include #include diff --git a/src/backends/cl/workloads/ClSubtractionWorkload.cpp b/src/backends/cl/workloads/ClSubtractionWorkload.cpp index 31e0becfd8..e320fec342 100644 --- a/src/backends/cl/workloads/ClSubtractionWorkload.cpp +++ b/src/backends/cl/workloads/ClSubtractionWorkload.cpp @@ -6,7 +6,7 @@ #include "ClSubtractionWorkload.hpp" #include -#include +#include #include #include diff --git a/src/backends/cl/workloads/ClTransposeConvolution2dWorkload.cpp b/src/backends/cl/workloads/ClTransposeConvolution2dWorkload.cpp index ff0fd5c168..b40b4b10ca 100644 --- a/src/backends/cl/workloads/ClTransposeConvolution2dWorkload.cpp +++ b/src/backends/cl/workloads/ClTransposeConvolution2dWorkload.cpp @@ -14,7 +14,7 @@ #include #include -#include +#include #include diff --git a/src/backends/cl/workloads/ClWorkloadUtils.hpp b/src/backends/cl/workloads/ClWorkloadUtils.hpp index b0cc8b4ed5..467505d55b 100644 --- a/src/backends/cl/workloads/ClWorkloadUtils.hpp +++ b/src/backends/cl/workloads/ClWorkloadUtils.hpp @@ -8,7 +8,7 @@ #include #include -#include +#include #include @@ -88,7 +88,7 @@ inline auto SetClSliceData(const std::vector& m_begin, } inline void InitializeArmComputeClTensorData(arm_compute::CLTensor& clTensor, - const ConstCpuTensorHandle* handle) + const ConstTensorHandle* handle) { ARMNN_ASSERT(handle); diff --git a/src/backends/neon/NeonWorkloadFactory.cpp b/src/backends/neon/NeonWorkloadFactory.cpp index 9967fb8604..8751d8ca2c 100644 --- a/src/backends/neon/NeonWorkloadFactory.cpp +++ b/src/backends/neon/NeonWorkloadFactory.cpp @@ -15,10 +15,10 @@ #include #include -#include #include #include #include +#include #include #include diff --git a/src/backends/neon/test/NeonLayerSupportTests.cpp b/src/backends/neon/test/NeonLayerSupportTests.cpp index a14122f573..13a4c732a4 100644 --- a/src/backends/neon/test/NeonLayerSupportTests.cpp +++ b/src/backends/neon/test/NeonLayerSupportTests.cpp @@ -9,7 +9,7 @@ #include #include -#include +#include #include #include #include diff --git a/src/backends/neon/test/NeonTimerTest.cpp b/src/backends/neon/test/NeonTimerTest.cpp index d9edca1b6d..9acd0e41e2 100644 --- a/src/backends/neon/test/NeonTimerTest.cpp +++ b/src/backends/neon/test/NeonTimerTest.cpp @@ -8,7 +8,7 @@ #include -#include +#include #include #include diff --git a/src/backends/neon/workloads/NeonAdditionWorkload.cpp b/src/backends/neon/workloads/NeonAdditionWorkload.cpp index 9300b317a9..5891677c0d 100644 --- a/src/backends/neon/workloads/NeonAdditionWorkload.cpp +++ b/src/backends/neon/workloads/NeonAdditionWorkload.cpp @@ -10,7 +10,7 @@ #include #include -#include +#include #include diff --git a/src/backends/neon/workloads/NeonArgMinMaxWorkload.cpp b/src/backends/neon/workloads/NeonArgMinMaxWorkload.cpp index 6290ecce17..cc85791ae6 100644 --- a/src/backends/neon/workloads/NeonArgMinMaxWorkload.cpp +++ b/src/backends/neon/workloads/NeonArgMinMaxWorkload.cpp @@ -8,7 +8,7 @@ #include -#include +#include #include #include diff --git a/src/backends/neon/workloads/NeonBatchNormalizationWorkload.cpp b/src/backends/neon/workloads/NeonBatchNormalizationWorkload.cpp index 33480faf69..5da7cca83e 100644 --- a/src/backends/neon/workloads/NeonBatchNormalizationWorkload.cpp +++ b/src/backends/neon/workloads/NeonBatchNormalizationWorkload.cpp @@ -12,7 +12,7 @@ #include -#include +#include #include diff --git a/src/backends/neon/workloads/NeonComparisonWorkload.cpp b/src/backends/neon/workloads/NeonComparisonWorkload.cpp index 6e1f208228..01a6a0c78b 100644 --- a/src/backends/neon/workloads/NeonComparisonWorkload.cpp +++ b/src/backends/neon/workloads/NeonComparisonWorkload.cpp @@ -7,7 +7,7 @@ #include #include #include -#include +#include namespace armnn { diff --git a/src/backends/neon/workloads/NeonConcatWorkload.cpp b/src/backends/neon/workloads/NeonConcatWorkload.cpp index a8f6dbed23..5cd906da41 100644 --- a/src/backends/neon/workloads/NeonConcatWorkload.cpp +++ b/src/backends/neon/workloads/NeonConcatWorkload.cpp @@ -9,7 +9,7 @@ #include #include -#include +#include #include namespace armnn diff --git a/src/backends/neon/workloads/NeonConstantWorkload.cpp b/src/backends/neon/workloads/NeonConstantWorkload.cpp index 0859abd394..77e4420794 100644 --- a/src/backends/neon/workloads/NeonConstantWorkload.cpp +++ b/src/backends/neon/workloads/NeonConstantWorkload.cpp @@ -11,7 +11,7 @@ #include #include #include -#include +#include #include namespace armnn diff --git a/src/backends/neon/workloads/NeonConvolution2dWorkload.cpp b/src/backends/neon/workloads/NeonConvolution2dWorkload.cpp index fd8be17dfd..32af3f853a 100644 --- a/src/backends/neon/workloads/NeonConvolution2dWorkload.cpp +++ b/src/backends/neon/workloads/NeonConvolution2dWorkload.cpp @@ -8,7 +8,7 @@ #include #include #include -#include +#include #include #include diff --git a/src/backends/neon/workloads/NeonDepthwiseConvolutionWorkload.cpp b/src/backends/neon/workloads/NeonDepthwiseConvolutionWorkload.cpp index db6bcc3ecb..ad509076b4 100644 --- a/src/backends/neon/workloads/NeonDepthwiseConvolutionWorkload.cpp +++ b/src/backends/neon/workloads/NeonDepthwiseConvolutionWorkload.cpp @@ -14,7 +14,7 @@ #include -#include +#include #include #include @@ -136,7 +136,7 @@ NeonDepthwiseConvolutionWorkload::NeonDepthwiseConvolutionWorkload( ARMNN_ASSERT(m_pDepthwiseConvolutionLayer); - ScopedCpuTensorHandle weightsPermutedHandle(weightPermuted); + ScopedTensorHandle weightsPermutedHandle(weightPermuted); InitializeArmComputeTensorData(*m_KernelTensor, &weightsPermutedHandle); if (m_Data.m_Parameters.m_BiasEnabled) diff --git a/src/backends/neon/workloads/NeonDequantizeWorkload.cpp b/src/backends/neon/workloads/NeonDequantizeWorkload.cpp index 9ae82ff79f..07323d19ca 100644 --- a/src/backends/neon/workloads/NeonDequantizeWorkload.cpp +++ b/src/backends/neon/workloads/NeonDequantizeWorkload.cpp @@ -11,7 +11,7 @@ #include #include -#include +#include #include namespace armnn diff --git a/src/backends/neon/workloads/NeonDivisionWorkload.cpp b/src/backends/neon/workloads/NeonDivisionWorkload.cpp index 1a26d9510a..fa61a100a9 100644 --- a/src/backends/neon/workloads/NeonDivisionWorkload.cpp +++ b/src/backends/neon/workloads/NeonDivisionWorkload.cpp @@ -10,7 +10,7 @@ #include -#include +#include namespace armnn { diff --git a/src/backends/neon/workloads/NeonFullyConnectedWorkload.cpp b/src/backends/neon/workloads/NeonFullyConnectedWorkload.cpp index 31489a0c32..713771be91 100644 --- a/src/backends/neon/workloads/NeonFullyConnectedWorkload.cpp +++ b/src/backends/neon/workloads/NeonFullyConnectedWorkload.cpp @@ -12,7 +12,7 @@ #include -#include +#include #include diff --git a/src/backends/neon/workloads/NeonInstanceNormalizationWorkload.cpp b/src/backends/neon/workloads/NeonInstanceNormalizationWorkload.cpp index d6c30817b8..1bfd1e4d47 100644 --- a/src/backends/neon/workloads/NeonInstanceNormalizationWorkload.cpp +++ b/src/backends/neon/workloads/NeonInstanceNormalizationWorkload.cpp @@ -8,7 +8,7 @@ #include "NeonWorkloadUtils.hpp" #include -#include +#include #include using namespace armnn::armcomputetensorutils; diff --git a/src/backends/neon/workloads/NeonMaximumWorkload.cpp b/src/backends/neon/workloads/NeonMaximumWorkload.cpp index 46d500bfdc..c4500d885a 100644 --- a/src/backends/neon/workloads/NeonMaximumWorkload.cpp +++ b/src/backends/neon/workloads/NeonMaximumWorkload.cpp @@ -6,7 +6,7 @@ #include "NeonMaximumWorkload.hpp" #include #include -#include +#include namespace armnn { diff --git a/src/backends/neon/workloads/NeonMinimumWorkload.cpp b/src/backends/neon/workloads/NeonMinimumWorkload.cpp index 53e483a182..519b3c4bc6 100644 --- a/src/backends/neon/workloads/NeonMinimumWorkload.cpp +++ b/src/backends/neon/workloads/NeonMinimumWorkload.cpp @@ -7,7 +7,7 @@ #include #include -#include +#include namespace armnn { diff --git a/src/backends/neon/workloads/NeonQuantizedLstmWorkload.cpp b/src/backends/neon/workloads/NeonQuantizedLstmWorkload.cpp index 4c2ba7513d..d809017692 100644 --- a/src/backends/neon/workloads/NeonQuantizedLstmWorkload.cpp +++ b/src/backends/neon/workloads/NeonQuantizedLstmWorkload.cpp @@ -7,7 +7,7 @@ #include "NeonWorkloadUtils.hpp" #include -#include +#include #include namespace armnn diff --git a/src/backends/neon/workloads/NeonResizeWorkload.cpp b/src/backends/neon/workloads/NeonResizeWorkload.cpp index ae07b250d6..ab01e30140 100644 --- a/src/backends/neon/workloads/NeonResizeWorkload.cpp +++ b/src/backends/neon/workloads/NeonResizeWorkload.cpp @@ -10,7 +10,7 @@ #include #include #include -#include +#include #include diff --git a/src/backends/neon/workloads/NeonSplitterWorkload.cpp b/src/backends/neon/workloads/NeonSplitterWorkload.cpp index de6f1378bd..4e428a2654 100644 --- a/src/backends/neon/workloads/NeonSplitterWorkload.cpp +++ b/src/backends/neon/workloads/NeonSplitterWorkload.cpp @@ -10,7 +10,7 @@ #include #include #include -#include +#include #include #include "NeonWorkloadUtils.hpp" diff --git a/src/backends/neon/workloads/NeonStackWorkload.cpp b/src/backends/neon/workloads/NeonStackWorkload.cpp index 696de65620..0b327b8a37 100644 --- a/src/backends/neon/workloads/NeonStackWorkload.cpp +++ b/src/backends/neon/workloads/NeonStackWorkload.cpp @@ -8,7 +8,7 @@ #include #include #include -#include +#include #include namespace armnn diff --git a/src/backends/neon/workloads/NeonSubtractionWorkload.cpp b/src/backends/neon/workloads/NeonSubtractionWorkload.cpp index 21f0f6fa41..64f68aa6e2 100644 --- a/src/backends/neon/workloads/NeonSubtractionWorkload.cpp +++ b/src/backends/neon/workloads/NeonSubtractionWorkload.cpp @@ -12,7 +12,7 @@ #include -#include +#include #include diff --git a/src/backends/neon/workloads/NeonTransposeConvolution2dWorkload.cpp b/src/backends/neon/workloads/NeonTransposeConvolution2dWorkload.cpp index 9c7e99c6a0..a1e545ce05 100644 --- a/src/backends/neon/workloads/NeonTransposeConvolution2dWorkload.cpp +++ b/src/backends/neon/workloads/NeonTransposeConvolution2dWorkload.cpp @@ -13,7 +13,7 @@ #include -#include +#include #include diff --git a/src/backends/neon/workloads/NeonWorkloadUtils.hpp b/src/backends/neon/workloads/NeonWorkloadUtils.hpp index 589d2ea017..ab7616fbe2 100644 --- a/src/backends/neon/workloads/NeonWorkloadUtils.hpp +++ b/src/backends/neon/workloads/NeonWorkloadUtils.hpp @@ -8,7 +8,7 @@ #include #include #include -#include +#include #include @@ -33,7 +33,7 @@ void CopyArmComputeTensorData(arm_compute::Tensor& dstTensor, const T* srcData) } inline void InitializeArmComputeTensorData(arm_compute::Tensor& tensor, - const ConstCpuTensorHandle* handle) + const ConstTensorHandle* handle) { ARMNN_ASSERT(handle); diff --git a/src/backends/reference/RefTensorHandle.hpp b/src/backends/reference/RefTensorHandle.hpp index 8c64dfbe63..3dfc0395df 100644 --- a/src/backends/reference/RefTensorHandle.hpp +++ b/src/backends/reference/RefTensorHandle.hpp @@ -4,7 +4,7 @@ // #pragma once -#include +#include #include "RefMemoryManager.hpp" diff --git a/src/backends/reference/RefWorkloadFactory.cpp b/src/backends/reference/RefWorkloadFactory.cpp index c1e3d58bd2..8e3bbe468f 100644 --- a/src/backends/reference/RefWorkloadFactory.cpp +++ b/src/backends/reference/RefWorkloadFactory.cpp @@ -3,10 +3,10 @@ // SPDX-License-Identifier: MIT // #include -#include #include #include #include +#include #include #include "RefWorkloadFactory.hpp" #include "RefBackendId.hpp" diff --git a/src/backends/reference/test/RefLayerSupportTests.cpp b/src/backends/reference/test/RefLayerSupportTests.cpp index 1648583210..a1487061b6 100644 --- a/src/backends/reference/test/RefLayerSupportTests.cpp +++ b/src/backends/reference/test/RefLayerSupportTests.cpp @@ -7,7 +7,7 @@ #include #include -#include +#include #include #include #include diff --git a/src/backends/reference/test/RefTensorHandleTests.cpp b/src/backends/reference/test/RefTensorHandleTests.cpp index b04d9d6c52..dadd1de1f2 100644 --- a/src/backends/reference/test/RefTensorHandleTests.cpp +++ b/src/backends/reference/test/RefTensorHandleTests.cpp @@ -173,8 +173,8 @@ BOOST_AUTO_TEST_CASE(TestManagedConstTensorHandle) void* mem = nullptr; TensorInfo info; - // Use PassthroughCpuTensor as others are abstract - auto passThroughHandle = std::make_shared(info, mem); + // Use PassthroughTensor as others are abstract + auto passThroughHandle = std::make_shared(info, mem); // Test managed handle is initialized with m_Mapped unset and once Map() called its set ManagedConstTensorHandle managedHandle(passThroughHandle); diff --git a/src/backends/reference/workloads/LstmUtils.cpp b/src/backends/reference/workloads/LstmUtils.cpp index f197aae291..8e1db0e88f 100644 --- a/src/backends/reference/workloads/LstmUtils.cpp +++ b/src/backends/reference/workloads/LstmUtils.cpp @@ -7,7 +7,7 @@ #include "LstmUtils.hpp" #include "BaseIterator.hpp" -#include +#include // Helper functions ported from the Android code base @@ -296,12 +296,12 @@ void SetActivationParameters(uint32_t activation, } } -std::unique_ptr AssignScopedCpuTensorHandle(const armnn::ConstCpuTensorHandle* ptr) +std::unique_ptr AssignScopedTensorHandle(const armnn::ConstTensorHandle *ptr) { if (!ptr) { return nullptr; } - return std::make_unique(*ptr); + return std::make_unique(*ptr); } diff --git a/src/backends/reference/workloads/LstmUtils.hpp b/src/backends/reference/workloads/LstmUtils.hpp index f6aff8b69f..11fbb77c5d 100644 --- a/src/backends/reference/workloads/LstmUtils.hpp +++ b/src/backends/reference/workloads/LstmUtils.hpp @@ -6,7 +6,7 @@ #pragma once #include "BaseIterator.hpp" -#include +#include // Helper functions ported from the Android code base // Refer to: android/external/tensorflow/tensorflow/contrib/lite/kernels/internal/reference/portable_tensor_utils.cc @@ -85,4 +85,4 @@ void SetActivationParameters(uint32_t activation, float& outA, float& outB); -std::unique_ptr AssignScopedCpuTensorHandle(const armnn::ConstCpuTensorHandle* ptr); +std::unique_ptr AssignScopedTensorHandle(const armnn::ConstTensorHandle *ptr); diff --git a/src/backends/reference/workloads/RefBatchNormalizationWorkload.cpp b/src/backends/reference/workloads/RefBatchNormalizationWorkload.cpp index e1068896ba..282374d89b 100644 --- a/src/backends/reference/workloads/RefBatchNormalizationWorkload.cpp +++ b/src/backends/reference/workloads/RefBatchNormalizationWorkload.cpp @@ -16,10 +16,10 @@ namespace armnn RefBatchNormalizationWorkload::RefBatchNormalizationWorkload(const BatchNormalizationQueueDescriptor& descriptor, const WorkloadInfo& info) : BaseWorkload(descriptor, info) - , m_Mean (std::make_unique(*(descriptor.m_Mean))) - , m_Variance(std::make_unique(*(descriptor.m_Variance))) - , m_Beta (std::make_unique(*(descriptor.m_Beta))) - , m_Gamma (std::make_unique(*(descriptor.m_Gamma))) + , m_Mean (std::make_unique(*(descriptor.m_Mean))) + , m_Variance(std::make_unique(*(descriptor.m_Variance))) + , m_Beta (std::make_unique(*(descriptor.m_Beta))) + , m_Gamma (std::make_unique(*(descriptor.m_Gamma))) {} void RefBatchNormalizationWorkload::Execute() const diff --git a/src/backends/reference/workloads/RefBatchNormalizationWorkload.hpp b/src/backends/reference/workloads/RefBatchNormalizationWorkload.hpp index a8a72ef65c..6fe05fd192 100644 --- a/src/backends/reference/workloads/RefBatchNormalizationWorkload.hpp +++ b/src/backends/reference/workloads/RefBatchNormalizationWorkload.hpp @@ -21,10 +21,10 @@ public: private: void Execute(std::vector inputs, std::vector outputs) const; - std::unique_ptr m_Mean; - std::unique_ptr m_Variance; - std::unique_ptr m_Beta; - std::unique_ptr m_Gamma; + std::unique_ptr m_Mean; + std::unique_ptr m_Variance; + std::unique_ptr m_Beta; + std::unique_ptr m_Gamma; }; } //namespace armnn diff --git a/src/backends/reference/workloads/RefConvolution2dWorkload.cpp b/src/backends/reference/workloads/RefConvolution2dWorkload.cpp index 6d0ab413d8..5ae1af8967 100644 --- a/src/backends/reference/workloads/RefConvolution2dWorkload.cpp +++ b/src/backends/reference/workloads/RefConvolution2dWorkload.cpp @@ -16,7 +16,7 @@ RefConvolution2dWorkload::RefConvolution2dWorkload( const Convolution2dQueueDescriptor& descriptor, const WorkloadInfo& info) : BaseWorkload(descriptor, info) { - m_Weight = std::make_unique(*(descriptor.m_Weight)); + m_Weight = std::make_unique(*(descriptor.m_Weight)); const TensorInfo& rFilterInfo = m_Weight->GetTensorInfo(); m_FilterShape = rFilterInfo.GetShape(); @@ -24,7 +24,7 @@ RefConvolution2dWorkload::RefConvolution2dWorkload( if (descriptor.m_Parameters.m_BiasEnabled) { - m_Bias = std::make_unique(*(descriptor.m_Bias)); + m_Bias = std::make_unique(*(descriptor.m_Bias)); const TensorInfo& biasInfo = m_Bias->GetTensorInfo(); m_BiasDecoder = MakeDecoder(biasInfo, m_Bias->Map(true)); } diff --git a/src/backends/reference/workloads/RefConvolution2dWorkload.hpp b/src/backends/reference/workloads/RefConvolution2dWorkload.hpp index 57df3ce6ae..3b2c76ade0 100644 --- a/src/backends/reference/workloads/RefConvolution2dWorkload.hpp +++ b/src/backends/reference/workloads/RefConvolution2dWorkload.hpp @@ -25,8 +25,8 @@ public: private: void Execute(std::vector inputs, std::vector outputs) const; - std::unique_ptr m_Weight; - std::unique_ptr m_Bias; + std::unique_ptr m_Weight; + std::unique_ptr m_Bias; std::unique_ptr> m_FilterDecoder; std::unique_ptr> m_BiasDecoder; diff --git a/src/backends/reference/workloads/RefDepthwiseConvolution2dWorkload.cpp b/src/backends/reference/workloads/RefDepthwiseConvolution2dWorkload.cpp index 8fe5dec7d1..b447d1a441 100644 --- a/src/backends/reference/workloads/RefDepthwiseConvolution2dWorkload.cpp +++ b/src/backends/reference/workloads/RefDepthwiseConvolution2dWorkload.cpp @@ -19,14 +19,14 @@ RefDepthwiseConvolution2dWorkload::RefDepthwiseConvolution2dWorkload( const DepthwiseConvolution2dQueueDescriptor& descriptor, const WorkloadInfo& info) : BaseWorkload(descriptor, info) { - m_Weight = std::make_unique(*(descriptor.m_Weight)); + m_Weight = std::make_unique(*(descriptor.m_Weight)); const TensorInfo& rFilterInfo = m_Weight->GetTensorInfo(); m_FilterShape = rFilterInfo.GetShape(); m_FilterDecoder = MakeDecoder(rFilterInfo, m_Weight->Map(true)); if (descriptor.m_Parameters.m_BiasEnabled) { - m_Bias = std::make_unique(*(descriptor.m_Bias)); + m_Bias = std::make_unique(*(descriptor.m_Bias)); const TensorInfo& biasInfo = m_Bias->GetTensorInfo(); m_BiasDecoder = MakeDecoder(biasInfo, m_Bias->Map(true)); } diff --git a/src/backends/reference/workloads/RefDepthwiseConvolution2dWorkload.hpp b/src/backends/reference/workloads/RefDepthwiseConvolution2dWorkload.hpp index 65a8fd76cf..62289ca34f 100644 --- a/src/backends/reference/workloads/RefDepthwiseConvolution2dWorkload.hpp +++ b/src/backends/reference/workloads/RefDepthwiseConvolution2dWorkload.hpp @@ -24,8 +24,8 @@ public: private: void Execute(std::vector inputs, std::vector outputs) const; - std::unique_ptr m_Weight; - std::unique_ptr m_Bias; + std::unique_ptr m_Weight; + std::unique_ptr m_Bias; std::unique_ptr > m_FilterDecoder; std::unique_ptr > m_BiasDecoder; diff --git a/src/backends/reference/workloads/RefDetectionPostProcessWorkload.cpp b/src/backends/reference/workloads/RefDetectionPostProcessWorkload.cpp index 6784e21585..4bc9eb1704 100644 --- a/src/backends/reference/workloads/RefDetectionPostProcessWorkload.cpp +++ b/src/backends/reference/workloads/RefDetectionPostProcessWorkload.cpp @@ -16,7 +16,7 @@ namespace armnn RefDetectionPostProcessWorkload::RefDetectionPostProcessWorkload( const DetectionPostProcessQueueDescriptor& descriptor, const WorkloadInfo& info) : BaseWorkload(descriptor, info), - m_Anchors(std::make_unique(*(descriptor.m_Anchors))) {} + m_Anchors(std::make_unique(*(descriptor.m_Anchors))) {} void RefDetectionPostProcessWorkload::Execute() const { diff --git a/src/backends/reference/workloads/RefDetectionPostProcessWorkload.hpp b/src/backends/reference/workloads/RefDetectionPostProcessWorkload.hpp index 007dcea456..920db96603 100644 --- a/src/backends/reference/workloads/RefDetectionPostProcessWorkload.hpp +++ b/src/backends/reference/workloads/RefDetectionPostProcessWorkload.hpp @@ -21,7 +21,7 @@ public: private: void Execute(std::vector inputs, std::vector outputs) const; - std::unique_ptr m_Anchors; + std::unique_ptr m_Anchors; }; } //namespace armnn diff --git a/src/backends/reference/workloads/RefFullyConnectedWorkload.cpp b/src/backends/reference/workloads/RefFullyConnectedWorkload.cpp index deb56d4c6b..3e63afac6f 100644 --- a/src/backends/reference/workloads/RefFullyConnectedWorkload.cpp +++ b/src/backends/reference/workloads/RefFullyConnectedWorkload.cpp @@ -18,14 +18,14 @@ RefFullyConnectedWorkload::RefFullyConnectedWorkload( { if (descriptor.m_Parameters.m_ConstantWeights) { - m_Weight = std::make_unique(*(descriptor.m_Weight)); + m_Weight = std::make_unique(*(descriptor.m_Weight)); const TensorInfo& rWeightInfo = m_Weight->GetTensorInfo(); m_WeightShape = rWeightInfo.GetShape(); m_WeightDecoder = MakeDecoder(rWeightInfo, m_Weight->Map(true)); if (descriptor.m_Parameters.m_BiasEnabled) { - m_Bias = std::make_unique(*(descriptor.m_Bias)); + m_Bias = std::make_unique(*(descriptor.m_Bias)); const TensorInfo& biasInfo = m_Bias->GetTensorInfo(); m_BiasDecoder = MakeDecoder(biasInfo, m_Bias->Map(true)); } diff --git a/src/backends/reference/workloads/RefFullyConnectedWorkload.hpp b/src/backends/reference/workloads/RefFullyConnectedWorkload.hpp index 5c0f67ebaf..6a4e5126cd 100644 --- a/src/backends/reference/workloads/RefFullyConnectedWorkload.hpp +++ b/src/backends/reference/workloads/RefFullyConnectedWorkload.hpp @@ -29,8 +29,8 @@ public: private: void PostAllocationConfigure(std::vector inputs, std::vector outputs); void Execute(std::vector inputs, std::vector outputs) const; - std::unique_ptr m_Weight; - std::unique_ptr m_Bias; + std::unique_ptr m_Weight; + std::unique_ptr m_Bias; std::unique_ptr> m_WeightDecoder; std::unique_ptr> m_BiasDecoder; diff --git a/src/backends/reference/workloads/RefLstmWorkload.cpp b/src/backends/reference/workloads/RefLstmWorkload.cpp index 09423547da..3ddfd334b8 100644 --- a/src/backends/reference/workloads/RefLstmWorkload.cpp +++ b/src/backends/reference/workloads/RefLstmWorkload.cpp @@ -15,27 +15,27 @@ namespace armnn RefLstmWorkload::RefLstmWorkload(const LstmQueueDescriptor &descriptor, const WorkloadInfo &info) : BaseWorkload(descriptor, info) - , m_InputToInputWeightsTensor (AssignScopedCpuTensorHandle(descriptor.m_InputToInputWeights)) - , m_InputToForgetWeightsTensor (AssignScopedCpuTensorHandle(descriptor.m_InputToForgetWeights)) - , m_InputToCellWeightsTensor (AssignScopedCpuTensorHandle(descriptor.m_InputToCellWeights)) - , m_InputToOutputWeightsTensor (AssignScopedCpuTensorHandle(descriptor.m_InputToOutputWeights)) - , m_RecurrentToInputWeightsTensor (AssignScopedCpuTensorHandle(descriptor.m_RecurrentToInputWeights)) - , m_RecurrentToForgetWeightsTensor(AssignScopedCpuTensorHandle(descriptor.m_RecurrentToForgetWeights)) - , m_RecurrentToCellWeightsTensor (AssignScopedCpuTensorHandle(descriptor.m_RecurrentToCellWeights)) - , m_RecurrentToOutputWeightsTensor(AssignScopedCpuTensorHandle(descriptor.m_RecurrentToOutputWeights)) - , m_CellToInputWeightsTensor (AssignScopedCpuTensorHandle(descriptor.m_CellToInputWeights)) - , m_CellToForgetWeightsTensor (AssignScopedCpuTensorHandle(descriptor.m_CellToForgetWeights)) - , m_CellToOutputWeightsTensor (AssignScopedCpuTensorHandle(descriptor.m_CellToOutputWeights)) - , m_InputGateBiasTensor (AssignScopedCpuTensorHandle(descriptor.m_InputGateBias)) - , m_ForgetGateBiasTensor (AssignScopedCpuTensorHandle(descriptor.m_ForgetGateBias)) - , m_CellBiasTensor (AssignScopedCpuTensorHandle(descriptor.m_CellBias)) - , m_OutputGateBiasTensor (AssignScopedCpuTensorHandle(descriptor.m_OutputGateBias)) - , m_ProjectionWeightsTensor (AssignScopedCpuTensorHandle(descriptor.m_ProjectionWeights)) - , m_ProjectionBiasTensor (AssignScopedCpuTensorHandle(descriptor.m_ProjectionBias)) - , m_InputLayerNormWeights (AssignScopedCpuTensorHandle(descriptor.m_InputLayerNormWeights)) - , m_ForgetLayerNormWeights (AssignScopedCpuTensorHandle(descriptor.m_ForgetLayerNormWeights)) - , m_CellLayerNormWeights (AssignScopedCpuTensorHandle(descriptor.m_CellLayerNormWeights)) - , m_OutputLayerNormWeights (AssignScopedCpuTensorHandle(descriptor.m_OutputLayerNormWeights)) + , m_InputToInputWeightsTensor (AssignScopedTensorHandle(descriptor.m_InputToInputWeights)) + , m_InputToForgetWeightsTensor (AssignScopedTensorHandle(descriptor.m_InputToForgetWeights)) + , m_InputToCellWeightsTensor (AssignScopedTensorHandle(descriptor.m_InputToCellWeights)) + , m_InputToOutputWeightsTensor (AssignScopedTensorHandle(descriptor.m_InputToOutputWeights)) + , m_RecurrentToInputWeightsTensor (AssignScopedTensorHandle(descriptor.m_RecurrentToInputWeights)) + , m_RecurrentToForgetWeightsTensor(AssignScopedTensorHandle(descriptor.m_RecurrentToForgetWeights)) + , m_RecurrentToCellWeightsTensor (AssignScopedTensorHandle(descriptor.m_RecurrentToCellWeights)) + , m_RecurrentToOutputWeightsTensor(AssignScopedTensorHandle(descriptor.m_RecurrentToOutputWeights)) + , m_CellToInputWeightsTensor (AssignScopedTensorHandle(descriptor.m_CellToInputWeights)) + , m_CellToForgetWeightsTensor (AssignScopedTensorHandle(descriptor.m_CellToForgetWeights)) + , m_CellToOutputWeightsTensor (AssignScopedTensorHandle(descriptor.m_CellToOutputWeights)) + , m_InputGateBiasTensor (AssignScopedTensorHandle(descriptor.m_InputGateBias)) + , m_ForgetGateBiasTensor (AssignScopedTensorHandle(descriptor.m_ForgetGateBias)) + , m_CellBiasTensor (AssignScopedTensorHandle(descriptor.m_CellBias)) + , m_OutputGateBiasTensor (AssignScopedTensorHandle(descriptor.m_OutputGateBias)) + , m_ProjectionWeightsTensor (AssignScopedTensorHandle(descriptor.m_ProjectionWeights)) + , m_ProjectionBiasTensor (AssignScopedTensorHandle(descriptor.m_ProjectionBias)) + , m_InputLayerNormWeights (AssignScopedTensorHandle(descriptor.m_InputLayerNormWeights)) + , m_ForgetLayerNormWeights (AssignScopedTensorHandle(descriptor.m_ForgetLayerNormWeights)) + , m_CellLayerNormWeights (AssignScopedTensorHandle(descriptor.m_CellLayerNormWeights)) + , m_OutputLayerNormWeights (AssignScopedTensorHandle(descriptor.m_OutputLayerNormWeights)) {} void RefLstmWorkload::Execute() const diff --git a/src/backends/reference/workloads/RefLstmWorkload.hpp b/src/backends/reference/workloads/RefLstmWorkload.hpp index b55a1f9a9e..6feffbcb00 100644 --- a/src/backends/reference/workloads/RefLstmWorkload.hpp +++ b/src/backends/reference/workloads/RefLstmWorkload.hpp @@ -23,27 +23,27 @@ public: private: void Execute(std::vector inputs, std::vector outputs) const; - std::unique_ptr m_InputToInputWeightsTensor; - std::unique_ptr m_InputToForgetWeightsTensor; - std::unique_ptr m_InputToCellWeightsTensor; - std::unique_ptr m_InputToOutputWeightsTensor; - std::unique_ptr m_RecurrentToInputWeightsTensor; - std::unique_ptr m_RecurrentToForgetWeightsTensor; - std::unique_ptr m_RecurrentToCellWeightsTensor; - std::unique_ptr m_RecurrentToOutputWeightsTensor; - std::unique_ptr m_CellToInputWeightsTensor; - std::unique_ptr m_CellToForgetWeightsTensor; - std::unique_ptr m_CellToOutputWeightsTensor; - std::unique_ptr m_InputGateBiasTensor; - std::unique_ptr m_ForgetGateBiasTensor; - std::unique_ptr m_CellBiasTensor; - std::unique_ptr m_OutputGateBiasTensor; - std::unique_ptr m_ProjectionWeightsTensor; - std::unique_ptr m_ProjectionBiasTensor; - std::unique_ptr m_InputLayerNormWeights; - std::unique_ptr m_ForgetLayerNormWeights; - std::unique_ptr m_CellLayerNormWeights; - std::unique_ptr m_OutputLayerNormWeights; + std::unique_ptr m_InputToInputWeightsTensor; + std::unique_ptr m_InputToForgetWeightsTensor; + std::unique_ptr m_InputToCellWeightsTensor; + std::unique_ptr m_InputToOutputWeightsTensor; + std::unique_ptr m_RecurrentToInputWeightsTensor; + std::unique_ptr m_RecurrentToForgetWeightsTensor; + std::unique_ptr m_RecurrentToCellWeightsTensor; + std::unique_ptr m_RecurrentToOutputWeightsTensor; + std::unique_ptr m_CellToInputWeightsTensor; + std::unique_ptr m_CellToForgetWeightsTensor; + std::unique_ptr m_CellToOutputWeightsTensor; + std::unique_ptr m_InputGateBiasTensor; + std::unique_ptr m_ForgetGateBiasTensor; + std::unique_ptr m_CellBiasTensor; + std::unique_ptr m_OutputGateBiasTensor; + std::unique_ptr m_ProjectionWeightsTensor; + std::unique_ptr m_ProjectionBiasTensor; + std::unique_ptr m_InputLayerNormWeights; + std::unique_ptr m_ForgetLayerNormWeights; + std::unique_ptr m_CellLayerNormWeights; + std::unique_ptr m_OutputLayerNormWeights; float m_LayerNormEpsilon = static_cast(1e-8); }; diff --git a/src/backends/reference/workloads/RefQLstmWorkload.cpp b/src/backends/reference/workloads/RefQLstmWorkload.cpp index 7b7961c5a0..dc29d0b92d 100644 --- a/src/backends/reference/workloads/RefQLstmWorkload.cpp +++ b/src/backends/reference/workloads/RefQLstmWorkload.cpp @@ -15,32 +15,32 @@ namespace armnn RefQLstmWorkload::RefQLstmWorkload(const QLstmQueueDescriptor &descriptor, const WorkloadInfo &info) : BaseWorkload(descriptor, info) - , m_InputToInputWeightsTensor (AssignScopedCpuTensorHandle(descriptor.m_InputToInputWeights)) - , m_InputToForgetWeightsTensor (AssignScopedCpuTensorHandle(descriptor.m_InputToForgetWeights)) - , m_InputToCellWeightsTensor (AssignScopedCpuTensorHandle(descriptor.m_InputToCellWeights)) - , m_InputToOutputWeightsTensor (AssignScopedCpuTensorHandle(descriptor.m_InputToOutputWeights)) - - , m_RecurrentToInputWeightsTensor (AssignScopedCpuTensorHandle(descriptor.m_RecurrentToInputWeights)) - , m_RecurrentToForgetWeightsTensor(AssignScopedCpuTensorHandle(descriptor.m_RecurrentToForgetWeights)) - , m_RecurrentToCellWeightsTensor (AssignScopedCpuTensorHandle(descriptor.m_RecurrentToCellWeights)) - , m_RecurrentToOutputWeightsTensor(AssignScopedCpuTensorHandle(descriptor.m_RecurrentToOutputWeights)) - - , m_CellToInputWeightsTensor (AssignScopedCpuTensorHandle(descriptor.m_CellToInputWeights)) - , m_CellToForgetWeightsTensor (AssignScopedCpuTensorHandle(descriptor.m_CellToForgetWeights)) - , m_CellToOutputWeightsTensor (AssignScopedCpuTensorHandle(descriptor.m_CellToOutputWeights)) - - , m_InputGateBiasTensor (AssignScopedCpuTensorHandle(descriptor.m_InputGateBias)) - , m_ForgetGateBiasTensor (AssignScopedCpuTensorHandle(descriptor.m_ForgetGateBias)) - , m_CellBiasTensor (AssignScopedCpuTensorHandle(descriptor.m_CellBias)) - , m_OutputGateBiasTensor (AssignScopedCpuTensorHandle(descriptor.m_OutputGateBias)) - - , m_ProjectionWeightsTensor (AssignScopedCpuTensorHandle(descriptor.m_ProjectionWeights)) - , m_ProjectionBiasTensor (AssignScopedCpuTensorHandle(descriptor.m_ProjectionBias)) - - , m_InputLayerNormWeightsTensor (AssignScopedCpuTensorHandle(descriptor.m_InputLayerNormWeights)) - , m_ForgetLayerNormWeightsTensor (AssignScopedCpuTensorHandle(descriptor.m_ForgetLayerNormWeights)) - , m_CellLayerNormWeightsTensor (AssignScopedCpuTensorHandle(descriptor.m_CellLayerNormWeights)) - , m_OutputLayerNormWeightsTensor (AssignScopedCpuTensorHandle(descriptor.m_OutputLayerNormWeights)) + , m_InputToInputWeightsTensor (AssignScopedTensorHandle(descriptor.m_InputToInputWeights)) + , m_InputToForgetWeightsTensor (AssignScopedTensorHandle(descriptor.m_InputToForgetWeights)) + , m_InputToCellWeightsTensor (AssignScopedTensorHandle(descriptor.m_InputToCellWeights)) + , m_InputToOutputWeightsTensor (AssignScopedTensorHandle(descriptor.m_InputToOutputWeights)) + + , m_RecurrentToInputWeightsTensor (AssignScopedTensorHandle(descriptor.m_RecurrentToInputWeights)) + , m_RecurrentToForgetWeightsTensor(AssignScopedTensorHandle(descriptor.m_RecurrentToForgetWeights)) + , m_RecurrentToCellWeightsTensor (AssignScopedTensorHandle(descriptor.m_RecurrentToCellWeights)) + , m_RecurrentToOutputWeightsTensor(AssignScopedTensorHandle(descriptor.m_RecurrentToOutputWeights)) + + , m_CellToInputWeightsTensor (AssignScopedTensorHandle(descriptor.m_CellToInputWeights)) + , m_CellToForgetWeightsTensor (AssignScopedTensorHandle(descriptor.m_CellToForgetWeights)) + , m_CellToOutputWeightsTensor (AssignScopedTensorHandle(descriptor.m_CellToOutputWeights)) + + , m_InputGateBiasTensor (AssignScopedTensorHandle(descriptor.m_InputGateBias)) + , m_ForgetGateBiasTensor (AssignScopedTensorHandle(descriptor.m_ForgetGateBias)) + , m_CellBiasTensor (AssignScopedTensorHandle(descriptor.m_CellBias)) + , m_OutputGateBiasTensor (AssignScopedTensorHandle(descriptor.m_OutputGateBias)) + + , m_ProjectionWeightsTensor (AssignScopedTensorHandle(descriptor.m_ProjectionWeights)) + , m_ProjectionBiasTensor (AssignScopedTensorHandle(descriptor.m_ProjectionBias)) + + , m_InputLayerNormWeightsTensor (AssignScopedTensorHandle(descriptor.m_InputLayerNormWeights)) + , m_ForgetLayerNormWeightsTensor (AssignScopedTensorHandle(descriptor.m_ForgetLayerNormWeights)) + , m_CellLayerNormWeightsTensor (AssignScopedTensorHandle(descriptor.m_CellLayerNormWeights)) + , m_OutputLayerNormWeightsTensor (AssignScopedTensorHandle(descriptor.m_OutputLayerNormWeights)) {} void RefQLstmWorkload::Execute() const diff --git a/src/backends/reference/workloads/RefQLstmWorkload.hpp b/src/backends/reference/workloads/RefQLstmWorkload.hpp index f4242ec8a4..0aa7e10bbf 100644 --- a/src/backends/reference/workloads/RefQLstmWorkload.hpp +++ b/src/backends/reference/workloads/RefQLstmWorkload.hpp @@ -23,32 +23,32 @@ public: private: void Execute(std::vector inputs, std::vector outputs) const; - std::unique_ptr m_InputToInputWeightsTensor; - std::unique_ptr m_InputToForgetWeightsTensor; - std::unique_ptr m_InputToCellWeightsTensor; - std::unique_ptr m_InputToOutputWeightsTensor; - - std::unique_ptr m_RecurrentToInputWeightsTensor; - std::unique_ptr m_RecurrentToForgetWeightsTensor; - std::unique_ptr m_RecurrentToCellWeightsTensor; - std::unique_ptr m_RecurrentToOutputWeightsTensor; - - std::unique_ptr m_CellToInputWeightsTensor; - std::unique_ptr m_CellToForgetWeightsTensor; - std::unique_ptr m_CellToOutputWeightsTensor; - - std::unique_ptr m_InputGateBiasTensor; - std::unique_ptr m_ForgetGateBiasTensor; - std::unique_ptr m_CellBiasTensor; - std::unique_ptr m_OutputGateBiasTensor; - - std::unique_ptr m_ProjectionWeightsTensor; - std::unique_ptr m_ProjectionBiasTensor; - - std::unique_ptr m_InputLayerNormWeightsTensor; - std::unique_ptr m_ForgetLayerNormWeightsTensor; - std::unique_ptr m_CellLayerNormWeightsTensor; - std::unique_ptr m_OutputLayerNormWeightsTensor; + std::unique_ptr m_InputToInputWeightsTensor; + std::unique_ptr m_InputToForgetWeightsTensor; + std::unique_ptr m_InputToCellWeightsTensor; + std::unique_ptr m_InputToOutputWeightsTensor; + + std::unique_ptr m_RecurrentToInputWeightsTensor; + std::unique_ptr m_RecurrentToForgetWeightsTensor; + std::unique_ptr m_RecurrentToCellWeightsTensor; + std::unique_ptr m_RecurrentToOutputWeightsTensor; + + std::unique_ptr m_CellToInputWeightsTensor; + std::unique_ptr m_CellToForgetWeightsTensor; + std::unique_ptr m_CellToOutputWeightsTensor; + + std::unique_ptr m_InputGateBiasTensor; + std::unique_ptr m_ForgetGateBiasTensor; + std::unique_ptr m_CellBiasTensor; + std::unique_ptr m_OutputGateBiasTensor; + + std::unique_ptr m_ProjectionWeightsTensor; + std::unique_ptr m_ProjectionBiasTensor; + + std::unique_ptr m_InputLayerNormWeightsTensor; + std::unique_ptr m_ForgetLayerNormWeightsTensor; + std::unique_ptr m_CellLayerNormWeightsTensor; + std::unique_ptr m_OutputLayerNormWeightsTensor; float m_LayerNormEpsilon = static_cast(1e-8); }; diff --git a/src/backends/reference/workloads/RefTransposeConvolution2dWorkload.cpp b/src/backends/reference/workloads/RefTransposeConvolution2dWorkload.cpp index 634122835f..8665648fe6 100644 --- a/src/backends/reference/workloads/RefTransposeConvolution2dWorkload.cpp +++ b/src/backends/reference/workloads/RefTransposeConvolution2dWorkload.cpp @@ -18,7 +18,7 @@ RefTransposeConvolution2dWorkload::RefTransposeConvolution2dWorkload( BaseWorkload(descriptor, info) { // set up weights decoder - m_Weights = std::make_unique(*(descriptor.m_Weight)); + m_Weights = std::make_unique(*(descriptor.m_Weight)); const TensorInfo& weightsInfo = m_Weights->GetTensorInfo(); m_WeightsDecoder = MakeDecoder(weightsInfo, m_Weights->Map(true)); @@ -27,7 +27,7 @@ RefTransposeConvolution2dWorkload::RefTransposeConvolution2dWorkload( // set up biases decoder if (descriptor.m_Parameters.m_BiasEnabled) { - m_Biases = std::make_unique(*(descriptor.m_Bias)); + m_Biases = std::make_unique(*(descriptor.m_Bias)); const TensorInfo& biasesInfo = m_Biases->GetTensorInfo(); m_BiasesDecoder = MakeDecoder(biasesInfo, m_Biases->Map(true)); } diff --git a/src/backends/reference/workloads/RefTransposeConvolution2dWorkload.hpp b/src/backends/reference/workloads/RefTransposeConvolution2dWorkload.hpp index 7c18f10293..997ccbfe12 100644 --- a/src/backends/reference/workloads/RefTransposeConvolution2dWorkload.hpp +++ b/src/backends/reference/workloads/RefTransposeConvolution2dWorkload.hpp @@ -8,7 +8,7 @@ #include "Decoders.hpp" #include "Encoders.hpp" -#include +#include #include namespace armnn @@ -26,8 +26,8 @@ public: private: void Execute(std::vector inputs, std::vector outputs) const; - std::unique_ptr m_Weights; - std::unique_ptr m_Biases; + std::unique_ptr m_Weights; + std::unique_ptr m_Biases; std::unique_ptr> m_WeightsDecoder; std::unique_ptr> m_BiasesDecoder; diff --git a/src/backends/reference/workloads/RefWorkloadUtils.hpp b/src/backends/reference/workloads/RefWorkloadUtils.hpp index 0d839afc1c..3659617b7f 100644 --- a/src/backends/reference/workloads/RefWorkloadUtils.hpp +++ b/src/backends/reference/workloads/RefWorkloadUtils.hpp @@ -5,7 +5,7 @@ #pragma once -#include +#include #include #include diff --git a/src/dynamic/sample/SampleDynamicWorkloadFactory.cpp b/src/dynamic/sample/SampleDynamicWorkloadFactory.cpp index ac324946d2..227190cb1b 100644 --- a/src/dynamic/sample/SampleDynamicWorkloadFactory.cpp +++ b/src/dynamic/sample/SampleDynamicWorkloadFactory.cpp @@ -3,8 +3,8 @@ // SPDX-License-Identifier: MIT // -#include #include +#include #include "SampleDynamicAdditionWorkload.hpp" #include "SampleDynamicBackend.hpp" @@ -45,7 +45,7 @@ std::unique_ptr SampleDynamicWorkloadFactory::CreateTensor const armnn::TensorInfo& tensorInfo, const bool isMemoryManaged) const { - return std::make_unique(tensorInfo); + return std::make_unique(tensorInfo); } std::unique_ptr SampleDynamicWorkloadFactory::CreateTensorHandle( @@ -53,7 +53,7 @@ std::unique_ptr SampleDynamicWorkloadFactory::CreateTensor armnn::DataLayout dataLayout, const bool isMemoryManaged) const { - return std::make_unique(tensorInfo); + return std::make_unique(tensorInfo); } std::unique_ptr SampleDynamicWorkloadFactory::CreateAddition( diff --git a/src/dynamic/sample/SampleTensorHandle.hpp b/src/dynamic/sample/SampleTensorHandle.hpp index 9ddccedce2..dce98cfc0b 100644 --- a/src/dynamic/sample/SampleTensorHandle.hpp +++ b/src/dynamic/sample/SampleTensorHandle.hpp @@ -4,7 +4,7 @@ // #pragma once -#include +#include #include "SampleMemoryManager.hpp" -- cgit v1.2.1