├── .clang-format ├── .clang-format.license ├── AUTHORS-TensorFlow ├── AUTHORS-TensorFlow.license ├── Android.bp ├── Android.mk ├── Arm_NN_horizontal_blue.png ├── Arm_NN_horizontal_blue.png.license ├── BuildGuideAndroidNDK.md ├── BuildGuideAndroidNDK.md.license ├── CMakeLists.txt ├── CONTRIBUTING.md ├── CONTRIBUTING.md.license ├── InstallationViaAptRepository.md ├── InstallationViaAptRepository.md.license ├── LICENSE ├── LICENSE.spdx ├── LICENSES ├── Apache-2.0.txt ├── BSD-3-Clause.txt └── MIT.txt ├── README.md ├── README.md.license ├── SECURITY.md ├── SECURITY.md.license ├── build-tool ├── README.md ├── README.md.license ├── docker │ └── Dockerfile ├── dockerfile_armnn.png ├── dockerfile_armnn.png.license └── scripts │ ├── build-armnn.sh │ ├── common.sh │ ├── docker-copy-to-host.sh │ ├── install-packages.sh │ ├── setup-armnn.sh │ └── validation.sh ├── cmake ├── AddDllCopyCommands.cmake ├── ArmnnConfig.cmake.in ├── ArmnnTestUtilsVersion.cmake ├── ArmnnVersion.cmake ├── ClassicDelegateVersion.cmake ├── GlobalConfig.cmake ├── OpaqueDelegateVersion.cmake ├── ParserVersion.cmake └── Utils.cmake ├── delegate ├── BuildGuideNative.md ├── BuildGuideNative.md.license ├── CMakeLists.txt ├── DelegateQuickStartGuide.md ├── DelegateQuickStartGuide.md.license ├── README.md ├── README.md.license ├── armnnDelegateJNI │ ├── CMakeLists.txt │ ├── README.md │ ├── README.md.license │ ├── src │ │ └── armnn_delegate_jni.cpp │ └── version_script ├── classic │ ├── CMakeLists.txt │ ├── include │ │ ├── Version.hpp │ │ └── armnn_delegate.hpp │ └── src │ │ ├── Activation.hpp │ │ ├── ArgMinMax.hpp │ │ ├── BatchMatMul.hpp │ │ ├── BatchSpace.hpp │ │ ├── BroadcastTo.hpp │ │ ├── ClassicDelegateUtils.hpp │ │ ├── Comparison.hpp │ │ ├── Control.hpp │ │ ├── Convolution.hpp │ │ ├── ElementwiseBinary.hpp │ │ ├── ElementwiseUnary.hpp │ │ ├── Fill.hpp │ │ ├── FullyConnected.hpp │ │ ├── Gather.hpp │ │ ├── GatherNd.hpp │ │ ├── LogicalBinary.hpp │ │ ├── Lstm.hpp │ │ ├── Normalization.hpp │ │ ├── Pack.hpp │ │ ├── Pad.hpp │ │ ├── Pooling.hpp │ │ ├── Prelu.hpp │ │ ├── Quantization.hpp │ │ ├── Redefine.hpp │ │ ├── Reduce.hpp │ │ ├── Resize.hpp │ │ ├── ReverseV2.hpp │ │ ├── Round.hpp │ │ ├── ScatterNd.hpp │ │ ├── Shape.hpp │ │ ├── SharedFunctions.cpp │ │ ├── SharedFunctions.hpp │ │ ├── Slice.hpp │ │ ├── Softmax.hpp │ │ ├── SpaceDepth.hpp │ │ ├── Split.hpp │ │ ├── StridedSlice.hpp │ │ ├── Tile.hpp │ │ ├── Transpose.hpp │ │ ├── UnidirectionalSequenceLstm.hpp │ │ ├── Unpack.hpp │ │ ├── armnn_delegate.cpp │ │ ├── armnn_external_delegate.cpp │ │ └── test │ │ ├── ArmnnClassicDelegateTest.cpp │ │ └── DelegateTestInterpreter.cpp ├── cmake │ └── Modules │ │ ├── ArmnnDelegateConfig.cmake.in │ │ ├── FindFlatbuffers.cmake │ │ ├── FindTfLite.cmake │ │ ├── FindTfLiteAbsl.cmake │ │ └── FindTfLiteSrc.cmake ├── common │ ├── include │ │ └── DelegateOptions.hpp │ └── src │ │ ├── DelegateOptions.cpp │ │ ├── DelegateUtils.hpp │ │ ├── MultiLayerFacade.hpp │ │ └── test │ │ ├── DelegateTestInterpreter.hpp │ │ ├── DelegateTestInterpreterUtils.hpp │ │ └── DelegateUtilsTest.cpp ├── include │ ├── DelegateOptions.hpp │ ├── Version.hpp │ └── armnn_delegate.hpp ├── opaque │ ├── CMakeLists.txt │ ├── include │ │ ├── Version.hpp │ │ └── armnn_delegate.hpp │ └── src │ │ ├── Activation.hpp │ │ ├── ArgMinMax.hpp │ │ ├── BatchMatMul.hpp │ │ ├── BatchSpace.hpp │ │ ├── BroadcastTo.hpp │ │ ├── Comparison.hpp │ │ ├── Control.hpp │ │ ├── Convolution.hpp │ │ ├── ElementwiseBinary.hpp │ │ ├── ElementwiseUnary.hpp │ │ ├── Fill.hpp │ │ ├── FullyConnected.hpp │ │ ├── Gather.hpp │ │ ├── GatherNd.hpp │ │ ├── LogicalBinary.hpp │ │ ├── Lstm.hpp │ │ ├── Normalization.hpp │ │ ├── OpaqueDelegateUtils.hpp │ │ ├── Pack.hpp │ │ ├── Pad.hpp │ │ ├── Pooling.hpp │ │ ├── Prelu.hpp │ │ ├── Quantization.hpp │ │ ├── Redefine.hpp │ │ ├── Reduce.hpp │ │ ├── Resize.hpp │ │ ├── ReverseV2.hpp │ │ ├── Round.hpp │ │ ├── ScatterNd.hpp │ │ ├── Shape.hpp │ │ ├── SharedFunctions.cpp │ │ ├── SharedFunctions.hpp │ │ ├── Slice.hpp │ │ ├── Softmax.hpp │ │ ├── SpaceDepth.hpp │ │ ├── Split.hpp │ │ ├── StridedSlice.hpp │ │ ├── Tile.hpp │ │ ├── Transpose.hpp │ │ ├── UnidirectionalSequenceLstm.hpp │ │ ├── Unpack.hpp │ │ ├── armnn_delegate.cpp │ │ ├── armnn_external_delegate.cpp │ │ └── test │ │ ├── ArmnnOpaqueDelegateTest.cpp │ │ └── DelegateTestInterpreter.cpp ├── python │ └── test │ │ ├── conftest.py │ │ ├── pytest.ini │ │ ├── test_data │ │ ├── conv2d.tflite │ │ ├── conv2d.tflite.license │ │ ├── fallback_model.tflite │ │ ├── fallback_model.tflite.license │ │ ├── fp32_model.tflite │ │ ├── fp32_model.tflite.license │ │ ├── mock_model.tflite │ │ └── mock_model.tflite.license │ │ ├── test_external_delegate.py │ │ └── utils.py └── test │ ├── ActivationTest.cpp │ ├── ActivationTestHelper.hpp │ ├── ArgMinMaxTest.cpp │ ├── ArgMinMaxTestHelper.hpp │ ├── BatchMatMulTest.cpp │ ├── BatchMatMulTestHelper.hpp │ ├── BatchSpaceTest.cpp │ ├── BatchSpaceTestHelper.hpp │ ├── BroadcastToTest.cpp │ ├── BroadcastToTestHelper.hpp │ ├── CastTest.cpp │ ├── CastTestHelper.hpp │ ├── ComparisonTest.cpp │ ├── ComparisonTestHelper.hpp │ ├── ControlTest.cpp │ ├── ControlTestHelper.hpp │ ├── Convolution2dTest.cpp │ ├── Convolution3dTest.cpp │ ├── ConvolutionTestHelper.hpp │ ├── DelegateOptionsTest.cpp │ ├── DelegateOptionsTestHelper.hpp │ ├── DepthwiseConvolution2dTest.cpp │ ├── ElementwiseBinaryTest.cpp │ ├── ElementwiseBinaryTestHelper.hpp │ ├── ElementwiseUnaryTest.cpp │ ├── ElementwiseUnaryTestHelper.hpp │ ├── ExpandDimsTest.cpp │ ├── FillTest.cpp │ ├── FillTestHelper.hpp │ ├── FullyConnectedTest.cpp │ ├── FullyConnectedTestHelper.hpp │ ├── GatherNdTest.cpp │ ├── GatherNdTestHelper.hpp │ ├── GatherTest.cpp │ ├── GatherTestHelper.hpp │ ├── LogicalTest.cpp │ ├── LogicalTestHelper.hpp │ ├── LstmTest.cpp │ ├── LstmTestHelper.hpp │ ├── MirrorPadTest.cpp │ ├── NeonDelegateTests_NDK_Issue.cpp │ ├── NormalizationTest.cpp │ ├── NormalizationTestHelper.hpp │ ├── PackTest.cpp │ ├── PackTestHelper.hpp │ ├── PadTest.cpp │ ├── PadTestHelper.hpp │ ├── Pooling2dTest.cpp │ ├── Pooling2dTestHelper.hpp │ ├── Pooling3dTest.cpp │ ├── Pooling3dTestHelper.hpp │ ├── PreluTest.cpp │ ├── PreluTestHelper.hpp │ ├── QuantizationTest.cpp │ ├── QuantizationTestHelper.hpp │ ├── RedefineTestHelper.hpp │ ├── ReduceTest.cpp │ ├── ReduceTestHelper.hpp │ ├── ReshapeTest.cpp │ ├── ResizeTest.cpp │ ├── ResizeTestHelper.hpp │ ├── ReverseV2Test.cpp │ ├── ReverseV2TestHelper.hpp │ ├── RoundTest.cpp │ ├── RoundTestHelper.hpp │ ├── ScatterNdTest.cpp │ ├── ScatterNdTestHelper.hpp │ ├── ShapeTest.cpp │ ├── ShapeTestHelper.hpp │ ├── SliceTest.cpp │ ├── SliceTestHelper.hpp │ ├── SoftmaxTest.cpp │ ├── SoftmaxTestHelper.hpp │ ├── SpaceDepthTest.cpp │ ├── SpaceDepthTestHelper.hpp │ ├── SplitTest.cpp │ ├── SplitTestHelper.hpp │ ├── SqueezeTest.cpp │ ├── StridedSliceTest.cpp │ ├── StridedSliceTestHelper.hpp │ ├── TestUtils.cpp │ ├── TestUtils.hpp │ ├── TileTest.cpp │ ├── TileTestHelper.hpp │ ├── TransposeConvolution2dTest.cpp │ ├── TransposeTest.cpp │ ├── TransposeTestHelper.hpp │ ├── UnidirectionalSequenceLstmTest.cpp │ ├── UnidirectionalSequenceLstmTestHelper.hpp │ ├── UnpackTest.cpp │ └── UnpackTestHelper.hpp ├── docker ├── README.md └── README.md.license ├── docs ├── 01_00_quick_start.dox ├── 02_operator_list.dox ├── 03_build_guides.dox ├── 04_contributor.dox ├── 05_00_software_components.dox ├── 05_01_parsers.dox ├── 05_02_serializer.dox ├── 05_03_delegate.dox ├── 05_04_runtimeoptions.dox ├── 05_05_deserializer.dox ├── Arm_NN_horizontal_blue.png ├── Arm_NN_horizontal_blue.png.license ├── Doxyfile ├── FAQ.md ├── FAQ.md.license ├── customdoxygen.css ├── design │ ├── EthosN_NPU-GPU_ZeroCopyFallbackDesignDocument.pdf │ ├── EthosN_NPU-GPU_ZeroCopyFallbackDesignDocument.pdf.license │ ├── README.md │ └── README.md.license └── header.html ├── include ├── armnn │ ├── ArmNN.hpp │ ├── BackendHelper.hpp │ ├── BackendId.hpp │ ├── BackendOptions.hpp │ ├── BackendRegistry.hpp │ ├── Conversion.hpp │ ├── Deprecated.hpp │ ├── Descriptors.hpp │ ├── DescriptorsFwd.hpp │ ├── Exceptions.hpp │ ├── INetwork.hpp │ ├── IProfiler.hpp │ ├── IRuntime.hpp │ ├── IStrategy.hpp │ ├── Logging.hpp │ ├── LstmParams.hpp │ ├── MemorySources.hpp │ ├── NetworkFwd.hpp │ ├── Numpy.hpp │ ├── Optional.hpp │ ├── QuantizedLstmParams.hpp │ ├── StrategyBase.hpp │ ├── Tensor.hpp │ ├── TensorFwd.hpp │ ├── Types.hpp │ ├── TypesUtils.hpp │ ├── Utils.hpp │ ├── Version.hpp │ ├── backends │ │ ├── CMakeLists.txt │ │ ├── DynamicBackend.hpp │ │ ├── IBackendContext.hpp │ │ ├── IBackendInternal.hpp │ │ ├── ICustomAllocator.hpp │ │ ├── ILayerSupport.hpp │ │ ├── IMemoryManager.hpp │ │ ├── IMemoryOptimizerStrategy.hpp │ │ ├── ITensorHandle.hpp │ │ ├── ITensorHandleFactory.hpp │ │ ├── IWorkload.hpp │ │ ├── MemCopyWorkload.hpp │ │ ├── OptimizationViews.hpp │ │ ├── SubgraphView.hpp │ │ ├── TensorHandle.hpp │ │ ├── TensorHandleFwd.hpp │ │ ├── Workload.hpp │ │ ├── WorkloadData.hpp │ │ ├── WorkloadFactory.hpp │ │ └── WorkloadInfo.hpp │ ├── profiling │ │ └── ArmNNProfiling.hpp │ └── utility │ │ ├── Assert.hpp │ │ ├── IgnoreUnused.hpp │ │ ├── NumericCast.hpp │ │ ├── PolymorphicDowncast.hpp │ │ ├── StringUtils.hpp │ │ ├── Timer.hpp │ │ └── TransformIterator.hpp ├── armnnDeserializer │ └── IDeserializer.hpp ├── armnnOnnxParser │ ├── IOnnxParser.hpp │ └── Version.hpp ├── armnnSerializer │ └── ISerializer.hpp ├── armnnTestUtils │ ├── DataLayoutUtils.hpp │ ├── LayerTestResult.hpp │ ├── MemCopyTestImpl.hpp │ ├── MockBackend.hpp │ ├── MockMemoryManager.hpp │ ├── MockTensorHandle.hpp │ ├── PredicateResult.hpp │ ├── TensorCopyUtils.hpp │ ├── TensorHelpers.hpp │ ├── Version.hpp │ └── WorkloadTestUtils.hpp ├── armnnTfLiteParser │ ├── ITfLiteParser.hpp │ └── Version.hpp └── armnnUtils │ ├── CompatibleTypes.hpp │ ├── DataLayoutIndexed.hpp │ ├── Filesystem.hpp │ ├── FloatingPointComparison.hpp │ ├── FloatingPointConverter.hpp │ ├── Permute.hpp │ ├── QuantizeHelper.hpp │ ├── TContainer.hpp │ ├── TensorUtils.hpp │ └── Transpose.hpp ├── profiling ├── CMakeLists.txt ├── buildpipe.sh ├── client │ ├── include │ │ ├── CounterIdMap.hpp │ │ ├── CounterStatus.hpp │ │ ├── CounterValue.hpp │ │ ├── Holder.hpp │ │ ├── ICounterValues.hpp │ │ ├── IInitialiseProfilingService.hpp │ │ ├── ILocalPacketHandler.hpp │ │ ├── IProfilingService.hpp │ │ ├── IProfilingServiceStatus.hpp │ │ ├── IReportStructure.hpp │ │ ├── ISendCounterPacket.hpp │ │ ├── ISendTimelinePacket.hpp │ │ ├── ProfilingOptions.hpp │ │ ├── ProfilingState.hpp │ │ ├── TimelineUtilityMethods.hpp │ │ ├── Timestamp.hpp │ │ └── backends │ │ │ ├── IBackendProfiling.hpp │ │ │ └── IBackendProfilingContext.hpp │ └── src │ │ ├── ActivateTimelineReportingCommandHandler.cpp │ │ ├── ActivateTimelineReportingCommandHandler.hpp │ │ ├── BufferManager.cpp │ │ ├── BufferManager.hpp │ │ ├── CMakeLists.txt │ │ ├── CommandHandler.cpp │ │ ├── CommandHandler.hpp │ │ ├── ConnectionAcknowledgedCommandHandler.cpp │ │ ├── ConnectionAcknowledgedCommandHandler.hpp │ │ ├── CounterIdMap.cpp │ │ ├── DeactivateTimelineReportingCommandHandler.cpp │ │ ├── DeactivateTimelineReportingCommandHandler.hpp │ │ ├── FileOnlyProfilingConnection.cpp │ │ ├── FileOnlyProfilingConnection.hpp │ │ ├── Holder.cpp │ │ ├── IBufferManager.hpp │ │ ├── IConsumer.hpp │ │ ├── INotifyBackends.hpp │ │ ├── IPacketBuffer.hpp │ │ ├── IPeriodicCounterCapture.hpp │ │ ├── IProfilingConnection.hpp │ │ ├── IProfilingConnectionFactory.hpp │ │ ├── IProfilingService.cpp │ │ ├── ISendThread.hpp │ │ ├── NullProfilingConnection.hpp │ │ ├── PacketBuffer.cpp │ │ ├── PacketBuffer.hpp │ │ ├── PerJobCounterSelectionCommandHandler.cpp │ │ ├── PerJobCounterSelectionCommandHandler.hpp │ │ ├── PeriodicCounterCapture.cpp │ │ ├── PeriodicCounterCapture.hpp │ │ ├── PeriodicCounterSelectionCommandHandler.cpp │ │ ├── PeriodicCounterSelectionCommandHandler.hpp │ │ ├── ProfilingConnectionDumpToFileDecorator.cpp │ │ ├── ProfilingConnectionDumpToFileDecorator.hpp │ │ ├── ProfilingConnectionFactory.cpp │ │ ├── ProfilingConnectionFactory.hpp │ │ ├── ProfilingService.cpp │ │ ├── ProfilingService.hpp │ │ ├── ProfilingStateMachine.cpp │ │ ├── ProfilingStateMachine.hpp │ │ ├── ProfilingUtils.cpp │ │ ├── ProfilingUtils.hpp │ │ ├── RegisterBackendCounters.cpp │ │ ├── RegisterBackendCounters.hpp │ │ ├── RequestCounterDirectoryCommandHandler.cpp │ │ ├── RequestCounterDirectoryCommandHandler.hpp │ │ ├── SendCounterPacket.cpp │ │ ├── SendCounterPacket.hpp │ │ ├── SendThread.cpp │ │ ├── SendThread.hpp │ │ ├── SendTimelinePacket.cpp │ │ ├── SendTimelinePacket.hpp │ │ ├── SocketProfilingConnection.cpp │ │ ├── SocketProfilingConnection.hpp │ │ ├── TimelinePacketWriterFactory.cpp │ │ ├── TimelinePacketWriterFactory.hpp │ │ ├── TimelineUtilityMethods.cpp │ │ └── backends │ │ ├── BackendProfiling.cpp │ │ ├── BackendProfiling.hpp │ │ └── IBackendProfiling.cpp ├── common │ ├── include │ │ ├── Assert.hpp │ │ ├── CommandHandlerFunctor.hpp │ │ ├── CommandHandlerKey.hpp │ │ ├── CommandHandlerRegistry.hpp │ │ ├── CommonProfilingUtils.hpp │ │ ├── Constants.hpp │ │ ├── Conversion.hpp │ │ ├── Counter.hpp │ │ ├── CounterDirectory.hpp │ │ ├── DllExport.hpp │ │ ├── EncodeVersion.hpp │ │ ├── ICounterDirectory.hpp │ │ ├── ICounterRegistry.hpp │ │ ├── IProfilingGuidGenerator.hpp │ │ ├── IgnoreUnused.hpp │ │ ├── LabelsAndEventClasses.hpp │ │ ├── Logging.hpp │ │ ├── NetworkSockets.hpp │ │ ├── NumericCast.hpp │ │ ├── Optional.hpp │ │ ├── Packet.hpp │ │ ├── PacketVersionResolver.hpp │ │ ├── Processes.hpp │ │ ├── ProfilingException.hpp │ │ ├── ProfilingGuid.hpp │ │ ├── ProfilingGuidGenerator.hpp │ │ ├── SocketConnectionException.hpp │ │ ├── SwTrace.hpp │ │ ├── TargetEndianess.hpp │ │ ├── Threads.hpp │ │ └── WindowsWrapper.hpp │ └── src │ │ ├── CMakeLists.txt │ │ ├── CommandHandlerFunctor.cpp │ │ ├── CommandHandlerKey.cpp │ │ ├── CommandHandlerRegistry.cpp │ │ ├── CommonProfilingUtils.cpp │ │ ├── CounterDirectory.cpp │ │ ├── LabelsAndEventClasses.cpp │ │ ├── Logging.cpp │ │ ├── NetworkSockets.cpp │ │ ├── PacketVersionResolver.cpp │ │ ├── Processes.cpp │ │ ├── SwTrace.cpp │ │ └── Threads.cpp ├── server │ ├── include │ │ ├── basePipeServer │ │ │ ├── BasePipeServer.hpp │ │ │ └── ConnectionHandler.hpp │ │ └── timelineDecoder │ │ │ ├── DirectoryCaptureCommandHandler.hpp │ │ │ ├── ITimelineDecoder.hpp │ │ │ ├── TimelineCaptureCommandHandler.hpp │ │ │ ├── TimelineDecoder.hpp │ │ │ └── TimelineDirectoryCaptureCommandHandler.hpp │ └── src │ │ ├── basePipeServer │ │ ├── BasePipeServer.cpp │ │ ├── CMakeLists.txt │ │ ├── ConnectionHandler.cpp │ │ └── tests │ │ │ └── BasePipeServerTests.cpp │ │ └── timelineDecoder │ │ ├── CMakeLists.txt │ │ ├── DirectoryCaptureCommandHandler.cpp │ │ ├── TimelineCaptureCommandHandler.cpp │ │ ├── TimelineDecoder.cpp │ │ ├── TimelineDirectoryCaptureCommandHandler.cpp │ │ └── tests │ │ └── TimelineTests.cpp └── toolchain-x86-ubuntu-mingw64.cmake ├── samples ├── BareMetalDeserializedGraph.cpp ├── CMakeLists.txt ├── CustomMemoryAllocatorSample.cpp ├── DynamicSample.cpp ├── KeywordSpotting │ ├── CMakeLists.txt │ ├── Readme.md │ ├── Readme.md.license │ ├── cmake │ │ └── unit_tests.cmake │ ├── include │ │ ├── Decoder.hpp │ │ ├── DsCNNPreprocessor.hpp │ │ ├── DsCnnMfcc.hpp │ │ └── KeywordSpottingPipeline.hpp │ ├── src │ │ ├── Decoder.cpp │ │ ├── DsCNNPreprocessor.cpp │ │ ├── KeywordSpottingPipeline.cpp │ │ └── Main.cpp │ └── test │ │ ├── DecoderTest.cpp │ │ └── KeywordSpottingPipelineTest.cpp ├── ObjectDetection │ ├── CMakeLists.txt │ ├── Readme.md │ ├── Readme.md.license │ ├── cmake │ │ └── unit_tests.cmake │ ├── include │ │ ├── BoundingBox.hpp │ │ ├── DetectedObject.hpp │ │ ├── IDetectionResultDecoder.hpp │ │ ├── ImageUtils.hpp │ │ ├── NonMaxSuppression.hpp │ │ ├── ObjectDetectionPipeline.hpp │ │ ├── SSDResultDecoder.hpp │ │ ├── YoloResultDecoder.hpp │ │ └── delegate │ │ │ └── ArmnnNetworkExecutor.hpp │ ├── src │ │ ├── BoundingBox.cpp │ │ ├── DetectedObject.cpp │ │ ├── ImageUtils.cpp │ │ ├── Main.cpp │ │ ├── NonMaxSuppression.cpp │ │ ├── ObjectDetectionPipeline.cpp │ │ ├── SSDResultDecoder.cpp │ │ └── YoloResultDecoder.cpp │ └── test │ │ ├── BoundingBoxTests.cpp │ │ ├── FrameReaderTest.cpp │ │ ├── ImageUtilsTest.cpp │ │ ├── NMSTests.cpp │ │ ├── PipelineTest.cpp │ │ └── delegate │ │ └── ArmnnDelegateNetworkExecutorTest.cpp ├── SimpleSample.cpp ├── SpeechRecognition │ ├── CMakeLists.txt │ ├── Readme.md │ ├── Readme.md.license │ ├── cmake │ │ └── unit_tests.cmake │ ├── include │ │ ├── Decoder.hpp │ │ ├── SpeechRecognitionPipeline.hpp │ │ ├── Wav2LetterMFCC.hpp │ │ └── Wav2LetterPreprocessor.hpp │ ├── src │ │ ├── Decoder.cpp │ │ ├── Main.cpp │ │ ├── SpeechRecognitionPipeline.cpp │ │ ├── Wav2LetterMFCC.cpp │ │ └── Wav2LetterPreprocessor.cpp │ └── test │ │ ├── DecoderTest.cpp │ │ ├── MFCCTest.cpp │ │ └── PreprocessTest.cpp ├── common │ ├── cmake │ │ ├── aarch64-toolchain.cmake │ │ ├── arm-linux-gnueabihf-toolchain.cmake │ │ ├── find_armnn.cmake │ │ ├── find_catch.cmake │ │ └── find_opencv.cmake │ ├── include │ │ ├── ArmnnUtils │ │ │ └── ArmnnNetworkExecutor.hpp │ │ ├── Audio │ │ │ ├── AudioCapture.hpp │ │ │ ├── DataStructures.hpp │ │ │ ├── MFCC.hpp │ │ │ ├── MathUtils.hpp │ │ │ └── SlidingWindow.hpp │ │ ├── CVUtils │ │ │ ├── CvVideoFileWriter.hpp │ │ │ ├── CvVideoFrameReader.hpp │ │ │ ├── CvWindowOutput.hpp │ │ │ ├── IFrameOutput.hpp │ │ │ └── IFrameReader.hpp │ │ └── Utils │ │ │ ├── CmdArgsParser.hpp │ │ │ ├── Profiling.hpp │ │ │ └── Types.hpp │ ├── src │ │ ├── Audio │ │ │ ├── AudioCapture.cpp │ │ │ ├── MFCC.cpp │ │ │ └── MathUtils.cpp │ │ ├── CVUtils │ │ │ ├── CvVideoFileWriter.cpp │ │ │ ├── CvVideoFrameReader.cpp │ │ │ └── CvWindowOutput.cpp │ │ └── Utils │ │ │ └── CmdArgsParser.cpp │ └── test │ │ └── Audio │ │ ├── AudioCaptureTest.cpp │ │ └── MathUtilsTest.cpp ├── examples.dox └── serialized │ ├── Readme.md │ ├── Readme.md.license │ ├── ssd_mobilenet_v1.armnn │ └── ssd_mobilenet_v1.armnn.license ├── scripts ├── build_android_ndk_guide.sh ├── clang-format.sh ├── generate_spdx.sh ├── generate_tensorflow_protobuf.sh ├── get_compute_library.sh └── get_tensorflow.sh ├── src ├── armnn │ ├── ArmNNProfilingServiceInitialiser.cpp │ ├── ArmNNProfilingServiceInitialiser.hpp │ ├── BackendHelper.cpp │ ├── BackendRegistry.cpp │ ├── BackendSettings.hpp │ ├── Descriptors.cpp │ ├── DeviceSpec.hpp │ ├── DllExport.hpp │ ├── Exceptions.cpp │ ├── ExecutionFrame.cpp │ ├── ExecutionFrame.hpp │ ├── Graph.cpp │ ├── Graph.hpp │ ├── IGraphObservable.hpp │ ├── ILayerSupport.cpp │ ├── ISubgraphViewConverter.hpp │ ├── Instrument.hpp │ ├── InternalTypes.cpp │ ├── InternalTypes.hpp │ ├── JsonPrinter.cpp │ ├── JsonPrinter.hpp │ ├── JsonUtils.hpp │ ├── Layer.cpp │ ├── Layer.hpp │ ├── LayerFwd.hpp │ ├── LayerSupportCommon.hpp │ ├── LayersFwd.hpp │ ├── LoadedNetwork.cpp │ ├── LoadedNetwork.hpp │ ├── Logging.cpp │ ├── Markers.hpp │ ├── Network.cpp │ ├── Network.hpp │ ├── NetworkUtils.cpp │ ├── NetworkUtils.hpp │ ├── Observable.cpp │ ├── Observable.hpp │ ├── OptimizedNetworkImpl.hpp │ ├── Optimizer.cpp │ ├── Optimizer.hpp │ ├── OutputHandler.cpp │ ├── OutputHandler.hpp │ ├── Profiling.cpp │ ├── Profiling.hpp │ ├── ProfilingDetails.hpp │ ├── ProfilingEvent.cpp │ ├── ProfilingEvent.hpp │ ├── ResolveType.hpp │ ├── Runtime.cpp │ ├── Runtime.hpp │ ├── SerializeLayerParameters.cpp │ ├── SerializeLayerParameters.hpp │ ├── SubgraphView.cpp │ ├── SubgraphViewSelector.cpp │ ├── SubgraphViewSelector.hpp │ ├── Tensor.cpp │ ├── TypesUtils.cpp │ ├── Utils.cpp │ ├── WallClockTimer.cpp │ ├── WallClockTimer.hpp │ ├── layers │ │ ├── AbsLayer.cpp │ │ ├── AbsLayer.hpp │ │ ├── ActivationLayer.cpp │ │ ├── ActivationLayer.hpp │ │ ├── AdditionLayer.cpp │ │ ├── AdditionLayer.hpp │ │ ├── ArgMinMaxLayer.cpp │ │ ├── ArgMinMaxLayer.hpp │ │ ├── BatchMatMulLayer.cpp │ │ ├── BatchMatMulLayer.hpp │ │ ├── BatchNormalizationLayer.cpp │ │ ├── BatchNormalizationLayer.hpp │ │ ├── BatchToSpaceNdLayer.cpp │ │ ├── BatchToSpaceNdLayer.hpp │ │ ├── BroadcastToLayer.cpp │ │ ├── BroadcastToLayer.hpp │ │ ├── CastLayer.cpp │ │ ├── CastLayer.hpp │ │ ├── ChannelShuffleLayer.cpp │ │ ├── ChannelShuffleLayer.hpp │ │ ├── ComparisonLayer.cpp │ │ ├── ComparisonLayer.hpp │ │ ├── ConcatLayer.cpp │ │ ├── ConcatLayer.hpp │ │ ├── ConstantLayer.cpp │ │ ├── ConstantLayer.hpp │ │ ├── ConvertFp16ToFp32Layer.cpp │ │ ├── ConvertFp16ToFp32Layer.hpp │ │ ├── ConvertFp32ToFp16Layer.cpp │ │ ├── ConvertFp32ToFp16Layer.hpp │ │ ├── Convolution2dLayer.cpp │ │ ├── Convolution2dLayer.hpp │ │ ├── Convolution3dLayer.cpp │ │ ├── Convolution3dLayer.hpp │ │ ├── DebugLayer.cpp │ │ ├── DebugLayer.hpp │ │ ├── DepthToSpaceLayer.cpp │ │ ├── DepthToSpaceLayer.hpp │ │ ├── DepthwiseConvolution2dLayer.cpp │ │ ├── DepthwiseConvolution2dLayer.hpp │ │ ├── DequantizeLayer.cpp │ │ ├── DequantizeLayer.hpp │ │ ├── DetectionPostProcessLayer.cpp │ │ ├── DetectionPostProcessLayer.hpp │ │ ├── DivisionLayer.cpp │ │ ├── DivisionLayer.hpp │ │ ├── ElementwiseBaseLayer.cpp │ │ ├── ElementwiseBaseLayer.hpp │ │ ├── ElementwiseBinaryLayer.cpp │ │ ├── ElementwiseBinaryLayer.hpp │ │ ├── ElementwiseUnaryLayer.cpp │ │ ├── ElementwiseUnaryLayer.hpp │ │ ├── FakeQuantizationLayer.cpp │ │ ├── FakeQuantizationLayer.hpp │ │ ├── FillLayer.cpp │ │ ├── FillLayer.hpp │ │ ├── FloorLayer.cpp │ │ ├── FloorLayer.hpp │ │ ├── FullyConnectedLayer.cpp │ │ ├── FullyConnectedLayer.hpp │ │ ├── FusedLayer.cpp │ │ ├── FusedLayer.hpp │ │ ├── GatherLayer.cpp │ │ ├── GatherLayer.hpp │ │ ├── GatherNdLayer.cpp │ │ ├── GatherNdLayer.hpp │ │ ├── InputLayer.cpp │ │ ├── InputLayer.hpp │ │ ├── InstanceNormalizationLayer.cpp │ │ ├── InstanceNormalizationLayer.hpp │ │ ├── L2NormalizationLayer.cpp │ │ ├── L2NormalizationLayer.hpp │ │ ├── LayerCloneBase.hpp │ │ ├── LayerWithParameters.hpp │ │ ├── LogSoftmaxLayer.cpp │ │ ├── LogSoftmaxLayer.hpp │ │ ├── LogicalBinaryLayer.cpp │ │ ├── LogicalBinaryLayer.hpp │ │ ├── LstmLayer.cpp │ │ ├── LstmLayer.hpp │ │ ├── LstmParameters.hpp │ │ ├── MapLayer.cpp │ │ ├── MapLayer.hpp │ │ ├── MaximumLayer.cpp │ │ ├── MaximumLayer.hpp │ │ ├── MeanLayer.cpp │ │ ├── MeanLayer.hpp │ │ ├── MemCopyLayer.cpp │ │ ├── MemCopyLayer.hpp │ │ ├── MemImportLayer.cpp │ │ ├── MemImportLayer.hpp │ │ ├── MergeLayer.cpp │ │ ├── MergeLayer.hpp │ │ ├── MergerLayer.hpp │ │ ├── MinimumLayer.cpp │ │ ├── MinimumLayer.hpp │ │ ├── MultiplicationLayer.cpp │ │ ├── MultiplicationLayer.hpp │ │ ├── NormalizationLayer.cpp │ │ ├── NormalizationLayer.hpp │ │ ├── OutputLayer.cpp │ │ ├── OutputLayer.hpp │ │ ├── PadLayer.cpp │ │ ├── PadLayer.hpp │ │ ├── PermuteLayer.cpp │ │ ├── PermuteLayer.hpp │ │ ├── Pooling2dLayer.cpp │ │ ├── Pooling2dLayer.hpp │ │ ├── Pooling3dLayer.cpp │ │ ├── Pooling3dLayer.hpp │ │ ├── PreCompiledLayer.cpp │ │ ├── PreCompiledLayer.hpp │ │ ├── PreluLayer.cpp │ │ ├── PreluLayer.hpp │ │ ├── QLstmLayer.cpp │ │ ├── QLstmLayer.hpp │ │ ├── QuantizeLayer.cpp │ │ ├── QuantizeLayer.hpp │ │ ├── QuantizedLstmLayer.cpp │ │ ├── QuantizedLstmLayer.hpp │ │ ├── RankLayer.cpp │ │ ├── RankLayer.hpp │ │ ├── ReduceLayer.cpp │ │ ├── ReduceLayer.hpp │ │ ├── ReshapeLayer.cpp │ │ ├── ReshapeLayer.hpp │ │ ├── ResizeLayer.cpp │ │ ├── ResizeLayer.hpp │ │ ├── ReverseV2Layer.cpp │ │ ├── ReverseV2Layer.hpp │ │ ├── RsqrtLayer.cpp │ │ ├── RsqrtLayer.hpp │ │ ├── ScatterNdLayer.cpp │ │ ├── ScatterNdLayer.hpp │ │ ├── ShapeLayer.cpp │ │ ├── ShapeLayer.hpp │ │ ├── SliceLayer.cpp │ │ ├── SliceLayer.hpp │ │ ├── SoftmaxLayer.cpp │ │ ├── SoftmaxLayer.hpp │ │ ├── SpaceToBatchNdLayer.cpp │ │ ├── SpaceToBatchNdLayer.hpp │ │ ├── SpaceToDepthLayer.cpp │ │ ├── SpaceToDepthLayer.hpp │ │ ├── SplitterLayer.cpp │ │ ├── SplitterLayer.hpp │ │ ├── StackLayer.cpp │ │ ├── StackLayer.hpp │ │ ├── StandInLayer.cpp │ │ ├── StandInLayer.hpp │ │ ├── StridedSliceLayer.cpp │ │ ├── StridedSliceLayer.hpp │ │ ├── SubtractionLayer.cpp │ │ ├── SubtractionLayer.hpp │ │ ├── SwitchLayer.cpp │ │ ├── SwitchLayer.hpp │ │ ├── TileLayer.cpp │ │ ├── TileLayer.hpp │ │ ├── TransposeConvolution2dLayer.cpp │ │ ├── TransposeConvolution2dLayer.hpp │ │ ├── TransposeLayer.cpp │ │ ├── TransposeLayer.hpp │ │ ├── UnidirectionalSequenceLstmLayer.cpp │ │ ├── UnidirectionalSequenceLstmLayer.hpp │ │ ├── UnmapLayer.cpp │ │ └── UnmapLayer.hpp │ ├── optimizations │ │ ├── AddBroadcastReshapeLayer.hpp │ │ ├── AddDebug.hpp │ │ ├── All.hpp │ │ ├── ConvertConstDequantisationLayersToConstLayers.hpp │ │ ├── ConvertConstPermuteLayersToConstLayers.hpp │ │ ├── ConvertConstants.hpp │ │ ├── ConvertFp32NetworkToFp16.hpp │ │ ├── DeleteBroadcastTo.hpp │ │ ├── FoldPadIntoLayer2d.hpp │ │ ├── FuseBatchNorm.hpp │ │ ├── MaxMinIntoBoundedRelu.hpp │ │ ├── MovePermuteUp.hpp │ │ ├── MoveTransposeUp.hpp │ │ ├── Optimization.hpp │ │ ├── OptimizeConsecutiveReshapes.hpp │ │ ├── OptimizeInverseConversions.hpp │ │ ├── OptimizeInversePermutes.hpp │ │ ├── PermuteAndBatchToSpaceAsDepthToSpace.hpp │ │ ├── PermuteAsReshape.hpp │ │ ├── PermuteDepthwiseConv2dWeights.hpp │ │ ├── SquashEqualSiblings.hpp │ │ ├── TransposeAsReshape.hpp │ │ └── TurboConvertConstDequantisationLayersToConstLayers.hpp │ └── test │ │ ├── CloneTests.cpp │ │ ├── ConstTensorLayerVisitor.cpp │ │ ├── ConstTensorLayerVisitor.hpp │ │ ├── DebugCallbackTest.cpp │ │ ├── EndToEndTest.cpp │ │ ├── ExecutionFrameTest.cpp │ │ ├── FloatingPointConverterTest.cpp │ │ ├── FlowControl.cpp │ │ ├── GraphTests.cpp │ │ ├── InferOutputTests.cpp │ │ ├── InferOutputTests.hpp │ │ ├── InstrumentTests.cpp │ │ ├── LayerTests.cpp │ │ ├── ModelAccuracyCheckerTest.cpp │ │ ├── NetworkTests.cpp │ │ ├── ObservableTest.cpp │ │ ├── OptimizerTests.cpp │ │ ├── OptionalTest.cpp │ │ ├── ProfilerTests.cpp │ │ ├── ProfilingEventTest.cpp │ │ ├── RuntimeTests.cpp │ │ ├── RuntimeTests.hpp │ │ ├── ShapeInferenceTests.cpp │ │ ├── SubgraphViewTests.cpp │ │ ├── TensorHandleStrategyTest.cpp │ │ ├── TensorTest.cpp │ │ ├── TestInputOutputLayerVisitor.cpp │ │ ├── TestInputOutputLayerVisitor.hpp │ │ ├── TestLayerVisitor.cpp │ │ ├── TestLayerVisitor.hpp │ │ ├── TestNameAndDescriptorLayerVisitor.cpp │ │ ├── TestNameAndDescriptorLayerVisitor.hpp │ │ ├── TestNameOnlyLayerVisitor.cpp │ │ ├── TestNameOnlyLayerVisitor.hpp │ │ ├── UtilityTests.cpp │ │ ├── UtilsTests.cpp │ │ └── optimizations │ │ ├── AddBroadcastReshapeLayerTests.cpp │ │ ├── AddMulAddTests.cpp │ │ ├── BroadcastToTests.cpp │ │ ├── ConvertConstDequantisationLayersToConstLayersTest.cpp │ │ ├── ConvertConstPermuteLayersToConstLayersTest.cpp │ │ ├── ConvertConstantsFloatToHalfTests.cpp │ │ ├── ConvertConstantsHalfToFloatTests.cpp │ │ ├── FoldPadIntoQuantizedAveragePooling2DTests.cpp │ │ ├── FoldPadTests.cpp │ │ ├── Fp32NetworkToFp16ConverterTests.cpp │ │ ├── FuseActivationTests.cpp │ │ ├── FuseBatchNormTests.cpp │ │ ├── InsertDebugLayerTests.cpp │ │ ├── MaxMinIntoBoundedReluTests.cpp │ │ ├── MovePermuteUpTests.cpp │ │ ├── MoveTransposeUpTests.cpp │ │ ├── OptimizeConsecutiveReshapesTests.cpp │ │ ├── OptimizeInverseConversionsTests.cpp │ │ ├── OptimizeInversePermutesTests.cpp │ │ ├── PermuteAndBatchToSpaceAsDepthToSpaceTests.cpp │ │ ├── PermuteAsReshapeTests.cpp │ │ ├── PermuteDepthwiseConv2dWeightsTests.cpp │ │ ├── ReduceMultipleAxesTests.cpp │ │ ├── SquashEqualSiblingsTests.cpp │ │ └── TransposeAsReshapeTests.cpp ├── armnnDeserializer │ ├── CMakeLists.txt │ ├── Deserializer.cpp │ ├── Deserializer.hpp │ ├── README.md │ ├── README.md.license │ └── test │ │ ├── DeserializeAbs.cpp │ │ ├── DeserializeActivation.cpp │ │ ├── DeserializeAdd.cpp │ │ ├── DeserializeArgMinMax.cpp │ │ ├── DeserializeBatchMatMul.cpp │ │ ├── DeserializeBatchNormalization.cpp │ │ ├── DeserializeBatchToSpaceNd.cpp │ │ ├── DeserializeCast.cpp │ │ ├── DeserializeChannelShuffle.cpp │ │ ├── DeserializeComparison.cpp │ │ ├── DeserializeConstant.cpp │ │ ├── DeserializeConvolution2d.cpp │ │ ├── DeserializeConvolution3d.cpp │ │ ├── DeserializeDepthToSpace.cpp │ │ ├── DeserializeDepthwiseConv2d.cpp │ │ ├── DeserializeDivision.cpp │ │ ├── DeserializeElementWiseBinary.cpp │ │ ├── DeserializeElementwiseUnary.cpp │ │ ├── DeserializeFill.cpp │ │ ├── DeserializeFloor.cpp │ │ ├── DeserializeFullyConnected.cpp │ │ ├── DeserializeGather.cpp │ │ ├── DeserializeGatherNd.cpp │ │ ├── DeserializeInstanceNormalization.cpp │ │ ├── DeserializeL2Normalization.cpp │ │ ├── DeserializeLogSoftmax.cpp │ │ ├── DeserializeMean.cpp │ │ ├── DeserializeMultiplication.cpp │ │ ├── DeserializeNormalization.cpp │ │ ├── DeserializePad.cpp │ │ ├── DeserializePermute.cpp │ │ ├── DeserializePooling2d.cpp │ │ ├── DeserializePooling3d.cpp │ │ ├── DeserializeRank.cpp │ │ ├── DeserializeReduceSum.cpp │ │ ├── DeserializeReshape.cpp │ │ ├── DeserializeResizeBilinear.cpp │ │ ├── DeserializeReverseV2.cpp │ │ ├── DeserializeRsqrt.cpp │ │ ├── DeserializeScatterNd.cpp │ │ ├── DeserializeShape.cpp │ │ ├── DeserializeSlice.cpp │ │ ├── DeserializeSpaceToBatchNd.cpp │ │ ├── DeserializeStridedSlice.cpp │ │ ├── DeserializeSubtraction.cpp │ │ ├── DeserializeTranspose.cpp │ │ ├── ParserFlatbuffersSerializeFixture.hpp │ │ ├── SchemaSerialize.hpp │ │ └── SchemaSerialize.s ├── armnnOnnxParser │ ├── OnnxParser.cpp │ ├── OnnxParser.hpp │ ├── README.md │ ├── README.md.license │ └── test │ │ ├── Addition.cpp │ │ ├── BatchNorm.cpp │ │ ├── Clip.cpp │ │ ├── Concat.cpp │ │ ├── Const.cpp │ │ ├── Constructor.cpp │ │ ├── Conv2D.cpp │ │ ├── CreateNetwork.cpp │ │ ├── DepthConv.cpp │ │ ├── Flatten.cpp │ │ ├── FullyConnected.cpp │ │ ├── Gather.cpp │ │ ├── Gemm.cpp │ │ ├── GetInputsOutputs.cpp │ │ ├── LoadScopeDynamicTensor.cpp │ │ ├── OnnxParserTestUtils.cpp │ │ ├── OnnxParserTestUtils.hpp │ │ ├── Pooling.cpp │ │ ├── Relu.cpp │ │ ├── Reshape.cpp │ │ ├── Shape.cpp │ │ └── Unsqueeze.cpp ├── armnnSerializer │ ├── ArmnnSchema.fbs │ ├── CMakeLists.txt │ ├── README.md │ ├── README.md.license │ ├── Serializer.cpp │ ├── Serializer.hpp │ ├── SerializerUtils.cpp │ ├── SerializerUtils.hpp │ └── test │ │ ├── ActivationSerializationTests.cpp │ │ ├── ComparisonSerializationTests.cpp │ │ ├── LstmSerializationTests.cpp │ │ ├── SerializerTestUtils.cpp │ │ ├── SerializerTestUtils.hpp │ │ └── SerializerTests.cpp ├── armnnTestUtils │ ├── CMakeLists.txt │ ├── CommonTestUtils.cpp │ ├── CommonTestUtils.hpp │ ├── CreateWorkload.hpp │ ├── DataTypeUtils.hpp │ ├── GraphUtils.cpp │ ├── GraphUtils.hpp │ ├── MockBackend.cpp │ ├── MockMemoryManager.cpp │ ├── MockTensorHandle.cpp │ ├── MockTensorHandleFactory.cpp │ ├── MockTensorHandleFactory.hpp │ ├── TensorCopyUtils.cpp │ ├── TestUtils.cpp │ ├── TestUtils.hpp │ ├── UnitTests.cpp │ └── UnitTests.hpp ├── armnnTfLiteParser │ ├── CMakeLists.txt │ ├── README.md │ ├── README.md.license │ ├── TfLiteParser.cpp │ ├── TfLiteParser.hpp │ └── test │ │ ├── Activations.cpp │ │ ├── Addition.cpp │ │ ├── ArgMinMax.cpp │ │ ├── AvgPool2D.cpp │ │ ├── BatchMatMul.cpp │ │ ├── BatchToSpaceND.cpp │ │ ├── BroadcastTo.cpp │ │ ├── Cast.cpp │ │ ├── Comparison.cpp │ │ ├── Concatenation.cpp │ │ ├── Constant.cpp │ │ ├── Conv2D.cpp │ │ ├── Conv3D.cpp │ │ ├── DepthToSpace.cpp │ │ ├── DepthwiseConvolution2D.cpp │ │ ├── Dequantize.cpp │ │ ├── DetectionPostProcess.cpp │ │ ├── Div.cpp │ │ ├── ElementWiseUnary.cpp │ │ ├── ExpandDims.cpp │ │ ├── FloorDiv.cpp │ │ ├── FullyConnected.cpp │ │ ├── Gather.cpp │ │ ├── GatherNd.cpp │ │ ├── GetBuffer.cpp │ │ ├── GetInputsOutputs.cpp │ │ ├── GetSubgraphInputsOutputs.cpp │ │ ├── GetTensorIds.cpp │ │ ├── InputOutputTensorNames.cpp │ │ ├── L2Normalization.cpp │ │ ├── LeakyRelu.cpp │ │ ├── LoadModel.cpp │ │ ├── LoadScopeDynamicTensor.cpp │ │ ├── LocalResponseNormalization.cpp │ │ ├── LogSoftmax.cpp │ │ ├── MaxPool2D.cpp │ │ ├── Maximum.cpp │ │ ├── Mean.cpp │ │ ├── Minimum.cpp │ │ ├── MirrorPad.cpp │ │ ├── Multiplication.cpp │ │ ├── OutputShapeOfSqueeze.cpp │ │ ├── Pack.cpp │ │ ├── Pad.cpp │ │ ├── PadV2.cpp │ │ ├── ParserFlatbuffersFixture.hpp │ │ ├── Power.cpp │ │ ├── Prelu.cpp │ │ ├── Prod.cpp │ │ ├── Quantize.cpp │ │ ├── Reduce.cpp │ │ ├── Reshape.cpp │ │ ├── ReshapeDynamic.cpp │ │ ├── ResizeBilinear.cpp │ │ ├── ResizeNearestNeighbor.cpp │ │ ├── ReverseV2.cpp │ │ ├── ScatterNd.cpp │ │ ├── Schema.hpp │ │ ├── Shape.cpp │ │ ├── Slice.cpp │ │ ├── Softmax.cpp │ │ ├── SpaceToBatchND.cpp │ │ ├── SpaceToDepth.cpp │ │ ├── Split.cpp │ │ ├── SplitV.cpp │ │ ├── Square.cpp │ │ ├── SquaredDifference.cpp │ │ ├── Squeeze.cpp │ │ ├── StridedSlice.cpp │ │ ├── Sub.cpp │ │ ├── Sum.cpp │ │ ├── TfLiteParser.cpp │ │ ├── Tile.cpp │ │ ├── Transpose.cpp │ │ ├── TransposeConv.cpp │ │ ├── Unpack.cpp │ │ └── Unsupported.cpp ├── armnnUtils │ ├── BFloat16.hpp │ ├── CompatibleTypes.cpp │ ├── DataLayoutIndexed.cpp │ ├── DotSerializer.cpp │ ├── DotSerializer.hpp │ ├── Filesystem.cpp │ ├── FloatingPointConverter.cpp │ ├── GraphTopologicalSort.hpp │ ├── Half.hpp │ ├── HeapProfiling.cpp │ ├── HeapProfiling.hpp │ ├── LeakChecking.cpp │ ├── LeakChecking.hpp │ ├── ModelAccuracyChecker.cpp │ ├── ModelAccuracyChecker.hpp │ ├── ParserHelper.cpp │ ├── ParserHelper.hpp │ ├── ParserPrototxtFixture.hpp │ ├── Permute.cpp │ ├── ProfilingOptionsConverter.cpp │ ├── ProfilingOptionsConverter.hpp │ ├── PrototxtConversions.cpp │ ├── PrototxtConversions.hpp │ ├── TensorIOUtils.hpp │ ├── TensorUtils.cpp │ ├── Transpose.cpp │ ├── VerificationHelpers.cpp │ ├── VerificationHelpers.hpp │ └── test │ │ ├── FloatingPointComparisonTest.cpp │ │ ├── ParserHelperTest.cpp │ │ ├── PrototxtConversionsTest.cpp │ │ ├── QuantizeHelperTest.cpp │ │ ├── TensorUtilsTest.cpp │ │ └── TransformIteratorTest.cpp ├── backends │ ├── README.md │ ├── README.md.license │ ├── aclCommon │ │ ├── ArmComputeSubgraphUtils.hpp │ │ ├── ArmComputeTensorHandle.hpp │ │ ├── ArmComputeTensorUtils.cpp │ │ ├── ArmComputeTensorUtils.hpp │ │ ├── ArmComputeTuningUtils.cpp │ │ ├── ArmComputeTuningUtils.hpp │ │ ├── ArmComputeUtils.hpp │ │ ├── BaseMemoryManager.cpp │ │ ├── BaseMemoryManager.hpp │ │ ├── CMakeLists.txt │ │ ├── IClTensorHandle.hpp │ │ ├── common.cmake │ │ ├── common.mk │ │ └── test │ │ │ ├── ArmComputeTensorUtilsTests.cpp │ │ │ ├── CMakeLists.txt │ │ │ ├── CreateWorkloadClNeon.hpp │ │ │ └── MemCopyTests.cpp │ ├── backends.cmake │ ├── backendsCommon │ │ ├── CMakeLists.txt │ │ ├── DefaultAllocator.hpp │ │ ├── DynamicBackend.cpp │ │ ├── DynamicBackendUtils.cpp │ │ ├── DynamicBackendUtils.hpp │ │ ├── IBackendInternal.cpp │ │ ├── ITensorHandleFactory.cpp │ │ ├── LayerSupportBase.cpp │ │ ├── LayerSupportBase.hpp │ │ ├── LayerSupportRules.hpp │ │ ├── MakeWorkloadHelper.hpp │ │ ├── MapWorkload.cpp │ │ ├── MapWorkload.hpp │ │ ├── MemCopyWorkload.cpp │ │ ├── MemImportWorkload.cpp │ │ ├── MemImportWorkload.hpp │ │ ├── MemSyncWorkload.cpp │ │ ├── MemSyncWorkload.hpp │ │ ├── MemoryManager.cpp │ │ ├── MemoryManager.hpp │ │ ├── OptimizationViews.cpp │ │ ├── SubgraphUtils.hpp │ │ ├── TensorHandle.cpp │ │ ├── TensorHandleFactoryRegistry.cpp │ │ ├── TensorHandleFactoryRegistry.hpp │ │ ├── UnmapWorkload.cpp │ │ ├── UnmapWorkload.hpp │ │ ├── WorkloadData.cpp │ │ ├── WorkloadDataCollector.hpp │ │ ├── WorkloadFactory.cpp │ │ ├── WorkloadFactoryBase.hpp │ │ ├── WorkloadUtils.cpp │ │ ├── WorkloadUtils.hpp │ │ ├── common.cmake │ │ ├── common.mk │ │ ├── memoryOptimizerStrategyLibrary │ │ │ ├── CMakeLists.txt │ │ │ ├── MemoryOptimizerStrategyFactory.hpp │ │ │ ├── MemoryOptimizerStrategyLibrary.hpp │ │ │ ├── strategies │ │ │ │ ├── ConstantMemoryStrategy.cpp │ │ │ │ ├── ConstantMemoryStrategy.hpp │ │ │ │ ├── SingleAxisPriorityList.cpp │ │ │ │ ├── SingleAxisPriorityList.hpp │ │ │ │ ├── StrategyValidator.cpp │ │ │ │ └── StrategyValidator.hpp │ │ │ └── test │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── ConstMemoryStrategyTests.cpp │ │ │ │ ├── MemoryOptimizerStrategyLibraryTests.cpp │ │ │ │ ├── SingleAxisPriorityListTests.cpp │ │ │ │ ├── TestMemBlocks.hpp │ │ │ │ └── ValidatorStrategyTests.cpp │ │ └── test │ │ │ ├── ActivationEndToEndTestImpl.hpp │ │ │ ├── ActivationFixture.hpp │ │ │ ├── AdditionEndToEndTestImpl.hpp │ │ │ ├── ArgMinMaxEndToEndTestImpl.hpp │ │ │ ├── BackendIdTests.cpp │ │ │ ├── BackendProfilingTests.cpp │ │ │ ├── BackendRegistryTests.cpp │ │ │ ├── BatchMatMulEndToEndTestImpl.hpp │ │ │ ├── BatchToSpaceNdEndToEndTestImpl.hpp │ │ │ ├── BroadcastToEndToEndTestImpl.hpp │ │ │ ├── CMakeLists.txt │ │ │ ├── ChannelShuffleEndToEndTestImpl.hpp │ │ │ ├── ComparisonEndToEndTestImpl.hpp │ │ │ ├── CompatibilityTests.cpp │ │ │ ├── ConcatEndToEndTestImpl.hpp │ │ │ ├── Convolution2dEndToEndTestImpl.hpp │ │ │ ├── Convolution3dEndToEndTestImpl.hpp │ │ │ ├── Convolution3dReshapeEndToEndTestImpl.hpp │ │ │ ├── CustomMemoryOptimizerStrategyTests.cpp │ │ │ ├── DepthToSpaceEndToEndTestImpl.hpp │ │ │ ├── DepthwiseConvolution2dEndToEndTests.hpp │ │ │ ├── DequantizeEndToEndTestImpl.hpp │ │ │ ├── DetectionPostProcessEndToEndTestImpl.hpp │ │ │ ├── DynamicBackendTests.cpp │ │ │ ├── DynamicBackendTests.hpp │ │ │ ├── ElementwiseBinaryEndToEndTestImpl.hpp │ │ │ ├── ElementwiseUnaryEndToEndTestImpl.hpp │ │ │ ├── EndToEndTestImpl.hpp │ │ │ ├── FillEndToEndTestImpl.hpp │ │ │ ├── FullyConnectedEndToEndTestImpl.hpp │ │ │ ├── GatherEndToEndTestImpl.hpp │ │ │ ├── GatherNdEndToEndTestImpl.hpp │ │ │ ├── InstanceNormalizationEndToEndTestImpl.cpp │ │ │ ├── InstanceNormalizationEndToEndTestImpl.hpp │ │ │ ├── IsLayerSupportedTestImpl.hpp │ │ │ ├── JsonPrinterTestImpl.cpp │ │ │ ├── JsonPrinterTestImpl.hpp │ │ │ ├── LayerReleaseConstantDataTest.cpp │ │ │ ├── LayerTests.hpp │ │ │ ├── LogSoftmaxEndToEndTestImpl.cpp │ │ │ ├── LogSoftmaxEndToEndTestImpl.hpp │ │ │ ├── MeanEndToEndTestImpl.hpp │ │ │ ├── MemoryManagerTests.cpp │ │ │ ├── MockBackendId.hpp │ │ │ ├── MultiplicationEndToEndTestImpl.hpp │ │ │ ├── OptimizationViewsTests.cpp │ │ │ ├── OptimizeSubgraphViewTests.cpp │ │ │ ├── OptimizedNetworkTests.cpp │ │ │ ├── PadEndToEndTestImpl.hpp │ │ │ ├── Pooling2dEndToEndTestImpl.hpp │ │ │ ├── PreluEndToEndTestImpl.hpp │ │ │ ├── QLstmEndToEndTestImpl.cpp │ │ │ ├── QLstmEndToEndTestImpl.hpp │ │ │ ├── QuantizationEndToEndTestImpl.hpp │ │ │ ├── QuantizedLstmEndToEndTestImpl.cpp │ │ │ ├── QuantizedLstmEndToEndTestImpl.hpp │ │ │ ├── RankEndToEndTestImpl.hpp │ │ │ ├── ReduceEndToEndTestImpl.hpp │ │ │ ├── ReshapeEndToEndTestImpl.hpp │ │ │ ├── ResizeEndToEndTestImpl.hpp │ │ │ ├── ReverseV2EndToEndTestImpl.hpp │ │ │ ├── RuntimeTestImpl.hpp │ │ │ ├── ScatterNdEndToEndTestImpl.hpp │ │ │ ├── SliceEndToEndTestImpl.hpp │ │ │ ├── SoftmaxEndToEndTestImpl.hpp │ │ │ ├── SpaceToDepthEndToEndTestImpl.cpp │ │ │ ├── SpaceToDepthEndToEndTestImpl.hpp │ │ │ ├── SplitterEndToEndTestImpl.hpp │ │ │ ├── StackEndToEndTestImpl.hpp │ │ │ ├── StridedSliceEndToEndTestImpl.hpp │ │ │ ├── SubgraphUtilsTest.hpp │ │ │ ├── SubtractionEndToEndTestImpl.hpp │ │ │ ├── TestDynamicBackend.cpp │ │ │ ├── TestDynamicBackend.hpp │ │ │ ├── TestSharedObject.cpp │ │ │ ├── TestSharedObject.hpp │ │ │ ├── TileEndToEndTestImpl.hpp │ │ │ ├── TransposeConvolution2dEndToEndTestImpl.hpp │ │ │ ├── TransposeEndToEndTestImpl.hpp │ │ │ ├── WorkloadDataValidation.cpp │ │ │ ├── WorkloadFactoryHelper.hpp │ │ │ ├── WorkloadUtilsTest.cpp │ │ │ ├── layerTests │ │ │ ├── AbsTestImpl.cpp │ │ │ ├── AbsTestImpl.hpp │ │ │ ├── ActivationTestImpl.cpp │ │ │ ├── ActivationTestImpl.hpp │ │ │ ├── AddMulAddTestImpl.hpp │ │ │ ├── AdditionTestImpl.cpp │ │ │ ├── AdditionTestImpl.hpp │ │ │ ├── ArgMinMaxTestImpl.cpp │ │ │ ├── ArgMinMaxTestImpl.hpp │ │ │ ├── BatchMatMulTestImpl.cpp │ │ │ ├── BatchMatMulTestImpl.hpp │ │ │ ├── BatchNormalizationTestImpl.cpp │ │ │ ├── BatchNormalizationTestImpl.hpp │ │ │ ├── BatchToSpaceNdTestImpl.hpp │ │ │ ├── BroadcastToTestImpl.cpp │ │ │ ├── BroadcastToTestImpl.hpp │ │ │ ├── CastTestImpl.cpp │ │ │ ├── CastTestImpl.hpp │ │ │ ├── ChannelShuffleTestImpl.cpp │ │ │ ├── ChannelShuffleTestImpl.hpp │ │ │ ├── ComparisonTestImpl.cpp │ │ │ ├── ComparisonTestImpl.hpp │ │ │ ├── ConcatTestImpl.cpp │ │ │ ├── ConcatTestImpl.hpp │ │ │ ├── ConstantTestImpl.cpp │ │ │ ├── ConstantTestImpl.hpp │ │ │ ├── Conv2dTestImpl.cpp │ │ │ ├── Conv2dTestImpl.hpp │ │ │ ├── Conv3dTestImpl.cpp │ │ │ ├── Conv3dTestImpl.hpp │ │ │ ├── ConvertFp16ToFp32TestImpl.cpp │ │ │ ├── ConvertFp16ToFp32TestImpl.hpp │ │ │ ├── ConvertFp32ToFp16TestImpl.cpp │ │ │ ├── ConvertFp32ToFp16TestImpl.hpp │ │ │ ├── DebugTestImpl.cpp │ │ │ ├── DebugTestImpl.hpp │ │ │ ├── DepthToSpaceTestImpl.cpp │ │ │ ├── DepthToSpaceTestImpl.hpp │ │ │ ├── DequantizeTestImpl.cpp │ │ │ ├── DequantizeTestImpl.hpp │ │ │ ├── DetectionPostProcessTestImpl.hpp │ │ │ ├── DivisionTestImpl.cpp │ │ │ ├── DivisionTestImpl.hpp │ │ │ ├── ElementwiseTestImpl.hpp │ │ │ ├── ElementwiseUnaryTestImpl.cpp │ │ │ ├── ElementwiseUnaryTestImpl.hpp │ │ │ ├── ExpTestImpl.cpp │ │ │ ├── ExpTestImpl.hpp │ │ │ ├── FakeQuantizationTestImpl.cpp │ │ │ ├── FakeQuantizationTestImpl.hpp │ │ │ ├── FillTestImpl.cpp │ │ │ ├── FillTestImpl.hpp │ │ │ ├── FloorDivTestImpl.cpp │ │ │ ├── FloorDivTestImpl.hpp │ │ │ ├── FloorTestImpl.cpp │ │ │ ├── FloorTestImpl.hpp │ │ │ ├── FullyConnectedTestImpl.cpp │ │ │ ├── FullyConnectedTestImpl.hpp │ │ │ ├── GatherNdTestImpl.cpp │ │ │ ├── GatherNdTestImpl.hpp │ │ │ ├── GatherTestImpl.cpp │ │ │ ├── GatherTestImpl.hpp │ │ │ ├── InstanceNormalizationTestImpl.cpp │ │ │ ├── InstanceNormalizationTestImpl.hpp │ │ │ ├── L2NormalizationTestImpl.cpp │ │ │ ├── L2NormalizationTestImpl.hpp │ │ │ ├── LogSoftmaxTestImpl.cpp │ │ │ ├── LogSoftmaxTestImpl.hpp │ │ │ ├── LogTestImpl.cpp │ │ │ ├── LogTestImpl.hpp │ │ │ ├── LogicalTestImpl.cpp │ │ │ ├── LogicalTestImpl.hpp │ │ │ ├── LstmTestImpl.cpp │ │ │ ├── LstmTestImpl.hpp │ │ │ ├── MaximumTestImpl.cpp │ │ │ ├── MaximumTestImpl.hpp │ │ │ ├── MeanTestImpl.hpp │ │ │ ├── MinimumTestImpl.cpp │ │ │ ├── MinimumTestImpl.hpp │ │ │ ├── MirrorPadTestImpl.cpp │ │ │ ├── MirrorPadTestImpl.hpp │ │ │ ├── MultiplicationTestImpl.cpp │ │ │ ├── MultiplicationTestImpl.hpp │ │ │ ├── NegTestImpl.cpp │ │ │ ├── NegTestImpl.hpp │ │ │ ├── NormalizationTestImpl.cpp │ │ │ ├── NormalizationTestImpl.hpp │ │ │ ├── PadTestImpl.cpp │ │ │ ├── PadTestImpl.hpp │ │ │ ├── PermuteTestImpl.hpp │ │ │ ├── Pooling2dTestImpl.cpp │ │ │ ├── Pooling2dTestImpl.hpp │ │ │ ├── Pooling3dTestImpl.cpp │ │ │ ├── Pooling3dTestImpl.hpp │ │ │ ├── PowerTestImpl.cpp │ │ │ ├── PowerTestImpl.hpp │ │ │ ├── PreluTestImpl.hpp │ │ │ ├── QuantizeTestImpl.cpp │ │ │ ├── QuantizeTestImpl.hpp │ │ │ ├── RankTestImpl.cpp │ │ │ ├── RankTestImpl.hpp │ │ │ ├── ReduceProdTestImpl.cpp │ │ │ ├── ReduceProdTestImpl.hpp │ │ │ ├── ReduceSumTestImpl.cpp │ │ │ ├── ReduceSumTestImpl.hpp │ │ │ ├── ReductionTestImpl.cpp │ │ │ ├── ReductionTestImpl.hpp │ │ │ ├── ReshapeTestImpl.cpp │ │ │ ├── ReshapeTestImpl.hpp │ │ │ ├── ResizeTestImpl.cpp │ │ │ ├── ResizeTestImpl.hpp │ │ │ ├── ReverseV2TestImpl.cpp │ │ │ ├── ReverseV2TestImpl.hpp │ │ │ ├── RsqrtTestImpl.cpp │ │ │ ├── RsqrtTestImpl.hpp │ │ │ ├── ScatterNdTestImpl.cpp │ │ │ ├── ScatterNdTestImpl.hpp │ │ │ ├── ShapeTestImpl.cpp │ │ │ ├── ShapeTestImpl.hpp │ │ │ ├── SinTestImpl.cpp │ │ │ ├── SinTestImpl.hpp │ │ │ ├── SliceTestImpl.cpp │ │ │ ├── SliceTestImpl.hpp │ │ │ ├── SoftmaxTestImpl.cpp │ │ │ ├── SoftmaxTestImpl.hpp │ │ │ ├── SpaceToBatchNdTestImpl.cpp │ │ │ ├── SpaceToBatchNdTestImpl.hpp │ │ │ ├── SpaceToDepthTestImpl.cpp │ │ │ ├── SpaceToDepthTestImpl.hpp │ │ │ ├── SplitterTestImpl.cpp │ │ │ ├── SplitterTestImpl.hpp │ │ │ ├── SqrtTestImpl.cpp │ │ │ ├── SqrtTestImpl.hpp │ │ │ ├── SquaredDifferenceTestImpl.cpp │ │ │ ├── SquaredDifferenceTestImpl.hpp │ │ │ ├── StackTestImpl.cpp │ │ │ ├── StackTestImpl.hpp │ │ │ ├── StridedSliceTestImpl.cpp │ │ │ ├── StridedSliceTestImpl.hpp │ │ │ ├── SubtractionTestImpl.cpp │ │ │ ├── SubtractionTestImpl.hpp │ │ │ ├── TileTestImpl.cpp │ │ │ ├── TileTestImpl.hpp │ │ │ ├── TransposeConvolution2dTestImpl.cpp │ │ │ ├── TransposeConvolution2dTestImpl.hpp │ │ │ ├── TransposeTestImpl.hpp │ │ │ ├── UnidirectionalSequenceLstmTestImpl.cpp │ │ │ └── UnidirectionalSequenceLstmTestImpl.hpp │ │ │ └── mockBackend │ │ │ ├── MockImportBackend.cpp │ │ │ ├── MockImportBackend.hpp │ │ │ └── MockImportLayerSupport.hpp │ ├── cl │ │ ├── CMakeLists.txt │ │ ├── ClBackend.cpp │ │ ├── ClBackend.hpp │ │ ├── ClBackendContext.cpp │ │ ├── ClBackendContext.hpp │ │ ├── ClBackendDefaultAllocator.hpp │ │ ├── ClBackendId.hpp │ │ ├── ClBackendModelContext.cpp │ │ ├── ClBackendModelContext.hpp │ │ ├── ClContextControl.cpp │ │ ├── ClContextControl.hpp │ │ ├── ClContextDeserializer.cpp │ │ ├── ClContextDeserializer.hpp │ │ ├── ClContextSchema.fbs │ │ ├── ClContextSchema_generated.h │ │ ├── ClContextSerializer.cpp │ │ ├── ClContextSerializer.hpp │ │ ├── ClImportTensorHandle.hpp │ │ ├── ClImportTensorHandleFactory.cpp │ │ ├── ClImportTensorHandleFactory.hpp │ │ ├── ClLayerSupport.cpp │ │ ├── ClLayerSupport.hpp │ │ ├── ClRegistryInitializer.cpp │ │ ├── ClTensorHandle.cpp │ │ ├── ClTensorHandle.hpp │ │ ├── ClTensorHandleFactory.cpp │ │ ├── ClTensorHandleFactory.hpp │ │ ├── ClWorkloadFactory.cpp │ │ ├── ClWorkloadFactory.hpp │ │ ├── ICLTensorProxy.hpp │ │ ├── OpenClTimer.cpp │ │ ├── OpenClTimer.hpp │ │ ├── backend.cmake │ │ ├── backend.mk │ │ ├── test │ │ │ ├── CMakeLists.txt │ │ │ ├── ClBackendTests.cpp │ │ │ ├── ClContextControlFixture.hpp │ │ │ ├── ClContextSerializerTests.cpp │ │ │ ├── ClCreateWorkloadTests.cpp │ │ │ ├── ClCustomAllocatorTests.cpp │ │ │ ├── ClDefaultAllocatorTests.cpp │ │ │ ├── ClEndToEndTests.cpp │ │ │ ├── ClFallbackTests.cpp │ │ │ ├── ClImportTensorHandleFactoryTests.cpp │ │ │ ├── ClImportTensorHandleTests.cpp │ │ │ ├── ClJsonPrinterTests.cpp │ │ │ ├── ClLayerSupportTests.cpp │ │ │ ├── ClLayerTests.cpp │ │ │ ├── ClMemCopyTests.cpp │ │ │ ├── ClOptimizedNetworkTests.cpp │ │ │ ├── ClRuntimeTests.cpp │ │ │ ├── ClWorkloadFactoryHelper.hpp │ │ │ ├── Fp16SupportTest.cpp │ │ │ ├── ICLTensorProxyTests.cpp │ │ │ └── OpenClTimerTest.cpp │ │ └── workloads │ │ │ ├── CMakeLists.txt │ │ │ ├── ClAbsWorkload.cpp │ │ │ ├── ClAbsWorkload.hpp │ │ │ ├── ClActivationWorkload.cpp │ │ │ ├── ClActivationWorkload.hpp │ │ │ ├── ClAdditionWorkload.cpp │ │ │ ├── ClAdditionWorkload.hpp │ │ │ ├── ClArgMinMaxWorkload.cpp │ │ │ ├── ClArgMinMaxWorkload.hpp │ │ │ ├── ClBaseWorkload.hpp │ │ │ ├── ClBatchMatMulWorkload.cpp │ │ │ ├── ClBatchMatMulWorkload.hpp │ │ │ ├── ClBatchNormalizationFloatWorkload.cpp │ │ │ ├── ClBatchNormalizationFloatWorkload.hpp │ │ │ ├── ClBatchToSpaceNdWorkload.cpp │ │ │ ├── ClBatchToSpaceNdWorkload.hpp │ │ │ ├── ClCastWorkload.cpp │ │ │ ├── ClCastWorkload.hpp │ │ │ ├── ClChannelShuffleWorkload.cpp │ │ │ ├── ClChannelShuffleWorkload.hpp │ │ │ ├── ClComparisonWorkload.cpp │ │ │ ├── ClComparisonWorkload.hpp │ │ │ ├── ClConcatWorkload.cpp │ │ │ ├── ClConcatWorkload.hpp │ │ │ ├── ClConstantWorkload.cpp │ │ │ ├── ClConstantWorkload.hpp │ │ │ ├── ClConvertFp16ToFp32Workload.cpp │ │ │ ├── ClConvertFp16ToFp32Workload.hpp │ │ │ ├── ClConvertFp32ToFp16Workload.cpp │ │ │ ├── ClConvertFp32ToFp16Workload.hpp │ │ │ ├── ClConvolution2dWorkload.cpp │ │ │ ├── ClConvolution2dWorkload.hpp │ │ │ ├── ClConvolution3dWorkload.cpp │ │ │ ├── ClConvolution3dWorkload.hpp │ │ │ ├── ClDepthToSpaceWorkload.cpp │ │ │ ├── ClDepthToSpaceWorkload.hpp │ │ │ ├── ClDepthwiseConvolutionWorkload.cpp │ │ │ ├── ClDepthwiseConvolutionWorkload.hpp │ │ │ ├── ClDequantizeWorkload.cpp │ │ │ ├── ClDequantizeWorkload.hpp │ │ │ ├── ClDivisionWorkload.cpp │ │ │ ├── ClDivisionWorkload.hpp │ │ │ ├── ClElementwiseBinaryWorkload.cpp │ │ │ ├── ClElementwiseBinaryWorkload.hpp │ │ │ ├── ClExpWorkload.cpp │ │ │ ├── ClExpWorkload.hpp │ │ │ ├── ClFillWorkload.cpp │ │ │ ├── ClFillWorkload.hpp │ │ │ ├── ClFloorDivWorkload.cpp │ │ │ ├── ClFloorDivWorkload.hpp │ │ │ ├── ClFloorFloatWorkload.cpp │ │ │ ├── ClFloorFloatWorkload.hpp │ │ │ ├── ClFullyConnectedWorkload.cpp │ │ │ ├── ClFullyConnectedWorkload.hpp │ │ │ ├── ClGatherNdWorkload.cpp │ │ │ ├── ClGatherNdWorkload.hpp │ │ │ ├── ClGatherWorkload.cpp │ │ │ ├── ClGatherWorkload.hpp │ │ │ ├── ClInstanceNormalizationWorkload.cpp │ │ │ ├── ClInstanceNormalizationWorkload.hpp │ │ │ ├── ClL2NormalizationFloatWorkload.cpp │ │ │ ├── ClL2NormalizationFloatWorkload.hpp │ │ │ ├── ClLogSoftmaxWorkload.cpp │ │ │ ├── ClLogSoftmaxWorkload.hpp │ │ │ ├── ClLogWorkload.cpp │ │ │ ├── ClLogWorkload.hpp │ │ │ ├── ClLogicalAndWorkload.cpp │ │ │ ├── ClLogicalAndWorkload.hpp │ │ │ ├── ClLogicalNotWorkload.cpp │ │ │ ├── ClLogicalNotWorkload.hpp │ │ │ ├── ClLogicalOrWorkload.cpp │ │ │ ├── ClLogicalOrWorkload.hpp │ │ │ ├── ClLstmFloatWorkload.cpp │ │ │ ├── ClLstmFloatWorkload.hpp │ │ │ ├── ClMaximumWorkload.cpp │ │ │ ├── ClMaximumWorkload.hpp │ │ │ ├── ClMeanWorkload.cpp │ │ │ ├── ClMeanWorkload.hpp │ │ │ ├── ClMinimumWorkload.cpp │ │ │ ├── ClMinimumWorkload.hpp │ │ │ ├── ClMultiplicationWorkload.cpp │ │ │ ├── ClMultiplicationWorkload.hpp │ │ │ ├── ClNegWorkload.cpp │ │ │ ├── ClNegWorkload.hpp │ │ │ ├── ClNormalizationFloatWorkload.cpp │ │ │ ├── ClNormalizationFloatWorkload.hpp │ │ │ ├── ClPadWorkload.cpp │ │ │ ├── ClPadWorkload.hpp │ │ │ ├── ClPermuteWorkload.cpp │ │ │ ├── ClPermuteWorkload.hpp │ │ │ ├── ClPooling2dWorkload.cpp │ │ │ ├── ClPooling2dWorkload.hpp │ │ │ ├── ClPooling3dWorkload.cpp │ │ │ ├── ClPooling3dWorkload.hpp │ │ │ ├── ClPreluWorkload.cpp │ │ │ ├── ClPreluWorkload.hpp │ │ │ ├── ClQLstmWorkload.cpp │ │ │ ├── ClQLstmWorkload.hpp │ │ │ ├── ClQuantizeWorkload.cpp │ │ │ ├── ClQuantizeWorkload.hpp │ │ │ ├── ClQuantizedLstmWorkload.cpp │ │ │ ├── ClQuantizedLstmWorkload.hpp │ │ │ ├── ClRankWorkload.hpp │ │ │ ├── ClReduceWorkload.cpp │ │ │ ├── ClReduceWorkload.hpp │ │ │ ├── ClReshapeWorkload.cpp │ │ │ ├── ClReshapeWorkload.hpp │ │ │ ├── ClResizeWorkload.cpp │ │ │ ├── ClResizeWorkload.hpp │ │ │ ├── ClReverseV2Workload.cpp │ │ │ ├── ClReverseV2Workload.hpp │ │ │ ├── ClRsqrtWorkload.cpp │ │ │ ├── ClRsqrtWorkload.hpp │ │ │ ├── ClScatterNdWorkload.cpp │ │ │ ├── ClScatterNdWorkload.hpp │ │ │ ├── ClSinWorkload.cpp │ │ │ ├── ClSinWorkload.hpp │ │ │ ├── ClSliceWorkload.cpp │ │ │ ├── ClSliceWorkload.hpp │ │ │ ├── ClSoftmaxWorkload.cpp │ │ │ ├── ClSoftmaxWorkload.hpp │ │ │ ├── ClSpaceToBatchNdWorkload.cpp │ │ │ ├── ClSpaceToBatchNdWorkload.hpp │ │ │ ├── ClSpaceToDepthWorkload.cpp │ │ │ ├── ClSpaceToDepthWorkload.hpp │ │ │ ├── ClSplitterWorkload.cpp │ │ │ ├── ClSplitterWorkload.hpp │ │ │ ├── ClSqrtWorkload.cpp │ │ │ ├── ClSqrtWorkload.hpp │ │ │ ├── ClStackWorkload.cpp │ │ │ ├── ClStackWorkload.hpp │ │ │ ├── ClStridedSliceWorkload.cpp │ │ │ ├── ClStridedSliceWorkload.hpp │ │ │ ├── ClSubtractionWorkload.cpp │ │ │ ├── ClSubtractionWorkload.hpp │ │ │ ├── ClTileWorkload.cpp │ │ │ ├── ClTileWorkload.hpp │ │ │ ├── ClTransposeConvolution2dWorkload.cpp │ │ │ ├── ClTransposeConvolution2dWorkload.hpp │ │ │ ├── ClTransposeWorkload.cpp │ │ │ ├── ClTransposeWorkload.hpp │ │ │ ├── ClUnidirectionalSequenceLstmFloatWorkload.cpp │ │ │ ├── ClUnidirectionalSequenceLstmFloatWorkload.hpp │ │ │ ├── ClWorkloadUtils.hpp │ │ │ └── ClWorkloads.hpp │ ├── dynamic │ │ └── reference │ │ │ ├── CMakeLists.txt │ │ │ ├── RefDynamicBackend.cpp │ │ │ └── RefDynamicBackend.hpp │ ├── neon │ │ ├── CMakeLists.txt │ │ ├── NeonBackend.cpp │ │ ├── NeonBackend.hpp │ │ ├── NeonBackendId.hpp │ │ ├── NeonBackendModelContext.cpp │ │ ├── NeonBackendModelContext.hpp │ │ ├── NeonBackendOptimizationUtils.hpp │ │ ├── NeonInterceptorScheduler.cpp │ │ ├── NeonInterceptorScheduler.hpp │ │ ├── NeonLayerSupport.cpp │ │ ├── NeonLayerSupport.hpp │ │ ├── NeonRegistryInitializer.cpp │ │ ├── NeonTensorHandle.cpp │ │ ├── NeonTensorHandle.hpp │ │ ├── NeonTensorHandleFactory.cpp │ │ ├── NeonTensorHandleFactory.hpp │ │ ├── NeonTimer.cpp │ │ ├── NeonTimer.hpp │ │ ├── NeonWorkloadFactory.cpp │ │ ├── NeonWorkloadFactory.hpp │ │ ├── backend.cmake │ │ ├── backend.mk │ │ ├── test │ │ │ ├── CMakeLists.txt │ │ │ ├── NeonBackendTests.cpp │ │ │ ├── NeonCreateWorkloadTests.cpp │ │ │ ├── NeonEndToEndTests.cpp │ │ │ ├── NeonFallbackTests.cpp │ │ │ ├── NeonJsonPrinterTests.cpp │ │ │ ├── NeonLayerSupportTests.cpp │ │ │ ├── NeonLayerTests.cpp │ │ │ ├── NeonLayerTests_NDK_Bug.cpp │ │ │ ├── NeonMemCopyTests.cpp │ │ │ ├── NeonOptimizedNetworkTests.cpp │ │ │ ├── NeonRuntimeTests.cpp │ │ │ ├── NeonTensorHandleTests.cpp │ │ │ ├── NeonTimerTest.cpp │ │ │ └── NeonWorkloadFactoryHelper.hpp │ │ └── workloads │ │ │ ├── CMakeLists.txt │ │ │ ├── NeonAbsWorkload.cpp │ │ │ ├── NeonAbsWorkload.hpp │ │ │ ├── NeonActivationWorkload.cpp │ │ │ ├── NeonActivationWorkload.hpp │ │ │ ├── NeonAdditionWorkload.cpp │ │ │ ├── NeonAdditionWorkload.hpp │ │ │ ├── NeonArgMinMaxWorkload.cpp │ │ │ ├── NeonArgMinMaxWorkload.hpp │ │ │ ├── NeonBaseWorkload.hpp │ │ │ ├── NeonBatchMatMulWorkload.cpp │ │ │ ├── NeonBatchMatMulWorkload.hpp │ │ │ ├── NeonBatchNormalizationWorkload.cpp │ │ │ ├── NeonBatchNormalizationWorkload.hpp │ │ │ ├── NeonBatchToSpaceNdWorkload.cpp │ │ │ ├── NeonBatchToSpaceNdWorkload.hpp │ │ │ ├── NeonCastWorkload.cpp │ │ │ ├── NeonCastWorkload.hpp │ │ │ ├── NeonChannelShuffleWorkload.cpp │ │ │ ├── NeonChannelShuffleWorkload.hpp │ │ │ ├── NeonComparisonWorkload.cpp │ │ │ ├── NeonComparisonWorkload.hpp │ │ │ ├── NeonConcatWorkload.cpp │ │ │ ├── NeonConcatWorkload.hpp │ │ │ ├── NeonConstantWorkload.cpp │ │ │ ├── NeonConstantWorkload.hpp │ │ │ ├── NeonConvertFp16ToFp32Workload.cpp │ │ │ ├── NeonConvertFp16ToFp32Workload.hpp │ │ │ ├── NeonConvertFp32ToFp16Workload.cpp │ │ │ ├── NeonConvertFp32ToFp16Workload.hpp │ │ │ ├── NeonConvolution2dWorkload.cpp │ │ │ ├── NeonConvolution2dWorkload.hpp │ │ │ ├── NeonConvolution3dWorkload.cpp │ │ │ ├── NeonConvolution3dWorkload.hpp │ │ │ ├── NeonDepthToSpaceWorkload.cpp │ │ │ ├── NeonDepthToSpaceWorkload.hpp │ │ │ ├── NeonDepthwiseConvolutionWorkload.cpp │ │ │ ├── NeonDepthwiseConvolutionWorkload.hpp │ │ │ ├── NeonDequantizeWorkload.cpp │ │ │ ├── NeonDequantizeWorkload.hpp │ │ │ ├── NeonDetectionPostProcessWorkload.cpp │ │ │ ├── NeonDetectionPostProcessWorkload.hpp │ │ │ ├── NeonDivisionWorkload.cpp │ │ │ ├── NeonDivisionWorkload.hpp │ │ │ ├── NeonElementwiseBinaryWorkload.cpp │ │ │ ├── NeonElementwiseBinaryWorkload.hpp │ │ │ ├── NeonExpWorkload.cpp │ │ │ ├── NeonExpWorkload.hpp │ │ │ ├── NeonFillWorkload.cpp │ │ │ ├── NeonFillWorkload.hpp │ │ │ ├── NeonFloorDivWorkload.cpp │ │ │ ├── NeonFloorDivWorkload.hpp │ │ │ ├── NeonFloorFloatWorkload.cpp │ │ │ ├── NeonFloorFloatWorkload.hpp │ │ │ ├── NeonFullyConnectedWorkload.cpp │ │ │ ├── NeonFullyConnectedWorkload.hpp │ │ │ ├── NeonFusedWorkload.cpp │ │ │ ├── NeonFusedWorkload.hpp │ │ │ ├── NeonGatherNdWorkload.cpp │ │ │ ├── NeonGatherNdWorkload.hpp │ │ │ ├── NeonGatherWorkload.cpp │ │ │ ├── NeonGatherWorkload.hpp │ │ │ ├── NeonInstanceNormalizationWorkload.cpp │ │ │ ├── NeonInstanceNormalizationWorkload.hpp │ │ │ ├── NeonL2NormalizationFloatWorkload.cpp │ │ │ ├── NeonL2NormalizationFloatWorkload.hpp │ │ │ ├── NeonLogSoftmaxWorkload.cpp │ │ │ ├── NeonLogSoftmaxWorkload.hpp │ │ │ ├── NeonLogWorkload.cpp │ │ │ ├── NeonLogWorkload.hpp │ │ │ ├── NeonLogicalAndWorkload.cpp │ │ │ ├── NeonLogicalAndWorkload.hpp │ │ │ ├── NeonLogicalNotWorkload.cpp │ │ │ ├── NeonLogicalNotWorkload.hpp │ │ │ ├── NeonLogicalOrWorkload.cpp │ │ │ ├── NeonLogicalOrWorkload.hpp │ │ │ ├── NeonLstmFloatWorkload.cpp │ │ │ ├── NeonLstmFloatWorkload.hpp │ │ │ ├── NeonMaximumWorkload.cpp │ │ │ ├── NeonMaximumWorkload.hpp │ │ │ ├── NeonMeanWorkload.cpp │ │ │ ├── NeonMeanWorkload.hpp │ │ │ ├── NeonMinimumWorkload.cpp │ │ │ ├── NeonMinimumWorkload.hpp │ │ │ ├── NeonMultiplicationWorkload.cpp │ │ │ ├── NeonMultiplicationWorkload.hpp │ │ │ ├── NeonNegWorkload.cpp │ │ │ ├── NeonNegWorkload.hpp │ │ │ ├── NeonNormalizationFloatWorkload.cpp │ │ │ ├── NeonNormalizationFloatWorkload.hpp │ │ │ ├── NeonPadWorkload.cpp │ │ │ ├── NeonPadWorkload.hpp │ │ │ ├── NeonPermuteWorkload.cpp │ │ │ ├── NeonPermuteWorkload.hpp │ │ │ ├── NeonPooling2dWorkload.cpp │ │ │ ├── NeonPooling2dWorkload.hpp │ │ │ ├── NeonPooling3dWorkload.cpp │ │ │ ├── NeonPooling3dWorkload.hpp │ │ │ ├── NeonPreluWorkload.cpp │ │ │ ├── NeonPreluWorkload.hpp │ │ │ ├── NeonQLstmWorkload.cpp │ │ │ ├── NeonQLstmWorkload.hpp │ │ │ ├── NeonQuantizeWorkload.cpp │ │ │ ├── NeonQuantizeWorkload.hpp │ │ │ ├── NeonQuantizedLstmWorkload.cpp │ │ │ ├── NeonQuantizedLstmWorkload.hpp │ │ │ ├── NeonRankWorkload.hpp │ │ │ ├── NeonReduceWorkload.cpp │ │ │ ├── NeonReduceWorkload.hpp │ │ │ ├── NeonReshapeWorkload.cpp │ │ │ ├── NeonReshapeWorkload.hpp │ │ │ ├── NeonResizeWorkload.cpp │ │ │ ├── NeonResizeWorkload.hpp │ │ │ ├── NeonReverseV2Workload.cpp │ │ │ ├── NeonReverseV2Workload.hpp │ │ │ ├── NeonRsqrtWorkload.cpp │ │ │ ├── NeonRsqrtWorkload.hpp │ │ │ ├── NeonSinWorkload.cpp │ │ │ ├── NeonSinWorkload.hpp │ │ │ ├── NeonSliceWorkload.cpp │ │ │ ├── NeonSliceWorkload.hpp │ │ │ ├── NeonSoftmaxWorkload.cpp │ │ │ ├── NeonSoftmaxWorkload.hpp │ │ │ ├── NeonSpaceToBatchNdWorkload.cpp │ │ │ ├── NeonSpaceToBatchNdWorkload.hpp │ │ │ ├── NeonSpaceToDepthWorkload.cpp │ │ │ ├── NeonSpaceToDepthWorkload.hpp │ │ │ ├── NeonSplitterWorkload.cpp │ │ │ ├── NeonSplitterWorkload.hpp │ │ │ ├── NeonSqrtWorkload.cpp │ │ │ ├── NeonSqrtWorkload.hpp │ │ │ ├── NeonStackWorkload.cpp │ │ │ ├── NeonStackWorkload.hpp │ │ │ ├── NeonStridedSliceWorkload.cpp │ │ │ ├── NeonStridedSliceWorkload.hpp │ │ │ ├── NeonSubtractionWorkload.cpp │ │ │ ├── NeonSubtractionWorkload.hpp │ │ │ ├── NeonTileWorkload.cpp │ │ │ ├── NeonTileWorkload.hpp │ │ │ ├── NeonTransposeConvolution2dWorkload.cpp │ │ │ ├── NeonTransposeConvolution2dWorkload.hpp │ │ │ ├── NeonTransposeWorkload.cpp │ │ │ ├── NeonTransposeWorkload.hpp │ │ │ ├── NeonUnidirectionalSequenceLstmFloatWorkload.cpp │ │ │ ├── NeonUnidirectionalSequenceLstmFloatWorkload.hpp │ │ │ ├── NeonUnidirectionalSequenceLstmWorkload.cpp │ │ │ ├── NeonUnidirectionalSequenceLstmWorkload.hpp │ │ │ ├── NeonWorkloadUtils.hpp │ │ │ └── NeonWorkloads.hpp │ ├── reference │ │ ├── CMakeLists.txt │ │ ├── RefBackend.cpp │ │ ├── RefBackend.hpp │ │ ├── RefBackendId.hpp │ │ ├── RefLayerSupport.cpp │ │ ├── RefLayerSupport.hpp │ │ ├── RefMemoryManager.cpp │ │ ├── RefMemoryManager.hpp │ │ ├── RefRegistryInitializer.cpp │ │ ├── RefTensorHandle.cpp │ │ ├── RefTensorHandle.hpp │ │ ├── RefTensorHandleFactory.cpp │ │ ├── RefTensorHandleFactory.hpp │ │ ├── RefWorkloadFactory.cpp │ │ ├── RefWorkloadFactory.hpp │ │ ├── backend.cmake │ │ ├── backend.mk │ │ ├── test │ │ │ ├── ArgMinMaxTests.cpp │ │ │ ├── CMakeLists.txt │ │ │ ├── RefBackendTests.cpp │ │ │ ├── RefCreateWorkloadTests.cpp │ │ │ ├── RefDetectionPostProcessTests.cpp │ │ │ ├── RefEndToEndTests.cpp │ │ │ ├── RefJsonPrinterTests.cpp │ │ │ ├── RefLayerSupportTests.cpp │ │ │ ├── RefLayerTests.cpp │ │ │ ├── RefMemCopyTests.cpp │ │ │ ├── RefMemoryManagerTests.cpp │ │ │ ├── RefOptimizedNetworkTests.cpp │ │ │ ├── RefPerAxisIteratorTests.cpp │ │ │ ├── RefPerChannelDecoderTests.cpp │ │ │ ├── RefRuntimeTests.cpp │ │ │ ├── RefTensorHandleTests.cpp │ │ │ └── RefWorkloadFactoryHelper.hpp │ │ └── workloads │ │ │ ├── Abs.hpp │ │ │ ├── Activation.cpp │ │ │ ├── Activation.hpp │ │ │ ├── ArgMinMax.cpp │ │ │ ├── ArgMinMax.hpp │ │ │ ├── BaseIterator.hpp │ │ │ ├── BatchMatMulImpl.cpp │ │ │ ├── BatchMatMulImpl.hpp │ │ │ ├── BatchNormImpl.cpp │ │ │ ├── BatchNormImpl.hpp │ │ │ ├── BatchToSpaceNd.cpp │ │ │ ├── BatchToSpaceNd.hpp │ │ │ ├── Broadcast.cpp │ │ │ ├── Broadcast.hpp │ │ │ ├── CMakeLists.txt │ │ │ ├── Ceil.hpp │ │ │ ├── Concatenate.cpp │ │ │ ├── Concatenate.hpp │ │ │ ├── Conv3dImpl.cpp │ │ │ ├── Conv3dImpl.hpp │ │ │ ├── ConvImpl.cpp │ │ │ ├── ConvImpl.hpp │ │ │ ├── Debug.cpp │ │ │ ├── Debug.hpp │ │ │ ├── Decoders.hpp │ │ │ ├── DepthToSpace.cpp │ │ │ ├── DepthToSpace.hpp │ │ │ ├── Dequantize.cpp │ │ │ ├── Dequantize.hpp │ │ │ ├── DetectionPostProcess.cpp │ │ │ ├── DetectionPostProcess.hpp │ │ │ ├── ElementwiseFunction.cpp │ │ │ ├── ElementwiseFunction.hpp │ │ │ ├── Encoders.hpp │ │ │ ├── Exp.hpp │ │ │ ├── Fill.cpp │ │ │ ├── Fill.hpp │ │ │ ├── FloorDiv.hpp │ │ │ ├── FullyConnected.cpp │ │ │ ├── FullyConnected.hpp │ │ │ ├── Gather.cpp │ │ │ ├── Gather.hpp │ │ │ ├── InstanceNorm.cpp │ │ │ ├── InstanceNorm.hpp │ │ │ ├── Log.hpp │ │ │ ├── LogSoftmax.cpp │ │ │ ├── LogSoftmax.hpp │ │ │ ├── Lstm.cpp │ │ │ ├── Lstm.hpp │ │ │ ├── LstmUtils.cpp │ │ │ ├── LstmUtils.hpp │ │ │ ├── Maximum.hpp │ │ │ ├── Minimum.hpp │ │ │ ├── MirrorPad.cpp │ │ │ ├── MirrorPad.hpp │ │ │ ├── Pad.cpp │ │ │ ├── Pad.hpp │ │ │ ├── Pooling2d.cpp │ │ │ ├── Pooling2d.hpp │ │ │ ├── Pooling3d.cpp │ │ │ ├── Pooling3d.hpp │ │ │ ├── Power.hpp │ │ │ ├── PreluImpl.cpp │ │ │ ├── PreluImpl.hpp │ │ │ ├── Reduce.cpp │ │ │ ├── Reduce.hpp │ │ │ ├── RefActivationWorkload.cpp │ │ │ ├── RefActivationWorkload.hpp │ │ │ ├── RefArgMinMaxWorkload.cpp │ │ │ ├── RefArgMinMaxWorkload.hpp │ │ │ ├── RefBaseWorkload.hpp │ │ │ ├── RefBatchMatMulWorkload.cpp │ │ │ ├── RefBatchMatMulWorkload.hpp │ │ │ ├── RefBatchNormalizationWorkload.cpp │ │ │ ├── RefBatchNormalizationWorkload.hpp │ │ │ ├── RefBatchToSpaceNdWorkload.cpp │ │ │ ├── RefBatchToSpaceNdWorkload.hpp │ │ │ ├── RefBroadcastToWorkload.cpp │ │ │ ├── RefBroadcastToWorkload.hpp │ │ │ ├── RefCastWorkload.cpp │ │ │ ├── RefCastWorkload.hpp │ │ │ ├── RefChannelShuffleWorkload.cpp │ │ │ ├── RefChannelShuffleWorkload.hpp │ │ │ ├── RefComparisonWorkload.cpp │ │ │ ├── RefComparisonWorkload.hpp │ │ │ ├── RefConcatWorkload.cpp │ │ │ ├── RefConcatWorkload.hpp │ │ │ ├── RefConstantWorkload.cpp │ │ │ ├── RefConstantWorkload.hpp │ │ │ ├── RefConvertFp16ToFp32Workload.cpp │ │ │ ├── RefConvertFp16ToFp32Workload.hpp │ │ │ ├── RefConvertFp32ToFp16Workload.cpp │ │ │ ├── RefConvertFp32ToFp16Workload.hpp │ │ │ ├── RefConvolution2dWorkload.cpp │ │ │ ├── RefConvolution2dWorkload.hpp │ │ │ ├── RefConvolution3dWorkload.cpp │ │ │ ├── RefConvolution3dWorkload.hpp │ │ │ ├── RefDebugWorkload.cpp │ │ │ ├── RefDebugWorkload.hpp │ │ │ ├── RefDepthToSpaceWorkload.cpp │ │ │ ├── RefDepthToSpaceWorkload.hpp │ │ │ ├── RefDepthwiseConvolution2dWorkload.cpp │ │ │ ├── RefDepthwiseConvolution2dWorkload.hpp │ │ │ ├── RefDequantizeWorkload.cpp │ │ │ ├── RefDequantizeWorkload.hpp │ │ │ ├── RefDetectionPostProcessWorkload.cpp │ │ │ ├── RefDetectionPostProcessWorkload.hpp │ │ │ ├── RefElementwiseBinaryWorkload.cpp │ │ │ ├── RefElementwiseBinaryWorkload.hpp │ │ │ ├── RefElementwiseUnaryWorkload.cpp │ │ │ ├── RefElementwiseUnaryWorkload.hpp │ │ │ ├── RefElementwiseWorkload.cpp │ │ │ ├── RefElementwiseWorkload.hpp │ │ │ ├── RefFakeQuantizationFloat32Workload.cpp │ │ │ ├── RefFakeQuantizationFloat32Workload.hpp │ │ │ ├── RefFillWorkload.cpp │ │ │ ├── RefFillWorkload.hpp │ │ │ ├── RefFloorWorkload.cpp │ │ │ ├── RefFloorWorkload.hpp │ │ │ ├── RefFullyConnectedWorkload.cpp │ │ │ ├── RefFullyConnectedWorkload.hpp │ │ │ ├── RefGatherNdWorkload.cpp │ │ │ ├── RefGatherNdWorkload.hpp │ │ │ ├── RefGatherWorkload.cpp │ │ │ ├── RefGatherWorkload.hpp │ │ │ ├── RefInstanceNormalizationWorkload.cpp │ │ │ ├── RefInstanceNormalizationWorkload.hpp │ │ │ ├── RefL2NormalizationWorkload.cpp │ │ │ ├── RefL2NormalizationWorkload.hpp │ │ │ ├── RefLogSoftmaxWorkload.cpp │ │ │ ├── RefLogSoftmaxWorkload.hpp │ │ │ ├── RefLogicalBinaryWorkload.cpp │ │ │ ├── RefLogicalBinaryWorkload.hpp │ │ │ ├── RefLogicalUnaryWorkload.cpp │ │ │ ├── RefLogicalUnaryWorkload.hpp │ │ │ ├── RefLstmWorkload.cpp │ │ │ ├── RefLstmWorkload.hpp │ │ │ ├── RefMeanWorkload.cpp │ │ │ ├── RefMeanWorkload.hpp │ │ │ ├── RefNormalizationWorkload.cpp │ │ │ ├── RefNormalizationWorkload.hpp │ │ │ ├── RefPadWorkload.cpp │ │ │ ├── RefPadWorkload.hpp │ │ │ ├── RefPermuteWorkload.cpp │ │ │ ├── RefPermuteWorkload.hpp │ │ │ ├── RefPooling2dWorkload.cpp │ │ │ ├── RefPooling2dWorkload.hpp │ │ │ ├── RefPooling3dWorkload.cpp │ │ │ ├── RefPooling3dWorkload.hpp │ │ │ ├── RefPreluWorkload.cpp │ │ │ ├── RefPreluWorkload.hpp │ │ │ ├── RefQLstmWorkload.cpp │ │ │ ├── RefQLstmWorkload.hpp │ │ │ ├── RefQuantizeWorkload.cpp │ │ │ ├── RefQuantizeWorkload.hpp │ │ │ ├── RefRankWorkload.hpp │ │ │ ├── RefReduceWorkload.cpp │ │ │ ├── RefReduceWorkload.hpp │ │ │ ├── RefReshapeWorkload.cpp │ │ │ ├── RefReshapeWorkload.hpp │ │ │ ├── RefResizeWorkload.cpp │ │ │ ├── RefResizeWorkload.hpp │ │ │ ├── RefReverseV2Workload.cpp │ │ │ ├── RefReverseV2Workload.hpp │ │ │ ├── RefScatterNdWorkload.cpp │ │ │ ├── RefScatterNdWorkload.hpp │ │ │ ├── RefShapeWorkload.hpp │ │ │ ├── RefSliceWorkload.cpp │ │ │ ├── RefSliceWorkload.hpp │ │ │ ├── RefSoftmaxWorkload.cpp │ │ │ ├── RefSoftmaxWorkload.hpp │ │ │ ├── RefSpaceToBatchNdWorkload.cpp │ │ │ ├── RefSpaceToBatchNdWorkload.hpp │ │ │ ├── RefSpaceToDepthWorkload.cpp │ │ │ ├── RefSpaceToDepthWorkload.hpp │ │ │ ├── RefSplitterWorkload.cpp │ │ │ ├── RefSplitterWorkload.hpp │ │ │ ├── RefStackWorkload.cpp │ │ │ ├── RefStackWorkload.hpp │ │ │ ├── RefStridedSliceWorkload.cpp │ │ │ ├── RefStridedSliceWorkload.hpp │ │ │ ├── RefTileWorkload.cpp │ │ │ ├── RefTileWorkload.hpp │ │ │ ├── RefTransposeConvolution2dWorkload.cpp │ │ │ ├── RefTransposeConvolution2dWorkload.hpp │ │ │ ├── RefTransposeWorkload.cpp │ │ │ ├── RefTransposeWorkload.hpp │ │ │ ├── RefUnidirectionalSequenceLstmWorkload.cpp │ │ │ ├── RefUnidirectionalSequenceLstmWorkload.hpp │ │ │ ├── RefWorkloadUtils.hpp │ │ │ ├── RefWorkloads.hpp │ │ │ ├── Resize.cpp │ │ │ ├── Resize.hpp │ │ │ ├── ReverseV2Impl.cpp │ │ │ ├── ReverseV2Impl.hpp │ │ │ ├── Rsqrt.hpp │ │ │ ├── ScatterNd.cpp │ │ │ ├── ScatterNd.hpp │ │ │ ├── Sin.hpp │ │ │ ├── Slice.cpp │ │ │ ├── Slice.hpp │ │ │ ├── Softmax.cpp │ │ │ ├── Softmax.hpp │ │ │ ├── SpaceToBatchNd.cpp │ │ │ ├── SpaceToBatchNd.hpp │ │ │ ├── SpaceToDepth.cpp │ │ │ ├── SpaceToDepth.hpp │ │ │ ├── Splitter.cpp │ │ │ ├── Splitter.hpp │ │ │ ├── Sqrt.hpp │ │ │ ├── SquaredDifference.hpp │ │ │ ├── Stack.cpp │ │ │ ├── Stack.hpp │ │ │ ├── StridedSlice.cpp │ │ │ ├── StridedSlice.hpp │ │ │ ├── StringMapping.cpp │ │ │ ├── StringMapping.hpp │ │ │ ├── TensorBufferArrayView.hpp │ │ │ ├── Tile.cpp │ │ │ ├── Tile.hpp │ │ │ ├── TransposeConvolution2d.cpp │ │ │ └── TransposeConvolution2d.hpp │ ├── tosaCommon │ │ ├── CMakeLists.txt │ │ ├── TosaLayerSupportRules.hpp │ │ ├── TosaMappings.cpp │ │ ├── TosaMappings.hpp │ │ ├── common.cmake │ │ ├── operatorMappings │ │ │ ├── AvgPool2DIgnoreValueOperator.cpp │ │ │ ├── AvgPool2DIgnoreValueOperator.hpp │ │ │ ├── BatchMatMulOperator.cpp │ │ │ ├── BatchMatMulOperator.hpp │ │ │ ├── CMakeLists.txt │ │ │ ├── ConcatOperator.cpp │ │ │ ├── ConcatOperator.hpp │ │ │ ├── ConstantOperator.cpp │ │ │ ├── ConstantOperator.hpp │ │ │ ├── Conv2dOperator.cpp │ │ │ ├── Conv2dOperator.hpp │ │ │ ├── Conv3dOperator.cpp │ │ │ ├── Conv3dOperator.hpp │ │ │ ├── DepthToSpaceOperator.cpp │ │ │ ├── DepthToSpaceOperator.hpp │ │ │ ├── DepthwiseConv2dOperator.cpp │ │ │ ├── DepthwiseConv2dOperator.hpp │ │ │ ├── DequantizeOperator.cpp │ │ │ ├── DequantizeOperator.hpp │ │ │ ├── ElementwiseBinaryOperator.cpp │ │ │ ├── ElementwiseBinaryOperator.hpp │ │ │ ├── ExpOperator.cpp │ │ │ ├── ExpOperator.hpp │ │ │ ├── FullyConnectedOperator.cpp │ │ │ ├── FullyConnectedOperator.hpp │ │ │ ├── GatherOperator.cpp │ │ │ ├── GatherOperator.hpp │ │ │ ├── GeluOperator.cpp │ │ │ ├── GeluOperator.hpp │ │ │ ├── HardSwishOperator.cpp │ │ │ ├── HardSwishOperator.hpp │ │ │ ├── LeakyReluOperator.cpp │ │ │ ├── LeakyReluOperator.hpp │ │ │ ├── LogOperator.cpp │ │ │ ├── LogOperator.hpp │ │ │ ├── PadOperator.cpp │ │ │ ├── PadOperator.hpp │ │ │ ├── Pooling2DOperator.cpp │ │ │ ├── Pooling2DOperator.hpp │ │ │ ├── QuantizeOperator.cpp │ │ │ ├── QuantizeOperator.hpp │ │ │ ├── ReduceOperator.cpp │ │ │ ├── ReduceOperator.hpp │ │ │ ├── ReluOperator.cpp │ │ │ ├── ReluOperator.hpp │ │ │ ├── ReshapeOperator.cpp │ │ │ ├── ReshapeOperator.hpp │ │ │ ├── ResizeOperator.cpp │ │ │ ├── ResizeOperator.hpp │ │ │ ├── RsqrtOperator.cpp │ │ │ ├── RsqrtOperator.hpp │ │ │ ├── SigmoidOperator.cpp │ │ │ ├── SigmoidOperator.hpp │ │ │ ├── SliceOperator.cpp │ │ │ ├── SliceOperator.hpp │ │ │ ├── SoftmaxOperator.cpp │ │ │ ├── SoftmaxOperator.hpp │ │ │ ├── SplitOperator.cpp │ │ │ ├── SplitOperator.hpp │ │ │ ├── StackOperator.cpp │ │ │ ├── StackOperator.hpp │ │ │ ├── StridedSliceOperator.cpp │ │ │ ├── StridedSliceOperator.hpp │ │ │ ├── TanhOperator.cpp │ │ │ ├── TanhOperator.hpp │ │ │ ├── TosaCommonOperators.hpp │ │ │ ├── TosaOperatorUtils.hpp │ │ │ ├── TosaRescaleOperatorUtils.hpp │ │ │ ├── TosaSoftmaxOperatorUtils.hpp │ │ │ ├── TosaTableUtils.hpp │ │ │ ├── TransposeConv2dOperator.cpp │ │ │ ├── TransposeConv2dOperator.hpp │ │ │ ├── TransposeOperator.cpp │ │ │ └── TransposeOperator.hpp │ │ └── test │ │ │ ├── AvgPool2DIgnoreValueChecker.hpp │ │ │ ├── CMakeLists.txt │ │ │ ├── FullyConnectedChecker.hpp │ │ │ ├── OneToManyMappingTests.cpp │ │ │ ├── OneToOneMappingTests.cpp │ │ │ ├── QuantizeChecker.hpp │ │ │ ├── SoftmaxChecker.hpp │ │ │ ├── SplitChecker.hpp │ │ │ └── TosaTestUtils.hpp │ └── tosaReference │ │ ├── CMakeLists.txt │ │ ├── TosaRefBackend.cpp │ │ ├── TosaRefBackend.hpp │ │ ├── TosaRefBackendId.hpp │ │ ├── TosaRefLayerSupport.cpp │ │ ├── TosaRefLayerSupport.hpp │ │ ├── TosaRefMemoryManager.cpp │ │ ├── TosaRefMemoryManager.hpp │ │ ├── TosaRefRegistryInitializer.cpp │ │ ├── TosaRefTensorHandle.cpp │ │ ├── TosaRefTensorHandle.hpp │ │ ├── TosaRefTensorHandleFactory.cpp │ │ ├── TosaRefTensorHandleFactory.hpp │ │ ├── TosaRefWorkloadFactory.cpp │ │ ├── TosaRefWorkloadFactory.hpp │ │ ├── backend.cmake │ │ ├── backend.mk │ │ ├── test │ │ ├── CMakeLists.txt │ │ ├── TosaRefEndToEndTests.cpp │ │ ├── TosaRefLayerSupportTests.cpp │ │ ├── TosaRefLayerTests.cpp │ │ ├── TosaRefOptimizedNetworkTests.cpp │ │ └── TosaRefWorkloadFactoryHelper.hpp │ │ └── workloads │ │ ├── CMakeLists.txt │ │ ├── TosaRefBaseWorkload.hpp │ │ ├── TosaRefPreCompiledWorkload.cpp │ │ ├── TosaRefPreCompiledWorkload.hpp │ │ └── TosaRefWorkloads.hpp ├── dynamic │ ├── README.md │ ├── README.md.license │ └── sample │ │ ├── CMakeLists.txt │ │ ├── SampleDynamicAdditionWorkload.cpp │ │ ├── SampleDynamicAdditionWorkload.hpp │ │ ├── SampleDynamicBackend.cpp │ │ ├── SampleDynamicBackend.hpp │ │ ├── SampleDynamicLayerSupport.cpp │ │ ├── SampleDynamicLayerSupport.hpp │ │ ├── SampleDynamicTensorHandleFactory.cpp │ │ ├── SampleDynamicTensorHandleFactory.hpp │ │ ├── SampleDynamicWorkloadFactory.cpp │ │ ├── SampleDynamicWorkloadFactory.hpp │ │ ├── SampleMemoryManager.cpp │ │ ├── SampleMemoryManager.hpp │ │ ├── SampleTensorHandle.cpp │ │ └── SampleTensorHandle.hpp ├── profiling │ └── test │ │ ├── BufferTests.cpp │ │ ├── FileOnlyProfilingDecoratorTests.cpp │ │ ├── PrintPacketHeaderHandler.cpp │ │ ├── PrintPacketHeaderHandler.hpp │ │ ├── ProfilingConnectionDumpToFileDecoratorTests.cpp │ │ ├── ProfilingGuidTest.cpp │ │ ├── ProfilingMocks.hpp │ │ ├── ProfilingTestUtils.cpp │ │ ├── ProfilingTestUtils.hpp │ │ ├── ProfilingTests.cpp │ │ ├── ProfilingTests.hpp │ │ ├── RequestCountersPacketHandler.cpp │ │ ├── RequestCountersPacketHandler.hpp │ │ ├── SendCounterPacketTests.cpp │ │ ├── SendCounterPacketTests.hpp │ │ ├── SendTimelinePacketTests.cpp │ │ ├── TestTimelinePacketHandler.cpp │ │ ├── TestTimelinePacketHandler.hpp │ │ ├── TimelineModel.cpp │ │ ├── TimelineModel.hpp │ │ ├── TimelinePacketTests.cpp │ │ └── TimelineUtilityMethodsTests.cpp └── timelineDecoder │ ├── CMakeLists.txt │ ├── JSONTimelineDecoder.cpp │ ├── JSONTimelineDecoder.hpp │ └── tests │ └── JSONTimelineDecoderTests.cpp ├── tests ├── CMakeLists.txt ├── Cifar10Database.cpp ├── Cifar10Database.hpp ├── ClassifierTestCaseData.hpp ├── CxxoptsUtils.hpp ├── DeepSpeechV1Database.hpp ├── DeepSpeechV1InferenceTest.hpp ├── ExecuteNetwork │ ├── ArmNNExecutor.cpp │ ├── ArmNNExecutor.hpp │ ├── ExecuteNetwork.cpp │ ├── ExecuteNetworkParams.cpp │ ├── ExecuteNetworkParams.hpp │ ├── ExecuteNetworkProgramOptions.cpp │ ├── ExecuteNetworkProgramOptions.hpp │ ├── FileComparisonExecutor.cpp │ ├── FileComparisonExecutor.hpp │ ├── IExecutor.hpp │ ├── TfliteExecutor.cpp │ ├── TfliteExecutor.hpp │ ├── evaluate_network.md │ ├── evaluate_network.md.license │ ├── evaluate_network.sh │ └── test │ │ └── FileComparisonExecutorTests.cpp ├── ImageCSVFileGenerator │ ├── ImageCSVFileGenerator.cpp │ ├── README.md │ └── README.md.license ├── ImagePreprocessor.cpp ├── ImagePreprocessor.hpp ├── ImageTensorGenerator │ ├── ImageTensorGenerator.cpp │ ├── ImageTensorGenerator.hpp │ ├── README.md │ └── README.md.license ├── InferenceModel.hpp ├── InferenceTest.cpp ├── InferenceTest.hpp ├── InferenceTest.inl ├── InferenceTestImage.cpp ├── InferenceTestImage.hpp ├── InterfaceTests │ ├── CMakeLists.txt │ ├── ClassicDelegateTest.cpp │ ├── OnnxParserTest.cpp │ ├── OpaqueDelegateTest.cpp │ ├── README.md │ ├── README.md.license │ ├── TfLiteParserTest.cpp │ ├── simple_conv2d_1_op.tflite │ └── simple_conv2d_1_op.tflite.license ├── LstmCommon.hpp ├── MemoryStrategyBenchmark │ ├── CMakeLists.txt │ ├── MemoryStrategyBenchmark.cpp │ ├── TestBlocks.hpp │ ├── TestStrategy.cpp │ └── TestStrategy.hpp ├── MnistDatabase.cpp ├── MnistDatabase.hpp ├── MobileNetSsdDatabase.hpp ├── MobileNetSsdInferenceTest.hpp ├── ModelAccuracyTool-Armnn │ ├── ModelAccuracyTool-Armnn.cpp │ ├── README.md │ └── README.md.license ├── MultipleNetworksCifar10 │ └── MultipleNetworksCifar10.cpp ├── NetworkExecutionUtils │ ├── NetworkExecutionUtils.cpp │ ├── NetworkExecutionUtils.hpp │ └── test │ │ └── NetworkExecutionUtilsTests.cpp ├── ObjectDetectionCommon.hpp ├── OnnxMnist-Armnn │ ├── OnnxMnist-Armnn.cpp │ ├── Validation.txt │ └── Validation.txt.license ├── OnnxMobileNet-Armnn │ ├── OnnxMobileNet-Armnn.cpp │ ├── Validation.txt │ ├── Validation.txt.license │ ├── labels.txt │ └── labels.txt.license ├── TfLiteBenchmark-Armnn │ └── TfLiteBenchmark-Armnn.cpp ├── TfLiteInceptionV3Quantized-Armnn │ ├── TfLiteInceptionV3Quantized-Armnn.cpp │ ├── Validation.txt │ └── Validation.txt.license ├── TfLiteInceptionV4Quantized-Armnn │ ├── TfLiteInceptionV4Quantized-Armnn.cpp │ ├── Validation.txt │ └── Validation.txt.license ├── TfLiteMnasNet-Armnn │ └── TfLiteMnasNet-Armnn.cpp ├── TfLiteMobileNetQuantizedSoftmax-Armnn │ ├── TfLiteMobileNetQuantizedSoftmax-Armnn.cpp │ ├── Validation.txt │ └── Validation.txt.license ├── TfLiteMobileNetSsd-Armnn │ └── TfLiteMobileNetSsd-Armnn.cpp ├── TfLiteMobilenetQuantized-Armnn │ ├── TfLiteMobilenetQuantized-Armnn.cpp │ ├── Validation.txt │ ├── Validation.txt.license │ ├── labels.txt │ └── labels.txt.license ├── TfLiteMobilenetV2Quantized-Armnn │ └── TfLiteMobilenetV2Quantized-Armnn.cpp ├── TfLiteResNetV2-50-Quantized-Armnn │ └── TfLiteResNetV2-50-Quantized-Armnn.cpp ├── TfLiteResNetV2-Armnn │ └── TfLiteResNetV2-Armnn.cpp ├── TfLiteVGG16Quantized-Armnn │ ├── TfLiteVGG16Quantized-Armnn.cpp │ ├── Validation.txt │ └── Validation.txt.license ├── TfLiteYoloV3Big-Armnn │ ├── NMS.cpp │ ├── NMS.hpp │ └── TfLiteYoloV3Big-Armnn.cpp ├── YoloDatabase.cpp ├── YoloDatabase.hpp ├── YoloInferenceTest.hpp └── profiling │ └── gatordmock │ ├── CommandFileParser.cpp │ ├── CommandFileParser.hpp │ ├── CommandLineProcessor.cpp │ ├── CommandLineProcessor.hpp │ ├── CounterDirectory.hpp │ ├── GatordMockMain.cpp │ ├── GatordMockService.cpp │ ├── GatordMockService.hpp │ ├── PeriodicCounterCaptureCommandHandler.cpp │ ├── PeriodicCounterCaptureCommandHandler.hpp │ ├── PeriodicCounterSelectionResponseHandler.cpp │ ├── PeriodicCounterSelectionResponseHandler.hpp │ ├── StreamMetadataCommandHandler.cpp │ ├── StreamMetadataCommandHandler.hpp │ ├── StubCommandHandler.hpp │ └── tests │ └── GatordMockTests.cpp └── third-party ├── REUSE.toml ├── cxxopts ├── CHANGELOG.md ├── CHANGELOG.md.license ├── LICENSE ├── LICENSE.spdx ├── README.md ├── README.md.license └── cxxopts.hpp ├── doctest ├── LICENSE.spdx ├── LICENSE.txt └── doctest.h ├── fmt ├── CMakeLists.txt ├── LICENSE.rst ├── LICENSE.spdx ├── README.rst ├── README.rst.license ├── core.h ├── format-inl.h ├── format.h └── src │ └── format.cc ├── gemmlowp ├── AUTHORS ├── LICENSE ├── LICENSE.spdx ├── README.md ├── fixedpoint.h ├── fixedpoint_avx.h ├── fixedpoint_msa.h ├── fixedpoint_neon.h ├── fixedpoint_sse.h ├── fixedpoint_wasmsimd.h └── internal │ └── detect_platform.h ├── ghc ├── LICENSE ├── LICENSE.spdx ├── README.md ├── README.md.license └── filesystem.hpp ├── half ├── ChangeLog.txt ├── ChangeLog.txt.license ├── LICENSE.spdx ├── LICENSE.txt ├── README.txt ├── README.txt.license └── half.hpp ├── mapbox ├── LICENSE ├── LICENSE.spdx ├── LICENSE_1_0.txt ├── LICENSE_1_0.txt.license ├── README.md ├── README.md.license ├── optional.hpp ├── recursive_wrapper.hpp ├── variant.hpp ├── variant_cast.hpp ├── variant_io.hpp └── variant_visitor.hpp └── stb ├── LICENSE ├── LICENSE.spdx ├── stb_image.h ├── stb_image_resize.h └── stb_image_write.h /.clang-format.license: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright © 2021 Arm Ltd and Contributors. 3 | # SPDX-License-Identifier: MIT 4 | # 5 | -------------------------------------------------------------------------------- /AUTHORS-TensorFlow: -------------------------------------------------------------------------------- 1 | # This is the official list of TensorFlow authors for copyright purposes. 2 | # This file is distinct from the CONTRIBUTORS files. 3 | # See the latter for an explanation. 4 | 5 | # Names should be added to this file as: 6 | # Name or Organization 7 | # The email address is not required for organizations. 8 | 9 | Google Inc. 10 | Yuan Tang 11 | Arm Ltd -------------------------------------------------------------------------------- /AUTHORS-TensorFlow.license: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright 2015, 2016-2017, 2022 The TensorFlow Authors. All Rights Reserved. 3 | # SPDX-License-Identifier: Apache-2.0 4 | # 5 | -------------------------------------------------------------------------------- /Android.bp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017 ARM Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | // Dummy Android.bp file to keep backward compatibility with previous 7 | // build systems/environments. 8 | 9 | -------------------------------------------------------------------------------- /Arm_NN_horizontal_blue.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ARM-software/armnn/e1ec5b81cf484f50dd50b480a8c16213edaff5e3/Arm_NN_horizontal_blue.png -------------------------------------------------------------------------------- /Arm_NN_horizontal_blue.png.license: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright © 2022 Arm Ltd and Contributors. All rights reserved. 3 | # SPDX-License-Identifier: MIT 4 | # 5 | -------------------------------------------------------------------------------- /BuildGuideAndroidNDK.md.license: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright © 2018-2022 Arm Ltd and Contributors. All rights reserved. 3 | # SPDX-License-Identifier: MIT 4 | # 5 | -------------------------------------------------------------------------------- /CONTRIBUTING.md.license: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright © 2018-2022 Arm Ltd and Contributors. All rights reserved. 3 | # SPDX-License-Identifier: MIT 4 | # 5 | -------------------------------------------------------------------------------- /InstallationViaAptRepository.md.license: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright © 2020-2022 Arm Ltd and Contributors. All rights reserved. 3 | # SPDX-License-Identifier: MIT 4 | # 5 | -------------------------------------------------------------------------------- /README.md.license: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright © 2018-2022 Arm Ltd and Contributors. All rights reserved. 3 | # SPDX-License-Identifier: MIT 4 | # 5 | -------------------------------------------------------------------------------- /SECURITY.md.license: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright © 2020 Arm Ltd and Contributors. All rights reserved. 3 | # SPDX-License-Identifier: MIT 4 | # 5 | -------------------------------------------------------------------------------- /build-tool/README.md.license: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright © 2022 Arm Ltd and Contributors. All rights reserved. 3 | # SPDX-License-Identifier: MIT 4 | # 5 | -------------------------------------------------------------------------------- /build-tool/dockerfile_armnn.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ARM-software/armnn/e1ec5b81cf484f50dd50b480a8c16213edaff5e3/build-tool/dockerfile_armnn.png -------------------------------------------------------------------------------- /build-tool/dockerfile_armnn.png.license: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright © 2022 Arm Ltd and Contributors. All rights reserved. 3 | # SPDX-License-Identifier: MIT 4 | # 5 | -------------------------------------------------------------------------------- /cmake/ArmnnConfig.cmake.in: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright © 2020 Arm Ltd and Contributors. All rights reserved. 3 | # SPDX-License-Identifier: MIT 4 | # 5 | 6 | get_filename_component(ARMNN_CMAKE_DIR "${CMAKE_CURRENT_LIST_FILE}" DIRECTORY) 7 | set(ARMNN_CONFIG_FILE ${CMAKE_CURRENT_LIST_FILE}) 8 | MESSAGE(STATUS "Found Armnn: ${ARMNN_CONFIG_FILE}") 9 | 10 | include(CMakeFindDependencyMacro) 11 | 12 | list(APPEND CMAKE_MODULE_PATH ${ARMNN_CMAKE_DIR}) 13 | 14 | if(NOT TARGET Armnn::Armnn) 15 | MESSAGE(STATUS "Armnn Import: ${ARMNN_CMAKE_DIR}/ArmnnTargets.cmake") 16 | include("${ARMNN_CMAKE_DIR}/ArmnnTargets.cmake") 17 | endif() 18 | 19 | set(ARMNN_LIBRARIES Armnn::Armnn) -------------------------------------------------------------------------------- /cmake/ArmnnVersion.cmake: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright © 2019 Arm Ltd. All rights reserved. 3 | # SPDX-License-Identifier: MIT 4 | # 5 | 6 | # Read the ArmNN version components from file 7 | file(READ ${CMAKE_CURRENT_LIST_DIR}/../include/armnn/Version.hpp armnnVersion) 8 | 9 | # Parse the ArmNN version components 10 | string(REGEX MATCH "#define ARMNN_MAJOR_VERSION ([0-9]*)" _ ${armnnVersion}) 11 | set(ARMNN_MAJOR_VERSION ${CMAKE_MATCH_1}) 12 | string(REGEX MATCH "#define ARMNN_MINOR_VERSION ([0-9]*)" _ ${armnnVersion}) 13 | set(ARMNN_MINOR_VERSION ${CMAKE_MATCH_1}) 14 | 15 | # Define LIB version 16 | set(GENERIC_LIB_VERSION "${ARMNN_MAJOR_VERSION}.${ARMNN_MINOR_VERSION}") 17 | 18 | # Define LIB soversion 19 | set(GENERIC_LIB_SOVERSION "${ARMNN_MAJOR_VERSION}") 20 | -------------------------------------------------------------------------------- /cmake/ClassicDelegateVersion.cmake: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright © 2021,2023 Arm Ltd and Contributors. All rights reserved. 3 | # SPDX-License-Identifier: MIT 4 | # 5 | 6 | # Read the ArmNN Delegate version components from file 7 | file(READ ${CMAKE_CURRENT_LIST_DIR}/../delegate/classic/include/Version.hpp ClassicDelegateVersion) 8 | 9 | # Parse the ArmNN Delegate version components 10 | string(REGEX MATCH "#define DELEGATE_MAJOR_VERSION ([0-9]*)" _ ${ClassicDelegateVersion}) 11 | set(DELEGATE_MAJOR_VERSION ${CMAKE_MATCH_1}) 12 | string(REGEX MATCH "#define DELEGATE_MINOR_VERSION ([0-9]*)" _ ${ClassicDelegateVersion}) 13 | set(DELEGATE_MINOR_VERSION ${CMAKE_MATCH_1}) 14 | 15 | # Define LIB version 16 | set(DELEGATE_LIB_VERSION "${DELEGATE_MAJOR_VERSION}.${DELEGATE_MINOR_VERSION}") 17 | # Define LIB soversion 18 | set(DELEGATE_LIB_SOVERSION "${DELEGATE_MAJOR_VERSION}") -------------------------------------------------------------------------------- /delegate/BuildGuideNative.md.license: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright © 2020-2022 Arm Ltd and Contributors. All rights reserved. 3 | # SPDX-License-Identifier: MIT 4 | # 5 | -------------------------------------------------------------------------------- /delegate/DelegateQuickStartGuide.md.license: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright © 2020, 2022 Arm Ltd and Contributors. All rights reserved. 3 | # SPDX-License-Identifier: MIT 4 | # 5 | -------------------------------------------------------------------------------- /delegate/README.md: -------------------------------------------------------------------------------- 1 | # The Arm NN TensorFlow Lite delegate 2 | 3 | 'armnnDelegate' is a library for accelerating certain TensorFlow Lite operators on Arm hardware by providing 4 | the TensorFlow Lite interpreter with an alternative implementation of the operators via its delegation mechanism. 5 | 6 | For more information, like a list of supported operators, please visit our [doxygen documentation](https://arm-software.github.io/armnn/latest/delegate.html). 7 | -------------------------------------------------------------------------------- /delegate/README.md.license: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright © 2020-2021 Arm Ltd and Contributors. All rights reserved. 3 | # SPDX-License-Identifier: MIT 4 | # 5 | -------------------------------------------------------------------------------- /delegate/armnnDelegateJNI/README.md: -------------------------------------------------------------------------------- 1 | # The Arm NN TensorFlow Lite delegate JNI (Experimental) 2 | 3 | NOTE: This library is an experimental feature. We cannot guarentee full support for this. 4 | 5 | It requires a static build which can be switched on through setting BUILD_SHARED_LIBS=OFF. You will also have to set 6 | CMAKE_ANDROID_STL_TYPE=c++_static when building ArmNN. 7 | 8 | BUILD_DELEGATE_JNI_INTERFACE will also have to be set to true. 9 | -------------------------------------------------------------------------------- /delegate/armnnDelegateJNI/README.md.license: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright © 2022 ARM Ltd and Contributors. All rights reserved. 3 | # SPDX-License-Identifier: MIT 4 | # -------------------------------------------------------------------------------- /delegate/armnnDelegateJNI/version_script: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright © 2022 Arm Ltd and Contributors. All rights reserved. 3 | SPDX-License-Identifier: MIT 4 | */ 5 | 6 | LIBARMNN_DELEGATE_JNI { 7 | global: 8 | Java_com_arm_armnn_delegate_ArmnnDelegate_createDelegate; 9 | Java_com_arm_armnn_delegate_ArmnnDelegate_deleteDelegate; 10 | Java_com_arm_armnn_delegate_ArmnnUtils_IsGpuAccSupported; 11 | Java_com_arm_armnn_delegate_ArmnnUtils_IsNeonDetected; 12 | local: 13 | *; 14 | 15 | }; -------------------------------------------------------------------------------- /delegate/include/DelegateOptions.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2020-2023 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #include 7 | #pragma message("armnn/delegate/include/DelegateOptions.hpp has been deprecated, it is due for removal in"\ 8 | " 24.02 release. Please include armnn/delegate/common/include/DelegateOptions.hpp instead.") 9 | -------------------------------------------------------------------------------- /delegate/include/Version.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2021-2023 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #include 7 | #pragma message("armnn/delegate/include/Version.hpp has been deprecated, it is due for removal in"\ 8 | " 24.02 release. Please include armnn/delegate/classic/include/Version.hpp instead.") 9 | -------------------------------------------------------------------------------- /delegate/include/armnn_delegate.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2020-2023 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #include 7 | #pragma message("armnn/delegate/include/armnn_delegate.hpp has been deprecated, it is due for removal in"\ 8 | " 24.02 release. Please include armnn/delegate/classic/include/armnn_delegate.hpp instead.") 9 | -------------------------------------------------------------------------------- /delegate/python/test/pytest.ini: -------------------------------------------------------------------------------- 1 | # Copyright © 2020 Arm Ltd and Contributors. All rights reserved. 2 | # SPDX-License-Identifier: MIT 3 | 4 | [pytest] 5 | addopts = --strict-markers 6 | markers = 7 | CpuRefTest: marks tests that require the CpuRef backend 8 | CpuAccTest: marks tests that require the CpuAcc backend 9 | GpuAccTest: marks tests that require the GpuAcc backend -------------------------------------------------------------------------------- /delegate/python/test/test_data/conv2d.tflite: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ARM-software/armnn/e1ec5b81cf484f50dd50b480a8c16213edaff5e3/delegate/python/test/test_data/conv2d.tflite -------------------------------------------------------------------------------- /delegate/python/test/test_data/conv2d.tflite.license: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright © 2021 Arm Ltd and Contributors. All rights reserved. 3 | # SPDX-License-Identifier: MIT 4 | # 5 | -------------------------------------------------------------------------------- /delegate/python/test/test_data/fallback_model.tflite: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ARM-software/armnn/e1ec5b81cf484f50dd50b480a8c16213edaff5e3/delegate/python/test/test_data/fallback_model.tflite -------------------------------------------------------------------------------- /delegate/python/test/test_data/fallback_model.tflite.license: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright © 2021 Arm Ltd and Contributors. All rights reserved. 3 | # SPDX-License-Identifier: MIT 4 | # 5 | -------------------------------------------------------------------------------- /delegate/python/test/test_data/fp32_model.tflite: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ARM-software/armnn/e1ec5b81cf484f50dd50b480a8c16213edaff5e3/delegate/python/test/test_data/fp32_model.tflite -------------------------------------------------------------------------------- /delegate/python/test/test_data/fp32_model.tflite.license: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright © 2021 Arm Ltd and Contributors. All rights reserved. 3 | # SPDX-License-Identifier: MIT 4 | # 5 | -------------------------------------------------------------------------------- /delegate/python/test/test_data/mock_model.tflite: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ARM-software/armnn/e1ec5b81cf484f50dd50b480a8c16213edaff5e3/delegate/python/test/test_data/mock_model.tflite -------------------------------------------------------------------------------- /delegate/python/test/test_data/mock_model.tflite.license: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright © 2020 Arm Ltd and Contributors. All rights reserved. 3 | # SPDX-License-Identifier: MIT 4 | # 5 | -------------------------------------------------------------------------------- /delegate/test/NormalizationTest.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2021, 2023-2024 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #include "NormalizationTestHelper.hpp" 7 | 8 | #include 9 | 10 | namespace armnnDelegate 11 | { 12 | 13 | TEST_SUITE("L2NormalizationTests") 14 | { 15 | 16 | TEST_CASE ("L2NormalizationFp32Test_Test") 17 | { 18 | L2NormalizationTest(); 19 | } 20 | 21 | } // TEST_SUITE("L2NormalizationTests") 22 | 23 | TEST_SUITE("LocalResponseNormalizationTests") 24 | { 25 | 26 | TEST_CASE ("LocalResponseNormalizationTest_Test") 27 | { 28 | LocalResponseNormalizationTest(3, 1.f, 1.f, 1.f); 29 | } 30 | 31 | } // TEST_SUITE("LocalResponseNormalizationTests") 32 | 33 | } // namespace armnnDelegate -------------------------------------------------------------------------------- /docker/README.md: -------------------------------------------------------------------------------- 1 | # ARMNN Docker Files 2 | 3 | A productized Arm NN Docker solution has been released as part of our new Arm NN Build Tool which can be found at this link on our GitHub website: https://github.com/ARM-software/armnn/tree/HEAD/build-tool 4 | 5 | 6 | 7 | -------------------------------------------------------------------------------- /docker/README.md.license: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright © 2021-2022 Arm Ltd and Contributors. All rights reserved. 3 | # SPDX-License-Identifier: MIT 4 | # 5 | -------------------------------------------------------------------------------- /docs/01_00_quick_start.dox: -------------------------------------------------------------------------------- 1 | /// Copyright (c) 2021 ARM Limited and Contributors. All rights reserved. 2 | /// 3 | /// SPDX-License-Identifier: MIT 4 | /// 5 | 6 | namespace armnn 7 | { 8 | /** 9 | @page quickstart Quick Start Guide 10 | 11 | On this page you can find guides which allow you to get setup and ready to run models with Arm NN quickly. 12 | These guides rely on using the apt packages or prebuilt binaries from our release notes. We only have added a quick start guide that uses TfLite-Delegate. 13 | More guides will be added in the future. 14 | 15 | - @subpage md_delegate_DelegateQuickStartGuide 16 | **/ 17 | } 18 | 19 | namespace armnn 20 | { 21 | /** 22 | 23 | @page md_delegate_DelegateQuickStartGuide TfLite Delegate Quick Start Guide 24 | **/ 25 | } 26 | -------------------------------------------------------------------------------- /docs/Arm_NN_horizontal_blue.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ARM-software/armnn/e1ec5b81cf484f50dd50b480a8c16213edaff5e3/docs/Arm_NN_horizontal_blue.png -------------------------------------------------------------------------------- /docs/Arm_NN_horizontal_blue.png.license: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright © 2020 Arm Ltd and Contributors. All rights reserved. 3 | # SPDX-License-Identifier: MIT 4 | # 5 | -------------------------------------------------------------------------------- /docs/FAQ.md.license: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright © 2020-2022 Arm Ltd and Contributors. All rights reserved. 3 | # SPDX-License-Identifier: MIT 4 | # 5 | -------------------------------------------------------------------------------- /docs/design/EthosN_NPU-GPU_ZeroCopyFallbackDesignDocument.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ARM-software/armnn/e1ec5b81cf484f50dd50b480a8c16213edaff5e3/docs/design/EthosN_NPU-GPU_ZeroCopyFallbackDesignDocument.pdf -------------------------------------------------------------------------------- /docs/design/EthosN_NPU-GPU_ZeroCopyFallbackDesignDocument.pdf.license: -------------------------------------------------------------------------------- 1 | # 2 | # SPDX-FileCopyrightText: Copyright © 2023-2024 ARM Ltd and Contributors. 3 | # SPDX-License-Identifier: MIT 4 | # -------------------------------------------------------------------------------- /docs/design/README.md: -------------------------------------------------------------------------------- 1 | # Design Documents 2 | 3 | This subdirectory has been created to hold design documents for features that the Arm NN project has decided NOT to implement. They are provided for information only. Note that users raising queries on the contents or seeking support for developing code on the basis of the designs here will only receive the amount of engineering resource that we would deploy on any general query coming into our support lists. -------------------------------------------------------------------------------- /docs/design/README.md.license: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright © 2024 Arm Ltd and Contributors. 3 | # SPDX-License-Identifier: MIT 4 | # 5 | -------------------------------------------------------------------------------- /include/armnn/ArmNN.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | #pragma once 6 | 7 | #include "BackendId.hpp" 8 | #include "BackendHelper.hpp" 9 | #include "Descriptors.hpp" 10 | #include "Exceptions.hpp" 11 | #include "INetwork.hpp" 12 | #include "IRuntime.hpp" 13 | #include "LstmParams.hpp" 14 | #include "Optional.hpp" 15 | #include "QuantizedLstmParams.hpp" 16 | #include "Tensor.hpp" 17 | #include "Types.hpp" 18 | #include "TypesUtils.hpp" 19 | #include "Utils.hpp" 20 | #include "Version.hpp" 21 | -------------------------------------------------------------------------------- /include/armnn/NetworkFwd.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | #pragma once 6 | 7 | namespace armnn 8 | { 9 | 10 | struct LstmInputParams; 11 | struct QuantizedLstmInputParams; 12 | 13 | class INetwork; 14 | class IOptimizedNetwork; 15 | class Graph; 16 | class IInputSlot; 17 | class IOutputSlot; 18 | class IConnectableLayer; 19 | class IDataLayer; 20 | 21 | } // end armnn namespace 22 | -------------------------------------------------------------------------------- /include/armnn/TensorFwd.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | #pragma once 6 | 7 | namespace armnn 8 | { 9 | 10 | class TensorShape; 11 | class TensorInfo; 12 | class Tensor; 13 | class ConstTensor; 14 | 15 | } 16 | -------------------------------------------------------------------------------- /include/armnn/Version.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017-2025 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | /// Macro utils 9 | #define STRINGIFY_VALUE(s) STRINGIFY_MACRO(s) 10 | #define STRINGIFY_MACRO(s) #s 11 | 12 | // ArmNN version components 13 | #define ARMNN_MAJOR_VERSION 35 14 | #define ARMNN_MINOR_VERSION 0 15 | #define ARMNN_PATCH_VERSION 0 16 | 17 | /// ARMNN_VERSION: "X.Y.Z" 18 | /// where: 19 | /// X = Major version number 20 | /// Y = Minor version number 21 | /// Z = Patch version number 22 | #define ARMNN_VERSION STRINGIFY_VALUE(ARMNN_MAJOR_VERSION) "." \ 23 | STRINGIFY_VALUE(ARMNN_MINOR_VERSION) "." \ 24 | STRINGIFY_VALUE(ARMNN_PATCH_VERSION) 25 | -------------------------------------------------------------------------------- /include/armnn/backends/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright © 2019 Arm Ltd. All rights reserved. 3 | # SPDX-License-Identifier: MIT 4 | # 5 | 6 | list(APPEND armnnBackendsAPI_sources 7 | TensorHandleFwd.hpp 8 | DynamicBackend.hpp 9 | IBackendInternal.hpp 10 | IBackendContext.hpp 11 | IMemoryManager.hpp 12 | IMemoryOptimizerStrategy.hpp 13 | ITensorHandle.hpp 14 | ITensorHandleFactory.hpp 15 | IWorkload.hpp 16 | OptimizationViews.hpp 17 | WorkloadInfo.hpp 18 | profiling/IBackendProfiling.hpp 19 | profiling/IBackendProfilingContext.hpp 20 | ) 21 | 22 | add_library(armnnBackendsAPI OBJECT ${armnnBackendsAPI_sources}) 23 | -------------------------------------------------------------------------------- /include/armnn/backends/IMemoryManager.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | #pragma once 6 | 7 | #include 8 | 9 | namespace armnn 10 | { 11 | 12 | class IMemoryManager 13 | { 14 | protected: 15 | IMemoryManager() {} 16 | 17 | public: 18 | virtual void Acquire() = 0; 19 | virtual void Release() = 0; 20 | 21 | virtual ~IMemoryManager() {} 22 | }; 23 | 24 | using IMemoryManagerUniquePtr = std::unique_ptr; 25 | 26 | } // namespace armnn -------------------------------------------------------------------------------- /include/armnn/backends/MemCopyWorkload.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2022, 2024 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | #pragma once 6 | 7 | #include "TensorHandle.hpp" 8 | #include "Workload.hpp" 9 | 10 | #include 11 | 12 | namespace armnn 13 | { 14 | 15 | class CopyMemGenericWorkload : public BaseWorkload 16 | { 17 | public: 18 | CopyMemGenericWorkload(const MemCopyQueueDescriptor& descriptor, const WorkloadInfo& info); 19 | void Execute() const override; 20 | 21 | private: 22 | using TensorHandlePair = std::pair; 23 | std::vector m_TensorHandlePairs; 24 | }; 25 | 26 | } //namespace armnn 27 | -------------------------------------------------------------------------------- /include/armnn/backends/TensorHandleFwd.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2021 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | namespace armnn 9 | { 10 | 11 | class ConstTensorHandle; 12 | class TensorHandle; 13 | class ScopedTensorHandle; 14 | class PassthroughTensorHandle; 15 | class ConstPassthroughTensorHandle; 16 | 17 | } // namespace armnn 18 | -------------------------------------------------------------------------------- /include/armnn/utility/Assert.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2020 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include 9 | 10 | namespace armnn 11 | { 12 | 13 | #ifndef NDEBUG 14 | # define ARMNN_ASSERT(COND) assert(COND) 15 | # define ARMNN_ASSERT_MSG(COND, MSG) assert((COND) && MSG) 16 | #else 17 | # define ARMNN_ASSERT(COND) 18 | # define ARMNN_ASSERT_MSG(COND, MSG) 19 | #endif 20 | 21 | } //namespace armnn -------------------------------------------------------------------------------- /include/armnn/utility/IgnoreUnused.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2020 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | namespace armnn 9 | { 10 | 11 | // Utility function to selectively silence unused variable compiler warnings 12 | 13 | template 14 | inline void IgnoreUnused(Ts&&...){} 15 | 16 | } //namespace armnn -------------------------------------------------------------------------------- /include/armnn/utility/Timer.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2020 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include 9 | #include 10 | 11 | namespace armnn 12 | { 13 | 14 | inline std::chrono::high_resolution_clock::time_point GetTimeNow() 15 | { 16 | return std::chrono::high_resolution_clock::now(); 17 | } 18 | 19 | inline std::chrono::duration GetTimeDuration( 20 | std::chrono::high_resolution_clock::time_point start_time) 21 | { 22 | return std::chrono::duration(GetTimeNow() - start_time); 23 | } 24 | 25 | } -------------------------------------------------------------------------------- /include/armnnTestUtils/TensorCopyUtils.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017,2022 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | #pragma once 6 | 7 | namespace armnn 8 | { 9 | class ITensorHandle; 10 | } // namespace armnn 11 | 12 | void CopyDataToITensorHandle(armnn::ITensorHandle* tensorHandle, const void* memory); 13 | 14 | void CopyDataFromITensorHandle(void* mem, const armnn::ITensorHandle* tensorHandle); 15 | 16 | void AllocateAndCopyDataToITensorHandle(armnn::ITensorHandle* tensorHandle, const void* memory); -------------------------------------------------------------------------------- /include/armnnUtils/CompatibleTypes.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2021 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include 9 | 10 | namespace armnnUtils 11 | { 12 | 13 | template 14 | bool CompatibleTypes(armnn::DataType); 15 | 16 | } //namespace armnnUtils 17 | -------------------------------------------------------------------------------- /include/armnnUtils/FloatingPointComparison.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2020 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include 9 | 10 | namespace armnnUtils 11 | { 12 | 13 | /** 14 | * Compare two floats and return true if their values are within a specified tolerance of each other. 15 | * @param a 16 | * @param b 17 | * @param tolerancePercentage If not supplied default will be 1% tolerance (1.0f) 18 | * @return true if the value of float b is within tolerancePercentage of the value for float a. 19 | */ 20 | inline bool within_percentage_tolerance(float a, float b, float tolerancePercent = 1.0f) 21 | { 22 | float toleranceValue = std::fabs(a * (tolerancePercent / 100)); 23 | return std::fabs(a - b) <= toleranceValue; 24 | } 25 | 26 | } //namespace armnn 27 | 28 | -------------------------------------------------------------------------------- /include/armnnUtils/Permute.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2019,2022 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include 9 | #include 10 | 11 | #include 12 | 13 | namespace armnnUtils 14 | { 15 | 16 | armnn::TensorShape Permuted(const armnn::TensorShape& srcShape, 17 | const armnn::PermutationVector& mappings); 18 | 19 | armnn::TensorInfo Permuted(const armnn::TensorInfo& info, 20 | const armnn::PermutationVector& mappings); 21 | 22 | void Permute(const armnn::TensorShape& dstShape, const armnn::PermutationVector& mappings, 23 | const void* src, void* dst, size_t dataTypeSize); 24 | 25 | } // namespace armnnUtils 26 | -------------------------------------------------------------------------------- /include/armnnUtils/TContainer.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2020 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include 9 | 10 | #include 11 | 12 | namespace armnnUtils 13 | { 14 | 15 | // Standard definition of TContainer used by ArmNN, use this definition or add alternative definitions here instead of 16 | // defining your own. 17 | using TContainer = 18 | mapbox::util::variant, std::vector, std::vector, std::vector>; 19 | 20 | } // namespace armnnUtils 21 | -------------------------------------------------------------------------------- /include/armnnUtils/Transpose.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2020,2022 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include 9 | #include 10 | #include 11 | 12 | namespace armnnUtils 13 | { 14 | 15 | armnn::TensorShape TransposeTensorShape(const armnn::TensorShape& srcShape, const armnn::PermutationVector& mappings); 16 | 17 | armnn::TensorInfo TransposeTensorShape(const armnn::TensorInfo& info, const armnn::PermutationVector& mappings); 18 | 19 | void Transpose(const armnn::TensorShape& dstShape, const armnn::PermutationVector& mappings, 20 | const void* src, void* dst, size_t dataTypeSize); 21 | 22 | } // namespace armnnUtils 23 | -------------------------------------------------------------------------------- /profiling/client/include/CounterValue.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2022 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | namespace arm 9 | { 10 | 11 | namespace pipe 12 | { 13 | 14 | struct CounterValue 15 | { 16 | CounterValue(uint16_t id, uint32_t value) : 17 | counterId(id), counterValue(value) {} 18 | uint16_t counterId; 19 | uint32_t counterValue; 20 | }; 21 | 22 | } // namespace pipe 23 | 24 | } // namespace arm 25 | -------------------------------------------------------------------------------- /profiling/client/include/IInitialiseProfilingService.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2022 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | namespace arm 9 | { 10 | 11 | namespace pipe 12 | { 13 | 14 | // forward declaration 15 | class IProfilingService; 16 | 17 | class IInitialiseProfilingService 18 | { 19 | public: 20 | virtual ~IInitialiseProfilingService() {} 21 | virtual void InitialiseProfilingService(IProfilingService& profilingService) = 0; 22 | }; 23 | 24 | } // namespace pipe 25 | 26 | } // namespace arm 27 | -------------------------------------------------------------------------------- /profiling/client/include/IProfilingServiceStatus.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2020 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "ILocalPacketHandler.hpp" 9 | 10 | #include 11 | 12 | #include 13 | 14 | namespace arm 15 | { 16 | 17 | namespace pipe 18 | { 19 | 20 | class IProfilingServiceStatus 21 | { 22 | public: 23 | virtual void NotifyProfilingServiceActive() = 0; 24 | virtual void WaitForProfilingServiceActivation(unsigned int timeout) = 0; 25 | virtual ~IProfilingServiceStatus() {}; 26 | }; 27 | 28 | } // namespace pipe 29 | 30 | } // namespace arm 31 | -------------------------------------------------------------------------------- /profiling/client/include/IReportStructure.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2020 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | namespace arm 9 | { 10 | 11 | namespace pipe 12 | { 13 | 14 | class IProfilingService; 15 | 16 | class IReportStructure 17 | { 18 | public: 19 | virtual ~IReportStructure() {} 20 | virtual void ReportStructure(arm::pipe::IProfilingService& profilingService) = 0; 21 | }; 22 | 23 | } // namespace pipe 24 | 25 | } // namespace arm 26 | 27 | -------------------------------------------------------------------------------- /profiling/client/include/ProfilingState.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2022 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | namespace arm 9 | { 10 | 11 | namespace pipe 12 | { 13 | 14 | enum class ProfilingState 15 | { 16 | Uninitialised, 17 | NotConnected, 18 | WaitingForAck, 19 | Active 20 | }; 21 | 22 | } // namespace pipe 23 | 24 | } // namespace arm 25 | -------------------------------------------------------------------------------- /profiling/client/include/Timestamp.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2022 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "CounterValue.hpp" 9 | 10 | namespace arm 11 | { 12 | 13 | namespace pipe 14 | { 15 | 16 | struct Timestamp 17 | { 18 | uint64_t timestamp; 19 | std::vector counterValues; 20 | }; 21 | 22 | } // namespace pipe 23 | 24 | } // namespace arm 25 | -------------------------------------------------------------------------------- /profiling/client/src/IConsumer.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2020 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | namespace arm 9 | { 10 | 11 | namespace pipe 12 | { 13 | 14 | class IConsumer 15 | { 16 | public: 17 | virtual ~IConsumer() {} 18 | 19 | /// Set a "ready to read" flag in the buffer to notify the reading thread to start reading it. 20 | virtual void SetReadyToRead() = 0; 21 | }; 22 | 23 | } // namespace pipe 24 | 25 | } // namespace arm 26 | 27 | -------------------------------------------------------------------------------- /profiling/client/src/INotifyBackends.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2020 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | namespace arm 9 | { 10 | 11 | namespace pipe 12 | { 13 | 14 | class INotifyBackends 15 | { 16 | public: 17 | virtual ~INotifyBackends() {} 18 | virtual void NotifyBackendsForTimelineReporting() = 0; 19 | }; 20 | 21 | } // namespace pipe 22 | 23 | } // namespace arm 24 | 25 | -------------------------------------------------------------------------------- /profiling/client/src/IPeriodicCounterCapture.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2019 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | namespace arm 9 | { 10 | namespace pipe 11 | { 12 | 13 | class IPeriodicCounterCapture 14 | { 15 | public: 16 | virtual ~IPeriodicCounterCapture() {} 17 | 18 | virtual void Start() = 0; 19 | virtual void Stop() = 0; 20 | }; 21 | 22 | } // namespace pipe 23 | } // namespace arm 24 | -------------------------------------------------------------------------------- /profiling/client/src/IProfilingConnection.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include 9 | 10 | #include 11 | 12 | #include 13 | 14 | namespace arm 15 | { 16 | 17 | namespace pipe 18 | { 19 | 20 | class IProfilingConnection 21 | { 22 | public: 23 | virtual ~IProfilingConnection() {} 24 | 25 | virtual bool IsOpen() const = 0; 26 | 27 | virtual void Close() = 0; 28 | 29 | virtual bool WritePacket(const unsigned char* buffer, uint32_t length) = 0; 30 | 31 | virtual arm::pipe::Packet ReadPacket(uint32_t timeout) = 0; 32 | }; 33 | 34 | } // namespace pipe 35 | 36 | } // namespace arm 37 | -------------------------------------------------------------------------------- /profiling/client/src/IProfilingConnectionFactory.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2019 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "IProfilingConnection.hpp" 9 | 10 | #include 11 | 12 | #include 13 | 14 | namespace arm 15 | { 16 | 17 | namespace pipe 18 | { 19 | 20 | class IProfilingConnectionFactory 21 | { 22 | public: 23 | using ExternalProfilingOptions = ProfilingOptions; 24 | using IProfilingConnectionPtr = std::unique_ptr; 25 | 26 | virtual ~IProfilingConnectionFactory() {} 27 | 28 | virtual IProfilingConnectionPtr GetProfilingConnection(const ProfilingOptions& options) const = 0; 29 | }; 30 | 31 | } // namespace pipe 32 | 33 | } // namespace arm 34 | -------------------------------------------------------------------------------- /profiling/client/src/ISendThread.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2020 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "IProfilingConnection.hpp" 9 | 10 | namespace arm 11 | { 12 | 13 | namespace pipe 14 | { 15 | 16 | class ISendThread 17 | { 18 | public: 19 | virtual ~ISendThread() {} 20 | 21 | /// Start the thread 22 | virtual void Start(IProfilingConnection& profilingConnection) = 0; 23 | 24 | /// Stop the thread 25 | virtual void Stop(bool rethrowSendThreadExceptions = true) = 0; 26 | }; 27 | 28 | } // namespace pipe 29 | 30 | } // namespace arm 31 | 32 | -------------------------------------------------------------------------------- /profiling/client/src/ProfilingConnectionFactory.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2019 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "IProfilingConnectionFactory.hpp" 9 | 10 | namespace arm 11 | { 12 | 13 | namespace pipe 14 | { 15 | 16 | class ProfilingConnectionFactory final : public IProfilingConnectionFactory 17 | { 18 | public: 19 | ProfilingConnectionFactory() = default; 20 | ~ProfilingConnectionFactory() = default; 21 | 22 | IProfilingConnectionPtr GetProfilingConnection(const ProfilingOptions& options) const override; 23 | }; 24 | 25 | } // namespace pipe 26 | 27 | } // namespace arm 28 | -------------------------------------------------------------------------------- /profiling/client/src/TimelinePacketWriterFactory.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2019 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #include "TimelinePacketWriterFactory.hpp" 7 | 8 | #include "SendTimelinePacket.hpp" 9 | 10 | namespace arm 11 | { 12 | 13 | namespace pipe 14 | { 15 | 16 | std::unique_ptr TimelinePacketWriterFactory::GetSendTimelinePacket() const 17 | { 18 | return std::make_unique(m_BufferManager); 19 | } 20 | 21 | } // namespace pipe 22 | 23 | } // namespace arm 24 | -------------------------------------------------------------------------------- /profiling/client/src/TimelinePacketWriterFactory.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2019 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "IBufferManager.hpp" 9 | 10 | #include 11 | 12 | #include 13 | 14 | namespace arm 15 | { 16 | 17 | namespace pipe 18 | { 19 | 20 | class TimelinePacketWriterFactory 21 | { 22 | public: 23 | TimelinePacketWriterFactory(IBufferManager& bufferManager) : m_BufferManager(bufferManager) {} 24 | 25 | std::unique_ptr GetSendTimelinePacket() const; 26 | 27 | private: 28 | IBufferManager& m_BufferManager; 29 | }; 30 | 31 | } // namespace pipe 32 | 33 | } // namespace arm 34 | -------------------------------------------------------------------------------- /profiling/client/src/backends/IBackendProfiling.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2022 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #include "BackendProfiling.hpp" 7 | 8 | #include 9 | 10 | namespace arm 11 | { 12 | 13 | namespace pipe 14 | { 15 | 16 | std::unique_ptr IBackendProfiling::CreateBackendProfiling(const ProfilingOptions& options, 17 | IProfilingService& profilingService, 18 | const std::string& backendId) 19 | { 20 | return std::make_unique(options, profilingService, backendId); 21 | } 22 | 23 | } // namespace pipe 24 | } // namespace arm 25 | -------------------------------------------------------------------------------- /profiling/common/include/Assert.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2020 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include 9 | 10 | namespace arm 11 | { 12 | 13 | namespace pipe 14 | { 15 | 16 | #ifndef NDEBUG 17 | # define ARM_PIPE_ASSERT(COND) assert(COND) 18 | # define ARM_PIPE_ASSERT_MSG(COND, MSG) assert((COND) && MSG) 19 | #else 20 | # define ARM_PIPE_ASSERT(COND) 21 | # define ARM_PIPE_ASSERT_MSG(COND, MSG) 22 | #endif 23 | } // namespace pipe 24 | } //namespace arm -------------------------------------------------------------------------------- /profiling/common/include/Constants.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2020 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | #pragma once 6 | 7 | namespace arm 8 | { 9 | 10 | namespace pipe 11 | { 12 | static const unsigned int PIPE_MAGIC = 0x45495434; 13 | } // namespace pipe 14 | } // namespace arm -------------------------------------------------------------------------------- /profiling/common/include/DllExport.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2020 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | #pragma once 6 | 7 | #if defined (_MSC_VER) 8 | 9 | #ifdef ARMNN_COMPILING_DLL 10 | #define ARMNN_DLLEXPORT __declspec(dllexport) 11 | #else 12 | #define ARMNN_DLLEXPORT __declspec(dllimport) 13 | #endif 14 | 15 | #else 16 | 17 | #define ARMNN_DLLEXPORT 18 | 19 | #endif -------------------------------------------------------------------------------- /profiling/common/include/IProfilingGuidGenerator.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2019 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "ProfilingGuid.hpp" 9 | 10 | #include 11 | 12 | namespace arm 13 | { 14 | 15 | namespace pipe 16 | { 17 | 18 | class IProfilingGuidGenerator 19 | { 20 | public: 21 | /// Return the next random Guid in the sequence 22 | virtual ProfilingDynamicGuid NextGuid() = 0; 23 | 24 | /// Create a ProfilingStaticGuid based on a hash of the string 25 | virtual ProfilingStaticGuid GenerateStaticId(const std::string& str) = 0; 26 | 27 | virtual ~IProfilingGuidGenerator() {} 28 | }; 29 | 30 | } // namespace pipe 31 | 32 | } // namespace arm 33 | -------------------------------------------------------------------------------- /profiling/common/include/IgnoreUnused.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2020 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | namespace arm 9 | { 10 | 11 | namespace pipe 12 | { 13 | // Utility function to selectively silence unused variable compiler warnings 14 | 15 | template 16 | inline void IgnoreUnused(Ts&&...){} 17 | } //namespace pipe 18 | } //namespace arm -------------------------------------------------------------------------------- /profiling/common/include/Processes.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2020 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | namespace arm 9 | { 10 | namespace pipe 11 | { 12 | 13 | int GetCurrentProcessId(); 14 | 15 | } // namespace arm 16 | } // namespace pipe 17 | -------------------------------------------------------------------------------- /profiling/common/include/TargetEndianess.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2022 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | enum class TargetEndianness 9 | { 10 | BeWire, 11 | LeWire 12 | }; -------------------------------------------------------------------------------- /profiling/common/include/Threads.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2020 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | namespace arm 9 | { 10 | namespace pipe 11 | { 12 | 13 | int GetCurrentThreadId(); 14 | 15 | } // namespace pipe 16 | } // namespace arm 17 | -------------------------------------------------------------------------------- /profiling/common/src/CommandHandlerFunctor.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #include "CommandHandlerFunctor.hpp" 7 | 8 | namespace arm 9 | { 10 | 11 | namespace pipe 12 | { 13 | 14 | uint32_t CommandHandlerFunctor::GetFamilyId() const 15 | { 16 | return m_FamilyId; 17 | } 18 | 19 | uint32_t CommandHandlerFunctor::GetPacketId() const 20 | { 21 | return m_PacketId; 22 | } 23 | 24 | uint32_t CommandHandlerFunctor::GetVersion() const 25 | { 26 | return m_Version; 27 | } 28 | 29 | } // namespace pipe 30 | 31 | } // namespace arm 32 | -------------------------------------------------------------------------------- /profiling/common/src/Processes.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2020 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #include "Processes.hpp" 7 | 8 | #if defined(__unix__) || defined(__APPLE__) 9 | #include 10 | #elif defined(_MSC_VER) 11 | #include 12 | #endif 13 | 14 | namespace arm 15 | { 16 | namespace pipe 17 | { 18 | 19 | int GetCurrentProcessId() 20 | { 21 | #if !defined(ARMNN_DISABLE_PROCESSES) 22 | #if defined(__unix__) || defined(__APPLE__) 23 | return getpid(); 24 | #elif defined(_MSC_VER) 25 | return ::GetCurrentProcessId(); 26 | #endif 27 | #else 28 | return 0; 29 | #endif 30 | } 31 | 32 | } // namespace pipe 33 | } // namespace arm 34 | -------------------------------------------------------------------------------- /samples/BareMetalDeserializedGraph.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2022 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | #include 6 | 7 | int main() 8 | { 9 | printf("The bare metal deserialized graph was successfully executed\n"); 10 | return 0; 11 | } 12 | -------------------------------------------------------------------------------- /samples/KeywordSpotting/Readme.md.license: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright © 2021 Arm Ltd and Contributors. All rights reserved. 3 | # SPDX-License-Identifier: MIT 4 | # 5 | -------------------------------------------------------------------------------- /samples/KeywordSpotting/include/Decoder.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2021 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | # pragma once 6 | 7 | #include 8 | #include 9 | #include "ArmnnNetworkExecutor.hpp" 10 | 11 | namespace kws 12 | { 13 | 14 | /** 15 | * @brief Decodes quantised last layer of model output 16 | * 17 | */ 18 | class Decoder 19 | { 20 | private: 21 | int quantisationOffset; 22 | float quantisationScale; 23 | 24 | public: 25 | 26 | Decoder(int quantisationOffset, float quantisationScale) : quantisationOffset(quantisationOffset), 27 | quantisationScale(quantisationScale) {} 28 | 29 | std::pair decodeOutput(std::vector& modelOutput); 30 | 31 | }; 32 | } // namespace kws -------------------------------------------------------------------------------- /samples/KeywordSpotting/include/DsCnnMfcc.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2020 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | #pragma once 6 | 7 | #include "MFCC.hpp" 8 | 9 | /* Class to provide DS-CNN specific MFCC calculation requirements. */ 10 | class DsCnnMFCC : public MFCC 11 | { 12 | 13 | public: 14 | 15 | explicit DsCnnMFCC(MfccParams& params) 16 | : MFCC(params) 17 | {} 18 | DsCnnMFCC() = delete; 19 | ~DsCnnMFCC() = default; 20 | }; 21 | -------------------------------------------------------------------------------- /samples/ObjectDetection/Readme.md.license: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright © 2020-2022 Arm Ltd and Contributors. All rights reserved. 3 | # SPDX-License-Identifier: MIT 4 | # 5 | -------------------------------------------------------------------------------- /samples/SpeechRecognition/Readme.md.license: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright © 2021 Arm Ltd and Contributors. All rights reserved. 3 | # SPDX-License-Identifier: MIT 4 | # 5 | -------------------------------------------------------------------------------- /samples/common/cmake/aarch64-toolchain.cmake: -------------------------------------------------------------------------------- 1 | # Copyright © 2020 Arm Ltd and Contributors. All rights reserved. 2 | # SPDX-License-Identifier: MIT 3 | 4 | # specify the cross compiler 5 | set(GNU_MACHINE "aarch64-linux-gnu") 6 | set(CROSS_PREFIX "aarch64-linux-gnu-") 7 | 8 | set(CMAKE_C_COMPILER ${CROSS_PREFIX}gcc) 9 | set(CMAKE_CXX_COMPILER ${CROSS_PREFIX}g++) 10 | set(CMAKE_AR ${CROSS_PREFIX}ar) 11 | set(CMAKE_STRIP ${CROSS_PREFIX}strip) 12 | set(CMAKE_LINKER ${CROSS_PREFIX}ld) 13 | 14 | set(CMAKE_CROSSCOMPILING true) 15 | set(CMAKE_SYSTEM_NAME Linux) 16 | 17 | set(CMAKE_SYSTEM_PROCESSOR aarch64) 18 | 19 | set(OPENCV_EXTRA_ARGS "-DENABLE_NEON=ON" 20 | "-DCMAKE_TOOLCHAIN_FILE=platforms/linux/aarch64-gnu.toolchain.cmake") -------------------------------------------------------------------------------- /samples/common/cmake/arm-linux-gnueabihf-toolchain.cmake: -------------------------------------------------------------------------------- 1 | # Copyright © 2020 Arm Ltd and Contributors. All rights reserved. 2 | # SPDX-License-Identifier: MIT 3 | 4 | # specify the cross compiler 5 | set(GNU_MACHINE "arm-linux-gnueabihf") 6 | set(CROSS_PREFIX "arm-linux-gnueabihf-") 7 | 8 | set(CMAKE_C_COMPILER ${CROSS_PREFIX}gcc) 9 | set(CMAKE_CXX_COMPILER ${CROSS_PREFIX}g++) 10 | set(CMAKE_AR ${CROSS_PREFIX}ar) 11 | set(CMAKE_STRIP ${CROSS_PREFIX}strip) 12 | set(CMAKE_LINKER ${CROSS_PREFIX}ld) 13 | 14 | set(CMAKE_CROSSCOMPILING true) 15 | set(CMAKE_SYSTEM_NAME Linux) 16 | 17 | set(CMAKE_SYSTEM_PROCESSOR arm) 18 | 19 | set(OPENCV_EXTRA_ARGS "-DENABLE_NEON=ON" 20 | "-DCMAKE_TOOLCHAIN_FILE=platforms/linux/arm.toolchain.cmake") -------------------------------------------------------------------------------- /samples/common/cmake/find_catch.cmake: -------------------------------------------------------------------------------- 1 | # Copyright © 2020 Arm Ltd and Contributors. All rights reserved. 2 | # SPDX-License-Identifier: MIT 3 | 4 | #Test TPIP 5 | set(TEST_TPIP ${DEPENDENCIES_DIR}/test) 6 | file(MAKE_DIRECTORY ${TEST_TPIP}) 7 | set(TEST_TPIP_INCLUDE ${TEST_TPIP}/include) 8 | file(MAKE_DIRECTORY ${TEST_TPIP_INCLUDE}) 9 | 10 | ExternalProject_Add(catch2-headers 11 | URL https://github.com/catchorg/Catch2/releases/download/v2.13.5/catch.hpp 12 | URL_HASH MD5=b43c586fe617aefdee3e480e9fa8f370 13 | DOWNLOAD_NO_EXTRACT 1 14 | CONFIGURE_COMMAND "" 15 | BUILD_COMMAND ${CMAKE_COMMAND} -E copy /catch.hpp ${TEST_TPIP_INCLUDE} 16 | INSTALL_COMMAND "" 17 | ) 18 | -------------------------------------------------------------------------------- /samples/common/src/CVUtils/CvWindowOutput.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2020 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #include "CvWindowOutput.hpp" 7 | 8 | namespace common 9 | { 10 | 11 | void CvWindowOutput::Init(const std::string& windowName) 12 | { 13 | m_windowName = windowName; 14 | cv::namedWindow(m_windowName, cv::WINDOW_AUTOSIZE); 15 | } 16 | 17 | void CvWindowOutput::WriteFrame(std::shared_ptr& frame) 18 | { 19 | cv::cvtColor(*frame, *frame, cv::COLOR_RGB2BGR); 20 | cv::imshow( m_windowName, *frame); 21 | cv::waitKey(30); 22 | } 23 | 24 | void CvWindowOutput::Close() 25 | { 26 | cv::destroyWindow(m_windowName); 27 | } 28 | 29 | bool CvWindowOutput::IsReady() const 30 | { 31 | return true; 32 | } 33 | }// namespace common -------------------------------------------------------------------------------- /samples/serialized/Readme.md: -------------------------------------------------------------------------------- 1 | # Arm NN Serialized Example model 2 | 3 | This is a really simple example of an Arm NN serialized model which is supported on Netron. It is based on SSD MobileNet V1 FP32 model available in the public model zoo (https://github.com/ARM-software/ML-zoo/tree/master/models/object_detection/ssd_mobilenet_v1/tflite_fp32), converted using the ArmnnConverter tool. The model is trained by Google and uses 300x300 input image. 4 | More details on how to deploy this model using Arm NN SDK can be found here: https://developer.arm.com/documentation/102274/latest. -------------------------------------------------------------------------------- /samples/serialized/Readme.md.license: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright © 2021-2022 Arm Ltd and Contributors. All rights reserved. 3 | # SPDX-License-Identifier: MIT 4 | # 5 | -------------------------------------------------------------------------------- /samples/serialized/ssd_mobilenet_v1.armnn: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ARM-software/armnn/e1ec5b81cf484f50dd50b480a8c16213edaff5e3/samples/serialized/ssd_mobilenet_v1.armnn -------------------------------------------------------------------------------- /samples/serialized/ssd_mobilenet_v1.armnn.license: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright © 2021 Arm Ltd and Contributors. All rights reserved. 3 | # SPDX-License-Identifier: MIT 4 | # 5 | -------------------------------------------------------------------------------- /src/armnn/ArmNNProfilingServiceInitialiser.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2022 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include 9 | #include 10 | 11 | namespace armnn 12 | { 13 | 14 | class ArmNNProfilingServiceInitialiser : public arm::pipe::IInitialiseProfilingService 15 | { 16 | public: 17 | void InitialiseProfilingService(arm::pipe::IProfilingService& profilingService) override; 18 | }; 19 | 20 | } // namespace armnn 21 | -------------------------------------------------------------------------------- /src/armnn/DllExport.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2020 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | #pragma once 6 | 7 | #if defined (_MSC_VER) 8 | 9 | #ifdef ARMNN_COMPILING_DLL 10 | #define ARMNN_DLLEXPORT __declspec(dllexport) 11 | #else 12 | #define ARMNN_DLLEXPORT __declspec(dllimport) 13 | #endif 14 | 15 | #else 16 | 17 | #define ARMNN_DLLEXPORT 18 | 19 | #endif -------------------------------------------------------------------------------- /src/armnn/IGraphObservable.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | #pragma once 6 | 7 | #include "Layer.hpp" 8 | 9 | namespace armnn 10 | { 11 | 12 | enum class GraphEvent 13 | { 14 | LayerAdded, 15 | LayerErased 16 | }; 17 | 18 | class IGraphObservable 19 | { 20 | public: 21 | virtual void Update(Layer* graphLayer) = 0; 22 | 23 | protected: 24 | virtual ~IGraphObservable() = default; 25 | }; 26 | 27 | } //namespace armnn 28 | 29 | -------------------------------------------------------------------------------- /src/armnn/ISubgraphViewConverter.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include 9 | 10 | #include 11 | #include 12 | #include 13 | 14 | namespace armnn 15 | { 16 | 17 | using CompiledBlobDeleter = std::function; 18 | using CompiledBlobPtr = std::unique_ptr; 19 | 20 | class ISubgraphViewConverter 21 | { 22 | public: 23 | virtual ~ISubgraphViewConverter() {} 24 | 25 | virtual std::vector CompileNetwork() = 0; 26 | }; 27 | 28 | } // namespace armnn 29 | -------------------------------------------------------------------------------- /src/armnn/InternalTypes.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017,2024 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #include "InternalTypes.hpp" 7 | 8 | #include 9 | 10 | namespace armnn 11 | { 12 | 13 | char const* GetLayerTypeAsCString(LayerType type) 14 | { 15 | switch (type) 16 | { 17 | #define X(name) case LayerType::name: return #name; 18 | LIST_OF_LAYER_TYPE 19 | #undef X 20 | default: 21 | throw armnn::InvalidArgumentException("Unknown layer type"); 22 | return "Unknown"; 23 | } 24 | } 25 | 26 | } 27 | -------------------------------------------------------------------------------- /src/armnn/InternalTypes.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | #pragma once 6 | 7 | #include 8 | #include 9 | 10 | #include 11 | 12 | namespace armnn 13 | { 14 | 15 | using Coordinates = std::array; 16 | using Dimensions = std::array; 17 | 18 | } 19 | -------------------------------------------------------------------------------- /src/armnn/LayerFwd.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | #pragma once 6 | 7 | namespace armnn 8 | { 9 | 10 | class BindableLayer; 11 | class Layer; 12 | 13 | } 14 | -------------------------------------------------------------------------------- /src/armnn/NetworkUtils.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2022 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "DeviceSpec.hpp" 9 | #include "Graph.hpp" 10 | 11 | namespace armnn 12 | { 13 | 14 | std::vector InsertConvertFp16ToFp32LayersBefore(Graph& graph, 15 | Layer& layer, 16 | bool expectCorrectInputType = true); 17 | 18 | std::vector InsertConvertFp32ToFp16LayersAfter(Graph& graph, Layer& layer); 19 | 20 | std::vector InsertDebugLayerAfter(Graph& graph, Layer& layer, bool toFile); 21 | 22 | bool RevertConstantWeightsToFP32(Layer* layer); 23 | 24 | } // namespace armnn 25 | -------------------------------------------------------------------------------- /src/armnn/layers/LayerCloneBase.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | #pragma once 6 | 7 | #include 8 | #include 9 | 10 | namespace armnn 11 | { 12 | 13 | template 14 | LayerType* Layer::CloneBase(Graph& graph, Params&& ... params) const 15 | { 16 | LayerType* const layer = graph.AddLayer(std::forward(params)...); 17 | 18 | layer->BackendSelectionHint(GetBackendHint()); 19 | layer->SetBackendId(GetBackendId()); 20 | layer->SetGuid(GetGuid()); 21 | layer->SetShapeInferenceMethod(m_ShapeInferenceMethod); 22 | layer->SetAllowExpandedDims(m_AllowExpandedDims); 23 | 24 | return layer; 25 | } 26 | 27 | } // namespace 28 | -------------------------------------------------------------------------------- /src/armnn/layers/MergerLayer.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | #pragma once 6 | 7 | #include "ConcatLayer.hpp" 8 | 9 | using MergerLayer = ConcatLayer; -------------------------------------------------------------------------------- /src/armnn/layers/QuantizeLayer.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include 9 | 10 | namespace armnn { 11 | 12 | //Forward 13 | class IWorkload; 14 | class IWorkloadFactory; 15 | 16 | class QuantizeLayer : public Layer 17 | { 18 | public: 19 | virtual std::unique_ptr CreateWorkload(const IWorkloadFactory& factory) const override; 20 | 21 | Layer* Clone(Graph& graph) const override; 22 | 23 | void ValidateTensorShapesFromInputs() override; 24 | 25 | void ExecuteStrategy(IStrategy& strategy) const override; 26 | 27 | 28 | protected: 29 | QuantizeLayer(const char* name); 30 | ~QuantizeLayer() = default; 31 | 32 | }; 33 | 34 | } //namespace armnn 35 | -------------------------------------------------------------------------------- /src/armnn/test/RuntimeTests.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | #pragma once 6 | 7 | #include 8 | 9 | namespace armnn 10 | { 11 | 12 | void RuntimeLoadedNetworksReserve(armnn::RuntimeImpl* runtime); 13 | 14 | } // namespace armnn 15 | -------------------------------------------------------------------------------- /src/armnnDeserializer/README.md: -------------------------------------------------------------------------------- 1 | # The Arm NN Deserializer 2 | 3 | The `armnnDeserializer` is a library for loading neural networks defined by Arm NN FlatBuffers files 4 | into the Arm NN runtime. 5 | 6 | For more information about the layers that are supported, and the networks that have been tested, 7 | take a look at our [doxygen documentation](https://arm-software.github.io/armnn/latest/deserializer.xhtml). -------------------------------------------------------------------------------- /src/armnnDeserializer/README.md.license: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright © 2019, 2021 Arm Ltd and Contributors. All rights reserved. 3 | # SPDX-License-Identifier: MIT 4 | # 5 | -------------------------------------------------------------------------------- /src/armnnDeserializer/test/SchemaSerialize.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | extern "C" { 7 | extern const char deserialize_schema_start; 8 | extern const char deserialize_schema_end; 9 | } 10 | -------------------------------------------------------------------------------- /src/armnnDeserializer/test/SchemaSerialize.s: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #if !defined(__MACH__) 7 | .section .rodata 8 | #define EXTERN_ASM 9 | #else 10 | .const_data 11 | #define EXTERN_ASM _ 12 | #endif 13 | 14 | #define GLUE(a, b) a ## b 15 | #define JOIN(a, b) GLUE(a, b) 16 | #define X(s) JOIN(EXTERN_ASM, s) 17 | 18 | .global X(deserialize_schema_start) 19 | .global X(deserialize_schema_end) 20 | 21 | X(deserialize_schema_start): 22 | .incbin ARMNN_SERIALIZER_SCHEMA_PATH 23 | X(deserialize_schema_end): 24 | -------------------------------------------------------------------------------- /src/armnnOnnxParser/README.md: -------------------------------------------------------------------------------- 1 | # Arm NN ONNX parser 2 | 3 | `armnnOnnxParser` is a library for loading neural networks defined in ONNX protobuf files into the Arm NN runtime. 4 | 5 | For more information, a list of supported ONNX layers, and the networks that have been tested, 6 | please visit our [doxygen documentation](https://arm-software.github.io/armnn/latest/parsers.xhtml#S5_onnx_parser). -------------------------------------------------------------------------------- /src/armnnOnnxParser/README.md.license: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright © 2018, 2021 Arm Ltd and Contributors. All rights reserved. 3 | # SPDX-License-Identifier: MIT 4 | # 5 | -------------------------------------------------------------------------------- /src/armnnOnnxParser/test/Constructor.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017, 2024 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #include "armnnOnnxParser/IOnnxParser.hpp" 7 | 8 | #include 9 | 10 | ARMNN_NO_DEPRECATE_WARN_BEGIN 11 | TEST_SUITE("OnnxParser_Constructor") 12 | { 13 | TEST_CASE("Create") 14 | { 15 | armnnOnnxParser::IOnnxParserPtr parser(armnnOnnxParser::IOnnxParser::Create()); 16 | } 17 | 18 | } 19 | ARMNN_NO_DEPRECATE_WARN_END -------------------------------------------------------------------------------- /src/armnnOnnxParser/test/OnnxParserTestUtils.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2021 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include 9 | #include 10 | 11 | namespace armnnUtils 12 | { 13 | 14 | std::string ConstructTensorShapeString(const std::vector& shape); 15 | 16 | std::string ConstructIntsAttribute(const std::string& name, const std::vector& value); 17 | 18 | } // namespace armnnUtils -------------------------------------------------------------------------------- /src/armnnSerializer/README.md: -------------------------------------------------------------------------------- 1 | # The Arm NN Serializer 2 | 3 | The `armnnSerializer` is a library for serializing an Arm NN network to a stream. 4 | 5 | For more information about the layers that are supported, and the networks that have been tested, 6 | take a look at our [doxygen documentation](https://arm-software.github.io/armnn/latest/serializer.xhtml). -------------------------------------------------------------------------------- /src/armnnSerializer/README.md.license: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright © 2019, 2021 Arm Ltd and Contributors. All rights reserved. 3 | # SPDX-License-Identifier: MIT 4 | # 5 | -------------------------------------------------------------------------------- /src/armnnTestUtils/TensorCopyUtils.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017,2022 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #include 7 | #include 8 | #include 9 | 10 | void CopyDataToITensorHandle(armnn::ITensorHandle* tensorHandle, const void* memory) 11 | { 12 | tensorHandle->CopyInFrom(memory); 13 | } 14 | 15 | void CopyDataFromITensorHandle(void* memory, const armnn::ITensorHandle* tensorHandle) 16 | { 17 | tensorHandle->CopyOutTo(memory); 18 | } 19 | 20 | void AllocateAndCopyDataToITensorHandle(armnn::ITensorHandle* tensorHandle, const void* memory) 21 | { 22 | tensorHandle->Allocate(); 23 | CopyDataToITensorHandle(tensorHandle, memory); 24 | } 25 | -------------------------------------------------------------------------------- /src/armnnTfLiteParser/README.md: -------------------------------------------------------------------------------- 1 | # The Arm NN TensorFlow Lite parser 2 | 3 | `armnnTfLiteParser` is a library for loading neural networks defined by TensorFlow Lite FlatBuffers files 4 | into the Arm NN runtime. 5 | 6 | For more information, a list of supported TensorFlow Lite layers, and the networks that have been tested, 7 | please visit our [doxygen documentation](https://arm-software.github.io/armnn/latest/parsers.xhtml#S6_tf_lite_parser). 8 | -------------------------------------------------------------------------------- /src/armnnTfLiteParser/README.md.license: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright © 2018-2019, 2021 Arm Ltd and Contributors. All rights reserved. 3 | # SPDX-License-Identifier: MIT 4 | # 5 | -------------------------------------------------------------------------------- /src/armnnTfLiteParser/test/Schema.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | extern unsigned char g_TfLiteSchemaText[]; 7 | extern unsigned int g_TfLiteSchemaText_len; 8 | -------------------------------------------------------------------------------- /src/armnnUtils/ProfilingOptionsConverter.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2022 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include 9 | 10 | #include 11 | 12 | namespace arm 13 | { 14 | 15 | namespace pipe 16 | { 17 | 18 | ProfilingOptions ConvertExternalProfilingOptions( 19 | const armnn::IRuntime::CreationOptions::ExternalProfilingOptions& options); 20 | 21 | } // namespace pipe 22 | 23 | } // namespace arm 24 | -------------------------------------------------------------------------------- /src/armnnUtils/PrototxtConversions.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include 9 | 10 | namespace armnn 11 | { 12 | class TensorShape; 13 | } // namespace armnn 14 | 15 | namespace armnnUtils 16 | { 17 | 18 | /// Converts an int value into the Prototxt octal representation 19 | std::string ConvertInt32ToOctalString(int value); 20 | 21 | /// Converts an TensorShape into Prototxt representation 22 | std::string ConvertTensorShapeToString(const armnn::TensorShape& shape); 23 | 24 | } // namespace armnnUtils 25 | -------------------------------------------------------------------------------- /src/backends/README.md.license: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright © 2018-2022 Arm Ltd and Contributors. All rights reserved. 3 | # SPDX-License-Identifier: MIT 4 | # 5 | -------------------------------------------------------------------------------- /src/backends/aclCommon/ArmComputeTensorHandle.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include 9 | 10 | #include 11 | #include 12 | 13 | namespace armnn 14 | { 15 | 16 | class IAclTensorHandle : public ITensorHandle 17 | { 18 | public: 19 | virtual arm_compute::ITensor& GetTensor() = 0; 20 | virtual arm_compute::ITensor const& GetTensor() const = 0; 21 | virtual arm_compute::DataType GetDataType() const = 0; 22 | virtual void SetMemoryGroup(const std::shared_ptr& memoryGroup) = 0; 23 | }; 24 | 25 | } //namespace armnn -------------------------------------------------------------------------------- /src/backends/aclCommon/IClTensorHandle.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2022 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | #pragma once 6 | 7 | #include 8 | #include 9 | 10 | namespace armnn 11 | { 12 | 13 | class IClTensorHandle : public IAclTensorHandle 14 | { 15 | public: 16 | virtual arm_compute::ICLTensor& GetTensor() = 0; 17 | virtual arm_compute::ICLTensor const& GetTensor() const = 0; 18 | virtual arm_compute::DataType GetDataType() const = 0; 19 | virtual void SetMemoryGroup(const std::shared_ptr& memoryGroup) = 0; 20 | }; 21 | 22 | } //namespace armnn -------------------------------------------------------------------------------- /src/backends/aclCommon/common.cmake: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright © 2017-2023 Arm Ltd. All rights reserved. 3 | # SPDX-License-Identifier: MIT 4 | # 5 | 6 | if(ARMCOMPUTENEON OR ARMCOMPUTECL) 7 | add_subdirectory(${PROJECT_SOURCE_DIR}/src/backends/aclCommon) 8 | list(APPEND armnnLibraries armnnAclCommon) 9 | list(APPEND armnnUnitTestLibraries armnnAclCommonUnitTests) 10 | endif() 11 | -------------------------------------------------------------------------------- /src/backends/backendsCommon/ITensorHandleFactory.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #include 7 | 8 | namespace armnn 9 | { 10 | 11 | const ITensorHandleFactory::FactoryId ITensorHandleFactory::LegacyFactoryId = "armnn_legacy_factory"; 12 | const ITensorHandleFactory::FactoryId ITensorHandleFactory::DeferredFactoryId = "armnn_deferred_factory"; 13 | 14 | } // namespace armnn 15 | -------------------------------------------------------------------------------- /src/backends/backendsCommon/MapWorkload.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2020 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #include 7 | 8 | namespace armnn 9 | { 10 | 11 | MapWorkload::MapWorkload(const MapQueueDescriptor& descriptor, 12 | const WorkloadInfo& info) 13 | : BaseWorkload(descriptor, info) 14 | { 15 | } 16 | 17 | void MapWorkload::Execute() const 18 | { 19 | m_Data.m_Inputs[0]->Map(); 20 | } 21 | 22 | } //namespace armnn 23 | -------------------------------------------------------------------------------- /src/backends/backendsCommon/MapWorkload.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2020 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | #pragma once 6 | 7 | #include 8 | 9 | namespace armnn 10 | { 11 | 12 | class MapWorkload : public BaseWorkload 13 | { 14 | public: 15 | MapWorkload(const MapQueueDescriptor& descriptor, const WorkloadInfo& info); 16 | void Execute() const override; 17 | }; 18 | 19 | } //namespace armnn 20 | -------------------------------------------------------------------------------- /src/backends/backendsCommon/MemImportWorkload.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | #pragma once 6 | 7 | #include "WorkloadUtils.hpp" 8 | 9 | #include 10 | #include 11 | 12 | #include 13 | 14 | namespace armnn 15 | { 16 | 17 | class ImportMemGenericWorkload : public BaseWorkload 18 | { 19 | public: 20 | ImportMemGenericWorkload(const MemImportQueueDescriptor& descriptor, const WorkloadInfo& info); 21 | void Execute() const override; 22 | 23 | private: 24 | using TensorHandlePair = std::pair; 25 | TensorHandlePair m_TensorHandlePairs; 26 | }; 27 | 28 | } //namespace armnn 29 | -------------------------------------------------------------------------------- /src/backends/backendsCommon/MemSyncWorkload.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2022, 2024 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | #pragma once 6 | 7 | #include "WorkloadUtils.hpp" 8 | 9 | #include 10 | #include 11 | 12 | #include 13 | 14 | namespace armnn 15 | { 16 | 17 | class SyncMemGenericWorkload : public BaseWorkload 18 | { 19 | public: 20 | SyncMemGenericWorkload(const MemSyncQueueDescriptor& descriptor, const WorkloadInfo& info); 21 | void Execute() const override; 22 | 23 | private: 24 | ITensorHandle* m_TensorHandle; 25 | }; 26 | 27 | } //namespace armnn 28 | -------------------------------------------------------------------------------- /src/backends/backendsCommon/UnmapWorkload.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2020 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #include 7 | 8 | namespace armnn 9 | { 10 | 11 | UnmapWorkload::UnmapWorkload(const UnmapQueueDescriptor& descriptor, 12 | const WorkloadInfo& info) 13 | : BaseWorkload(descriptor, info) 14 | { 15 | } 16 | 17 | void UnmapWorkload::Execute() const 18 | { 19 | m_Data.m_Inputs[0]->Unmap(); 20 | } 21 | 22 | } //namespace armnn 23 | -------------------------------------------------------------------------------- /src/backends/backendsCommon/UnmapWorkload.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2020 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | #pragma once 6 | 7 | #include 8 | 9 | namespace armnn 10 | { 11 | 12 | class UnmapWorkload : public BaseWorkload 13 | { 14 | public: 15 | UnmapWorkload(const UnmapQueueDescriptor& descriptor, const WorkloadInfo& info); 16 | void Execute() const override; 17 | }; 18 | 19 | } //namespace armnn 20 | -------------------------------------------------------------------------------- /src/backends/backendsCommon/common.cmake: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright © 2017 Arm Ltd. All rights reserved. 3 | # SPDX-License-Identifier: MIT 4 | # 5 | 6 | add_subdirectory(${PROJECT_SOURCE_DIR}/src/backends/backendsCommon) 7 | list(APPEND armnnLibraries armnnBackendsCommon) 8 | list(APPEND armnnLibraries armnnMemoryOptimizationStrategies) 9 | list(APPEND armnnUnitTestLibraries armnnBackendsCommonUnitTests) 10 | list(APPEND armnnUnitTestLibraries armnnMemoryOptimizationStrategiesUnitTests) -------------------------------------------------------------------------------- /src/backends/backendsCommon/memoryOptimizerStrategyLibrary/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright © 2021 Arm Ltd and Contributors. All rights reserved. 3 | # SPDX-License-Identifier: MIT 4 | # 5 | 6 | list(APPEND armnnMemoryOptimizationStrategies_sources 7 | MemoryOptimizerStrategyLibrary.hpp 8 | MemoryOptimizerStrategyFactory.hpp 9 | strategies/ConstantMemoryStrategy.hpp 10 | strategies/ConstantMemoryStrategy.cpp 11 | strategies/StrategyValidator.hpp 12 | strategies/StrategyValidator.cpp 13 | strategies/SingleAxisPriorityList.hpp 14 | strategies/SingleAxisPriorityList.cpp 15 | ) 16 | 17 | if(BUILD_UNIT_TESTS) 18 | add_subdirectory(test) 19 | endif() 20 | 21 | add_library(armnnMemoryOptimizationStrategies OBJECT ${armnnMemoryOptimizationStrategies_sources}) -------------------------------------------------------------------------------- /src/backends/backendsCommon/memoryOptimizerStrategyLibrary/test/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright © 2021 Arm Ltd and Contributors. All rights reserved. 3 | # SPDX-License-Identifier: MIT 4 | # 5 | 6 | list(APPEND armnnMemoryOptimizationStrategiesUnitTests_sources 7 | ConstMemoryStrategyTests.cpp 8 | ValidatorStrategyTests.cpp 9 | SingleAxisPriorityListTests.cpp 10 | MemoryOptimizerStrategyLibraryTests.cpp 11 | ) 12 | 13 | add_library(armnnMemoryOptimizationStrategiesUnitTests OBJECT ${armnnMemoryOptimizationStrategiesUnitTests_sources}) 14 | target_include_directories(armnnMemoryOptimizationStrategiesUnitTests PRIVATE ${PROJECT_SOURCE_DIR}/src/backends) 15 | -------------------------------------------------------------------------------- /src/backends/backendsCommon/test/InstanceNormalizationEndToEndTestImpl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2019 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include 9 | 10 | #include 11 | 12 | void InstanceNormalizationNhwcEndToEndTest1(const std::vector& defaultBackends); 13 | 14 | void InstanceNormalizationNchwEndToEndTest1(const std::vector& defaultBackends); 15 | 16 | void InstanceNormalizationNhwcEndToEndTest2(const std::vector& defaultBackends); 17 | 18 | void InstanceNormalizationNchwEndToEndTest2(const std::vector& defaultBackends); 19 | -------------------------------------------------------------------------------- /src/backends/backendsCommon/test/JsonPrinterTestImpl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include 9 | 10 | #include 11 | 12 | void RunSoftmaxProfilerJsonPrinterTest(const std::vector& backends); 13 | -------------------------------------------------------------------------------- /src/backends/backendsCommon/test/LogSoftmaxEndToEndTestImpl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2019 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include 9 | 10 | #include 11 | 12 | void LogSoftmaxEndToEndTest(const std::vector& defaultBackends); 13 | -------------------------------------------------------------------------------- /src/backends/backendsCommon/test/MockBackendId.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | namespace armnn 9 | { 10 | 11 | constexpr const char* MockBackendId() { return "MockAcc"; } 12 | 13 | } // namespace armnn 14 | -------------------------------------------------------------------------------- /src/backends/backendsCommon/test/QLstmEndToEndTestImpl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2020 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include 9 | 10 | #include 11 | 12 | void QLstmEndToEnd(const std::vector& backends); -------------------------------------------------------------------------------- /src/backends/backendsCommon/test/QuantizedLstmEndToEndTestImpl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include 9 | 10 | #include 11 | 12 | void QuantizedLstmEndToEnd(const std::vector& backends); 13 | -------------------------------------------------------------------------------- /src/backends/backendsCommon/test/SpaceToDepthEndToEndTestImpl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include 9 | 10 | #include 11 | 12 | void SpaceToDepthNhwcEndToEndTest1(const std::vector& defaultBackends); 13 | 14 | void SpaceToDepthNchwEndToEndTest1(const std::vector& defaultBackends); 15 | 16 | void SpaceToDepthNhwcEndToEndTest2(const std::vector& defaultBackends); 17 | 18 | void SpaceToDepthNchwEndToEndTest2(const std::vector& defaultBackends); 19 | -------------------------------------------------------------------------------- /src/backends/backendsCommon/test/TestSharedObject.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #include "TestSharedObject.hpp" 7 | 8 | int TestFunction1(int i) 9 | { 10 | return i; 11 | } 12 | 13 | int TestFunction2(int i) 14 | { 15 | return i; 16 | } 17 | 18 | int TestFunction3(int i) 19 | { 20 | return i; 21 | } 22 | -------------------------------------------------------------------------------- /src/backends/backendsCommon/test/TestSharedObject.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include 9 | 10 | // No name mangling 11 | extern "C" 12 | { 13 | int TestFunction1(int i); 14 | } 15 | 16 | // C++ name mangling 17 | extern int TestFunction2(int i); 18 | 19 | // No external linkage 20 | int TestFunction3(int i); 21 | -------------------------------------------------------------------------------- /src/backends/backendsCommon/test/WorkloadFactoryHelper.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | #pragma once 6 | 7 | namespace 8 | { 9 | 10 | template struct WorkloadFactoryHelper {}; 11 | 12 | } // anonymous namespace -------------------------------------------------------------------------------- /src/backends/backendsCommon/test/layerTests/ConvertFp16ToFp32TestImpl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include 9 | 10 | #include 11 | #include 12 | 13 | LayerTestResult SimpleConvertFp16ToFp32Test( 14 | armnn::IWorkloadFactory& workloadFactory, 15 | const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, 16 | const armnn::ITensorHandleFactory& tensorHandleFactory); 17 | -------------------------------------------------------------------------------- /src/backends/backendsCommon/test/layerTests/ConvertFp32ToFp16TestImpl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include 9 | 10 | #include 11 | 12 | #include 13 | #include 14 | 15 | LayerTestResult SimpleConvertFp32ToFp16Test( 16 | armnn::IWorkloadFactory& workloadFactory, 17 | const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, 18 | const armnn::ITensorHandleFactory& tensorHandleFactory); 19 | -------------------------------------------------------------------------------- /src/backends/backendsCommon/test/layerTests/ElementwiseUnaryTestImpl.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2019 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #include "ElementwiseUnaryTestImpl.hpp" 7 | 8 | std::unique_ptr CreateWorkload( 9 | const armnn::IWorkloadFactory& workloadFactory, 10 | const armnn::WorkloadInfo& info, 11 | const armnn::ElementwiseUnaryQueueDescriptor& descriptor) 12 | { 13 | return workloadFactory.CreateWorkload(armnn::LayerType::ElementwiseUnary, descriptor, info); 14 | } -------------------------------------------------------------------------------- /src/backends/backendsCommon/test/layerTests/FakeQuantizationTestImpl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include 9 | 10 | #include 11 | #include 12 | 13 | LayerTestResult FakeQuantizationTest( 14 | armnn::IWorkloadFactory& workloadFactory, 15 | const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, 16 | const armnn::ITensorHandleFactory& tensorHandleFactory); 17 | -------------------------------------------------------------------------------- /src/backends/backendsCommon/test/layerTests/FillTestImpl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2020 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include 9 | 10 | #include 11 | 12 | #include 13 | #include 14 | 15 | template> 16 | LayerTestResult SimpleFillTest( 17 | armnn::IWorkloadFactory& workloadFactory, 18 | const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, 19 | const armnn::ITensorHandleFactory& tensorHandleFactory); 20 | -------------------------------------------------------------------------------- /src/backends/backendsCommon/test/layerTests/FloorDivTestImpl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2024 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include 9 | 10 | #include 11 | 12 | #include 13 | #include 14 | 15 | template> 16 | LayerTestResult SimpleFloorDivTest( 17 | armnn::IWorkloadFactory& workloadFactory, 18 | const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, 19 | const armnn::ITensorHandleFactory& tensorHandleFactory); -------------------------------------------------------------------------------- /src/backends/backendsCommon/test/layerTests/FloorTestImpl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include 9 | 10 | #include 11 | 12 | #include 13 | #include 14 | 15 | template> 16 | LayerTestResult SimpleFloorTest( 17 | armnn::IWorkloadFactory& workloadFactory, 18 | const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, 19 | const armnn::ITensorHandleFactory& tensorHandleFactory); 20 | -------------------------------------------------------------------------------- /src/backends/cl/ClBackendId.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | #pragma once 6 | 7 | namespace armnn 8 | { 9 | 10 | constexpr const char * ClBackendId() { return "GpuAcc"; } 11 | 12 | } // namespace armnn 13 | -------------------------------------------------------------------------------- /src/backends/cl/ClContextSchema.fbs: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2020 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | namespace armnn; 7 | 8 | file_identifier "ARMN"; 9 | 10 | file_extension "armnn"; 11 | 12 | table ClContext { 13 | programs:[Program]; 14 | } 15 | 16 | table Program { 17 | name:string; 18 | binary:[ubyte]; 19 | } 20 | 21 | root_type ClContext; -------------------------------------------------------------------------------- /src/backends/cl/backend.cmake: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright © 2017 Arm Ltd. All rights reserved. 3 | # SPDX-License-Identifier: MIT 4 | # 5 | 6 | add_subdirectory(${PROJECT_SOURCE_DIR}/src/backends/cl) 7 | list(APPEND armnnLibraries armnnClBackend) 8 | 9 | if(ARMCOMPUTECL) 10 | list(APPEND armnnLibraries armnnClBackendWorkloads) 11 | list(APPEND armnnUnitTestLibraries armnnClBackendUnitTests) 12 | else() 13 | message(STATUS "CL backend is disabled") 14 | endif() 15 | -------------------------------------------------------------------------------- /src/backends/cl/test/ClContextControlFixture.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include 9 | #include 10 | 11 | template 12 | struct ClContextControlFixtureBase 13 | { 14 | // Initialising ClContextControl to ensure OpenCL is loaded correctly for each test case 15 | ClContextControlFixtureBase() 16 | : m_ClContextControl(nullptr, nullptr, ProfilingEnabled) {} 17 | 18 | armnn::ClContextControl m_ClContextControl; 19 | }; 20 | 21 | using ClContextControlFixture = ClContextControlFixtureBase; 22 | using ClProfilingContextControlFixture = ClContextControlFixtureBase; 23 | -------------------------------------------------------------------------------- /src/backends/cl/test/ClJsonPrinterTests.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #include 7 | 8 | #include 9 | #include 10 | 11 | #include 12 | 13 | #include 14 | 15 | TEST_CASE_FIXTURE(ClProfilingContextControlFixture, "SoftmaxProfilerJsonPrinterGpuAccTest") 16 | { 17 | std::vector backends = {armnn::Compute::GpuAcc}; 18 | RunSoftmaxProfilerJsonPrinterTest(backends); 19 | 20 | } -------------------------------------------------------------------------------- /src/backends/cl/workloads/ClFillWorkload.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2020 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include 9 | #include "ClBaseWorkload.hpp" 10 | #include 11 | 12 | namespace armnn { 13 | 14 | class ClFillWorkload : public ClBaseWorkload 15 | { 16 | public: 17 | ClFillWorkload(const FillQueueDescriptor& descriptor, 18 | const WorkloadInfo& info, 19 | const arm_compute::CLCompileContext& clCompileContext); 20 | void Execute() const override; 21 | 22 | private: 23 | mutable arm_compute::CLFill m_Layer; 24 | }; 25 | 26 | } //namespace armnn 27 | -------------------------------------------------------------------------------- /src/backends/dynamic/reference/RefDynamicBackend.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #include "RefDynamicBackend.hpp" 7 | 8 | #include 9 | 10 | using namespace armnn; 11 | 12 | const char* GetBackendId() 13 | { 14 | return RefBackend::GetIdStatic().Get().c_str(); 15 | } 16 | 17 | void GetVersion(uint32_t* outMajor, uint32_t* outMinor) 18 | { 19 | if (!outMajor || !outMinor) 20 | { 21 | return; 22 | } 23 | 24 | BackendVersion apiVersion = IBackendInternal::GetApiVersion(); 25 | 26 | *outMajor = apiVersion.m_Major; 27 | *outMinor = apiVersion.m_Minor; 28 | } 29 | 30 | void* BackendFactory() 31 | { 32 | return new RefBackend(); 33 | } 34 | -------------------------------------------------------------------------------- /src/backends/dynamic/reference/RefDynamicBackend.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include 9 | 10 | extern "C" 11 | { 12 | const char* GetBackendId(); 13 | void GetVersion(uint32_t* outMajor, uint32_t* outMinor); 14 | void* BackendFactory(); 15 | } 16 | -------------------------------------------------------------------------------- /src/backends/neon/NeonBackendId.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | #pragma once 6 | 7 | namespace armnn 8 | { 9 | 10 | constexpr const char * NeonBackendId() { return "CpuAcc"; } 11 | 12 | } // namespace armnn 13 | -------------------------------------------------------------------------------- /src/backends/neon/backend.cmake: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright © 2017 Arm Ltd. All rights reserved. 3 | # SPDX-License-Identifier: MIT 4 | # 5 | 6 | add_subdirectory(${PROJECT_SOURCE_DIR}/src/backends/neon) 7 | list(APPEND armnnLibraries armnnNeonBackend) 8 | 9 | if(ARMCOMPUTENEON) 10 | list(APPEND armnnLibraries armnnNeonBackendWorkloads) 11 | list(APPEND armnnUnitTestLibraries armnnNeonBackendUnitTests) 12 | else() 13 | message(STATUS "NEON backend is disabled") 14 | endif() 15 | -------------------------------------------------------------------------------- /src/backends/neon/test/NeonJsonPrinterTests.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #include 7 | 8 | #include 9 | 10 | #include 11 | 12 | #include 13 | 14 | TEST_SUITE("NeonJsonPrinter") 15 | { 16 | TEST_CASE("SoftmaxProfilerJsonPrinterCpuAccTest") 17 | { 18 | std::vector backends = {armnn::Compute::CpuAcc}; 19 | RunSoftmaxProfilerJsonPrinterTest(backends); 20 | } 21 | 22 | } -------------------------------------------------------------------------------- /src/backends/neon/workloads/NeonAbsWorkload.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "NeonBaseWorkload.hpp" 9 | 10 | #include 11 | #include 12 | 13 | namespace armnn 14 | { 15 | 16 | arm_compute::Status NeonAbsWorkloadValidate(const TensorInfo& input, const TensorInfo& output); 17 | 18 | class NeonAbsWorkload : public NeonBaseWorkload 19 | { 20 | public: 21 | NeonAbsWorkload(const AbsQueueDescriptor& descriptor, const WorkloadInfo& info); 22 | virtual void Execute() const override; 23 | 24 | private: 25 | mutable arm_compute::NEAbsLayer m_AbsLayer; 26 | }; 27 | 28 | } // namespace armnn 29 | -------------------------------------------------------------------------------- /src/backends/neon/workloads/NeonCastWorkload.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2021 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "NeonBaseWorkload.hpp" 9 | 10 | #include 11 | #include 12 | 13 | namespace armnn 14 | { 15 | 16 | arm_compute::Status NeonCastValidate(const TensorInfo& input, const TensorInfo& output); 17 | 18 | class NeonCastWorkload : public NeonBaseWorkload 19 | { 20 | public: 21 | NeonCastWorkload(const CastQueueDescriptor& descriptor, const WorkloadInfo& info); 22 | virtual void Execute() const override; 23 | 24 | private: 25 | mutable arm_compute::NECast m_CastLayer; 26 | }; 27 | 28 | } // namespace armnn 29 | -------------------------------------------------------------------------------- /src/backends/neon/workloads/NeonConstantWorkload.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "NeonBaseWorkload.hpp" 9 | 10 | #include 11 | 12 | namespace armnn 13 | { 14 | arm_compute::Status NeonConstantWorkloadValidate(const TensorInfo& output); 15 | 16 | class NeonConstantWorkload : public NeonBaseWorkload 17 | { 18 | public: 19 | NeonConstantWorkload(const ConstantQueueDescriptor& descriptor, const WorkloadInfo& info); 20 | 21 | virtual void Execute() const override; 22 | 23 | private: 24 | mutable bool m_RanOnce; 25 | }; 26 | 27 | } //namespace armnn 28 | -------------------------------------------------------------------------------- /src/backends/neon/workloads/NeonFillWorkload.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2020 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include 9 | #include "NeonBaseWorkload.hpp" 10 | #include 11 | #include 12 | 13 | namespace armnn { 14 | 15 | class NeonFillWorkload : public NeonBaseWorkload 16 | { 17 | public: 18 | NeonFillWorkload(const FillQueueDescriptor& descriptor, const WorkloadInfo& info); 19 | void Execute() const override; 20 | 21 | private: 22 | std::unique_ptr m_Layer; 23 | }; 24 | 25 | } //namespace armnn 26 | -------------------------------------------------------------------------------- /src/backends/neon/workloads/NeonLogWorkload.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2021 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "NeonBaseWorkload.hpp" 9 | #include 10 | #include 11 | 12 | namespace armnn 13 | { 14 | 15 | arm_compute::Status NeonLogWorkloadValidate(const TensorInfo& input, const TensorInfo& output); 16 | 17 | class NeonLogWorkload : public NeonBaseWorkload 18 | { 19 | public: 20 | NeonLogWorkload(const ElementwiseUnaryQueueDescriptor& descriptor, const WorkloadInfo& info); 21 | virtual void Execute() const override; 22 | 23 | private: 24 | mutable arm_compute::NELogLayer m_LogLayer; 25 | }; 26 | 27 | } //namespace armnn -------------------------------------------------------------------------------- /src/backends/neon/workloads/NeonQuantizeWorkload.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "NeonBaseWorkload.hpp" 9 | 10 | #include 11 | 12 | namespace armnn { 13 | 14 | arm_compute::Status NeonQuantizeWorkloadValidate(const TensorInfo& input, const TensorInfo& output); 15 | 16 | class NeonQuantizeWorkload : public NeonBaseWorkload 17 | { 18 | public: 19 | NeonQuantizeWorkload(const QuantizeQueueDescriptor& descriptor, const WorkloadInfo& workloadInfo); 20 | void Execute() const override; 21 | 22 | private: 23 | mutable std::unique_ptr m_Layer; 24 | }; 25 | 26 | } // namespace armnn 27 | -------------------------------------------------------------------------------- /src/backends/neon/workloads/NeonRsqrtWorkload.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2019 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "NeonBaseWorkload.hpp" 9 | 10 | #include 11 | #include 12 | 13 | namespace armnn 14 | { 15 | 16 | arm_compute::Status NeonRsqrtWorkloadValidate(const TensorInfo& input, const TensorInfo& output); 17 | 18 | class NeonRsqrtWorkload : public NeonBaseWorkload 19 | { 20 | public: 21 | NeonRsqrtWorkload(const RsqrtQueueDescriptor& descriptor, const WorkloadInfo& info); 22 | virtual void Execute() const override; 23 | 24 | private: 25 | mutable arm_compute::NERsqrtLayer m_RsqrtLayer; 26 | }; 27 | 28 | } // namespace armnn 29 | -------------------------------------------------------------------------------- /src/backends/neon/workloads/NeonSinWorkload.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2021 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "NeonBaseWorkload.hpp" 9 | #include 10 | #include 11 | 12 | namespace armnn 13 | { 14 | 15 | arm_compute::Status NeonSinWorkloadValidate(const TensorInfo& input, const TensorInfo& output); 16 | 17 | class NeonSinWorkload : public NeonBaseWorkload 18 | { 19 | public: 20 | NeonSinWorkload(const ElementwiseUnaryQueueDescriptor& descriptor, const WorkloadInfo& info); 21 | virtual void Execute() const override; 22 | 23 | private: 24 | mutable arm_compute::NESinLayer m_SinLayer; 25 | }; 26 | 27 | } //namespace armnn -------------------------------------------------------------------------------- /src/backends/neon/workloads/NeonSqrtWorkload.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2022 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "NeonBaseWorkload.hpp" 9 | #include 10 | #include 11 | 12 | namespace armnn 13 | { 14 | 15 | arm_compute::Status NeonSqrtWorkloadValidate(const TensorInfo& input, const TensorInfo& output); 16 | 17 | class NeonSqrtWorkload : public NeonBaseWorkload 18 | { 19 | public: 20 | NeonSqrtWorkload(const ElementwiseUnaryQueueDescriptor& descriptor, const WorkloadInfo& info); 21 | virtual void Execute() const override; 22 | 23 | private: 24 | mutable arm_compute::NEActivationLayer m_SqrtLayer; 25 | }; 26 | 27 | } //namespace armnn -------------------------------------------------------------------------------- /src/backends/reference/RefBackendId.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | #pragma once 6 | 7 | namespace armnn 8 | { 9 | 10 | constexpr const char * RefBackendId() { return "CpuRef"; } 11 | 12 | } // namespace armnn 13 | -------------------------------------------------------------------------------- /src/backends/reference/RefRegistryInitializer.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #include "RefBackend.hpp" 7 | 8 | #include 9 | 10 | namespace 11 | { 12 | 13 | using namespace armnn; 14 | 15 | static BackendRegistry::StaticRegistryInitializer g_RegisterHelper 16 | { 17 | BackendRegistryInstance(), 18 | RefBackend::GetIdStatic(), 19 | []() 20 | { 21 | return IBackendInternalUniquePtr(new RefBackend); 22 | } 23 | }; 24 | 25 | } // Anonymous namespace 26 | -------------------------------------------------------------------------------- /src/backends/reference/backend.cmake: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright © 2017 Arm Ltd. All rights reserved. 3 | # SPDX-License-Identifier: MIT 4 | # 5 | 6 | add_subdirectory(${PROJECT_SOURCE_DIR}/src/backends/reference) 7 | list(APPEND armnnLibraries armnnRefBackend) 8 | 9 | if(ARMNNREF) 10 | list(APPEND armnnLibraries armnnRefBackendWorkloads) 11 | list(APPEND armnnUnitTestLibraries armnnRefBackendUnitTests) 12 | else() 13 | message(STATUS "Reference backend is disabled") 14 | endif() 15 | -------------------------------------------------------------------------------- /src/backends/reference/test/RefJsonPrinterTests.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #include 7 | 8 | #include 9 | 10 | #include 11 | 12 | #include 13 | 14 | TEST_SUITE("RefJsonPrinter") 15 | { 16 | TEST_CASE("SoftmaxProfilerJsonPrinterCpuRefTest") 17 | { 18 | std::vector backends = {armnn::Compute::CpuRef}; 19 | RunSoftmaxProfilerJsonPrinterTest(backends); 20 | } 21 | 22 | } -------------------------------------------------------------------------------- /src/backends/reference/workloads/Abs.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2019 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include 9 | 10 | namespace armnn 11 | { 12 | template 13 | struct abs 14 | { 15 | typedef T result_type; 16 | typedef T argument_type; 17 | 18 | T 19 | operator () (const T& inputData) const 20 | { 21 | return std::abs(inputData); 22 | } 23 | }; 24 | 25 | } //namespace armnn 26 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/Activation.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #include "BaseIterator.hpp" 7 | 8 | #include 9 | #include 10 | 11 | namespace armnn 12 | { 13 | float Activation(float in, 14 | ActivationFunction function, 15 | float a, 16 | float b); 17 | 18 | void Activation(Decoder& in, 19 | Encoder& out, 20 | const TensorInfo& tensorInfo, 21 | ActivationFunction function, 22 | float a, 23 | float b); 24 | 25 | } //namespace armnn 26 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/ArgMinMax.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2019 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "armnn/Tensor.hpp" 9 | #include "armnn/Descriptors.hpp" 10 | 11 | #include "Decoders.hpp" 12 | 13 | namespace armnn 14 | { 15 | 16 | template 17 | void ArgMinMax(Decoder& in, OUT *out, const TensorInfo& inputTensorInfo, 18 | const TensorInfo& outputTensorInfo, ArgMinMaxFunction function, int axis); 19 | 20 | } //namespace armnn 21 | 22 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/BatchNormImpl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "Encoders.hpp" 9 | #include "Decoders.hpp" 10 | 11 | #include 12 | 13 | namespace armnn 14 | { 15 | 16 | void BatchNormImpl(const BatchNormalizationQueueDescriptor& data, 17 | Decoder& meanIn, 18 | Decoder& varIn, 19 | Decoder& betaIn, 20 | Decoder& gammaIn, 21 | Decoder& inputData, 22 | Encoder& outputData); 23 | 24 | } // namespace armnn 25 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/BatchToSpaceNd.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017-2019,2021,2023 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "BaseIterator.hpp" 9 | #include "Decoders.hpp" 10 | #include "Encoders.hpp" 11 | 12 | #include 13 | 14 | namespace armnn 15 | { 16 | 17 | void BatchToSpaceNd(const TensorInfo& inputInfo, 18 | const TensorInfo& outputInfo, 19 | const BatchToSpaceNdDescriptor& params, 20 | Decoder& inputData, 21 | Encoder& outputData); 22 | 23 | } // namespace armnn 24 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/Ceil.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2023 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include 9 | 10 | namespace armnn 11 | { 12 | template 13 | struct ceil 14 | { 15 | typedef T result_type; 16 | typedef T argument_type; 17 | 18 | T 19 | operator () (const T& inputData) const 20 | { 21 | return std::ceil(inputData); 22 | } 23 | }; 24 | 25 | } //namespace armnn 26 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/Concatenate.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include 9 | #include 10 | 11 | namespace armnn 12 | { 13 | void Concatenate(const ConcatQueueDescriptor &data, 14 | std::vector inputs, 15 | std::vector outputs); 16 | } //namespace armnn 17 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/Debug.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | #pragma once 6 | 7 | #include 8 | 9 | namespace armnn 10 | { 11 | template 12 | void Debug(const TensorInfo& inputInfo, 13 | const T* inputData, 14 | LayerGuid guid, 15 | const std::string& layerName, 16 | unsigned int slotIndex, 17 | bool outputsToFile); 18 | 19 | } //namespace armnn 20 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/DepthToSpace.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2019 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include 9 | #include 10 | 11 | namespace armnn 12 | { 13 | 14 | void DepthToSpace(const TensorInfo& inputInfo, 15 | const DepthToSpaceDescriptor& descriptor, 16 | const void* inputData, 17 | void* outputData, 18 | unsigned int dataTypeSize); 19 | 20 | } // namespace armnn 21 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/Dequantize.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2019 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include 9 | #include "Encoders.hpp" 10 | #include "Decoders.hpp" 11 | 12 | namespace armnn 13 | { 14 | 15 | void Dequantize(Decoder& inputDecoder, 16 | Encoder& outputEncoder, 17 | const TensorInfo& inputInfo, 18 | const TensorInfo& outputInfo); 19 | 20 | } //namespace armnn 21 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/Exp.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2019 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include 9 | 10 | namespace armnn 11 | { 12 | template 13 | struct exp 14 | { 15 | typedef T result_type; 16 | typedef T argument_type; 17 | 18 | T 19 | operator () (const T& inputData) const 20 | { 21 | return std::exp(inputData); 22 | } 23 | }; 24 | 25 | } //namespace armnn 26 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/Fill.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2020 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #include "Fill.hpp" 7 | 8 | #include "RefWorkloadUtils.hpp" 9 | 10 | namespace armnn 11 | { 12 | 13 | void Fill(Encoder& output, 14 | const TensorShape& desiredOutputShape, 15 | const float value) 16 | { 17 | for(unsigned int i = 0; i < desiredOutputShape.GetNumElements(); ++i) 18 | { 19 | output[i]; 20 | output.Set(value); 21 | } 22 | } 23 | 24 | } //namespace armnn 25 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/Fill.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2020 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "BaseIterator.hpp" 9 | #include "Decoders.hpp" 10 | #include "Encoders.hpp" 11 | #include 12 | #include 13 | 14 | namespace armnn 15 | { 16 | 17 | /// Creates a tensor and fills it with a scalar value. 18 | void Fill(Encoder& output, 19 | const TensorShape& desiredOutputShape, 20 | const float value); 21 | 22 | } //namespace armnn 23 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/FloorDiv.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2024 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | namespace armnn 9 | { 10 | 11 | template 12 | struct floorDiv 13 | { 14 | typedef T result_type; 15 | typedef T first_argument_type; 16 | T operator () (const T& inputData0, const T& inputData1) const 17 | { 18 | double result = static_cast(inputData0)/static_cast(inputData1); 19 | return static_cast(std::floor(result)); 20 | } 21 | }; 22 | 23 | } //namespace armnn 24 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/Gather.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017, 2024 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "armnn/Tensor.hpp" 9 | 10 | #include "BaseIterator.hpp" 11 | #include "Decoders.hpp" 12 | #include "Encoders.hpp" 13 | 14 | namespace armnn 15 | { 16 | template 17 | void Gather(const TensorInfo& paramsInfo, 18 | const TensorInfo& indicesInfo, 19 | const TensorInfo& outputInfo, 20 | Decoder& params, 21 | const int32_t* indices, 22 | Encoder& output, 23 | const int32_t = 0); 24 | 25 | } //namespace armnn 26 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/InstanceNorm.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2019 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "Encoders.hpp" 9 | #include "Decoders.hpp" 10 | 11 | #include 12 | 13 | namespace armnn 14 | { 15 | 16 | void InstanceNorm(const InstanceNormalizationQueueDescriptor& data, 17 | const TensorInfo& inputInfo, 18 | Decoder& inputData, 19 | Encoder& outputData); 20 | 21 | } // namespace armnn 22 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/Log.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2021 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include 9 | 10 | namespace armnn 11 | { 12 | template 13 | struct log 14 | { 15 | typedef T result_type; 16 | typedef T argument_type; 17 | 18 | T 19 | operator () (const T& inputData) const 20 | { 21 | // computes natural logarithm of inputData 22 | return std::log(inputData); 23 | } 24 | }; 25 | 26 | } //namespace armnn 27 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/LogSoftmax.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2019 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include 9 | #include 10 | 11 | #include "BaseIterator.hpp" 12 | 13 | namespace armnn 14 | { 15 | 16 | void LogSoftmax(Decoder& input, 17 | Encoder& output, 18 | const TensorInfo& inputInfo, 19 | const LogSoftmaxDescriptor& descriptor); 20 | 21 | } // namespace armnn 22 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/Maximum.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | 9 | 10 | namespace armnn 11 | { 12 | template 13 | struct maximum 14 | { 15 | typedef T result_type; 16 | typedef T first_argument_type; 17 | 18 | T operator () (const T& inputData0, const T& inputData1) const 19 | { 20 | return std::max(inputData0, inputData1); 21 | } 22 | }; 23 | } //namespace armnn 24 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/Minimum.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | namespace armnn 9 | { 10 | 11 | template 12 | struct minimum 13 | { 14 | typedef T result_type; 15 | typedef T first_argument_type; 16 | 17 | T 18 | operator()(const T& input1, const T& input2) const 19 | { 20 | return std::min(input1, input2); 21 | } 22 | }; 23 | 24 | } //namespace armnn 25 | 26 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/MirrorPad.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2021 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "armnn/Tensor.hpp" 9 | 10 | #include 11 | #include 12 | 13 | namespace armnn 14 | { 15 | 16 | void MirrorPad(const TensorInfo& inputInfo, 17 | const TensorInfo& outputInfo, 18 | const ITensorHandle* inputHandle, 19 | ITensorHandle* outputHandle, 20 | const PadQueueDescriptor& data); 21 | 22 | } //namespace armnn 23 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/Pad.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "armnn/Tensor.hpp" 9 | 10 | #include 11 | #include 12 | 13 | namespace armnn 14 | { 15 | 16 | void Pad(const TensorInfo& inputInfo, 17 | const TensorInfo& outputInfo, 18 | const ITensorHandle* inputHandle, 19 | ITensorHandle* outputHandle, 20 | const PadQueueDescriptor& data); 21 | 22 | } //namespace armnn 23 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/Pooling2d.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include 9 | #include 10 | 11 | #include "BaseIterator.hpp" 12 | 13 | namespace armnn 14 | { 15 | /// Computes the Pooling2d operation. 16 | void Pooling2d(Decoder& rInputDecoder, 17 | Encoder& rOutputEncoder, 18 | const TensorInfo& inputInfo, 19 | const TensorInfo& outputInfo, 20 | const Pooling2dDescriptor& params); 21 | } //namespace armnn 22 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/Pooling3d.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2021 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include 9 | #include 10 | 11 | #include "BaseIterator.hpp" 12 | 13 | namespace armnn 14 | { 15 | /// Computes the Pooling3d operation. 16 | void Pooling3d(Decoder& rInputDecoder, 17 | Encoder& rOutputEncoder, 18 | const TensorInfo& inputInfo, 19 | const TensorInfo& outputInfo, 20 | const Pooling3dDescriptor& params); 21 | } //namespace armnn 22 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/Power.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2023 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include 9 | 10 | namespace armnn 11 | { 12 | 13 | template 14 | struct power 15 | { 16 | typedef T result_type; 17 | typedef T first_argument_type; 18 | 19 | T 20 | operator()(const T& input1, const T& input2) const 21 | { 22 | T power = armnn::numeric_cast(std::pow(static_cast(input1), static_cast(input2))); 23 | return power; 24 | } 25 | }; 26 | 27 | } //namespace armnn 28 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/PreluImpl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "Encoders.hpp" 9 | #include "Decoders.hpp" 10 | 11 | #include 12 | 13 | namespace armnn 14 | { 15 | 16 | void PreluImpl(const TensorInfo& inputInfo, 17 | const TensorInfo& alphaInfo, 18 | const TensorInfo& outputInfo, 19 | Decoder& inputData, 20 | Decoder& alphaData, 21 | Encoder& outputData); 22 | 23 | } // namespace armnn 24 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/Reduce.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2021 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "BaseIterator.hpp" 9 | #include "Decoders.hpp" 10 | #include "Encoders.hpp" 11 | 12 | #include 13 | 14 | namespace armnn 15 | { 16 | 17 | void Reduce(const TensorInfo& inputInfo, 18 | const TensorInfo& outputInfo, 19 | Decoder& input, 20 | Encoder& output, 21 | const std::vector axis, 22 | const ReduceOperation reduceOperation); 23 | 24 | } //namespace armnn 25 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/RefActivationWorkload.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2022, 2024 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "RefBaseWorkload.hpp" 9 | #include 10 | 11 | namespace armnn 12 | { 13 | 14 | class RefActivationWorkload : public RefBaseWorkload 15 | { 16 | public: 17 | using RefBaseWorkload::RefBaseWorkload; 18 | void Execute() const override; 19 | 20 | private: 21 | void Execute(std::vector inputs, std::vector outputs) const; 22 | }; 23 | 24 | } //namespace armnn 25 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/RefArgMinMaxWorkload.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2022, 2024 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "RefBaseWorkload.hpp" 9 | #include 10 | 11 | namespace armnn 12 | { 13 | class RefArgMinMaxWorkload : public RefBaseWorkload 14 | { 15 | public: 16 | explicit RefArgMinMaxWorkload(const ArgMinMaxQueueDescriptor& descriptor, 17 | const WorkloadInfo& info); 18 | 19 | void Execute() const override; 20 | 21 | private: 22 | void Execute(std::vector inputs, std::vector outputs) const; 23 | }; 24 | } //namespace armnn -------------------------------------------------------------------------------- /src/backends/reference/workloads/RefBatchMatMulWorkload.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2022, 2024 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "RefBaseWorkload.hpp" 9 | #include 10 | 11 | #include "BatchMatMulImpl.hpp" 12 | 13 | namespace armnn 14 | { 15 | 16 | class RefBatchMatMulWorkload : public RefBaseWorkload 17 | { 18 | public: 19 | explicit RefBatchMatMulWorkload(const BatchMatMulQueueDescriptor& descriptor, 20 | const WorkloadInfo& info); 21 | 22 | void Execute() const override; 23 | 24 | private: 25 | void Execute(std::vector inputs, std::vector outputs) const; 26 | 27 | }; 28 | 29 | } // namespace armnn -------------------------------------------------------------------------------- /src/backends/reference/workloads/RefBatchToSpaceNdWorkload.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2018-2019,2021-2024 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "RefBaseWorkload.hpp" 9 | 10 | namespace armnn 11 | { 12 | 13 | class RefBatchToSpaceNdWorkload : public RefBaseWorkload 14 | { 15 | 16 | public: 17 | using RefBaseWorkload::RefBaseWorkload; 18 | 19 | void Execute() const override; 20 | 21 | private: 22 | void Execute(std::vector inputs, std::vector outputs) const; 23 | }; 24 | 25 | } // namespace armnn -------------------------------------------------------------------------------- /src/backends/reference/workloads/RefBroadcastToWorkload.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2023-2024 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "RefBaseWorkload.hpp" 9 | 10 | namespace armnn 11 | { 12 | class RefBroadcastToWorkload : public RefBaseWorkload 13 | { 14 | 15 | public: 16 | explicit RefBroadcastToWorkload(const BroadcastToQueueDescriptor& descriptor, 17 | const WorkloadInfo& info); 18 | 19 | void Execute() const override; 20 | 21 | private: 22 | void Execute(std::vector inputs, std::vector outputs) const; 23 | }; 24 | } // namespace armnn -------------------------------------------------------------------------------- /src/backends/reference/workloads/RefCastWorkload.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2022, 2024 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "RefBaseWorkload.hpp" 9 | #include 10 | #include "RefWorkloadUtils.hpp" 11 | 12 | namespace armnn 13 | { 14 | 15 | 16 | class RefCastWorkload : public RefBaseWorkload 17 | { 18 | public: 19 | using RefBaseWorkload::RefBaseWorkload; 20 | void Execute() const override; 21 | private: 22 | void Execute(std::vector inputs, std::vector outputs) const; 23 | }; 24 | 25 | } //namespace armnn 26 | 27 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/RefChannelShuffleWorkload.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2022, 2024 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "RefBaseWorkload.hpp" 9 | #include 10 | 11 | namespace armnn 12 | { 13 | 14 | class RefChannelShuffleWorkload : public RefBaseWorkload 15 | { 16 | public: 17 | using RefBaseWorkload::RefBaseWorkload; 18 | void Execute() const override; 19 | 20 | private: 21 | void Execute(std::vector inputs, std::vector outputs) const; 22 | }; 23 | 24 | } // namespace armnn -------------------------------------------------------------------------------- /src/backends/reference/workloads/RefConcatWorkload.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017,2019-2024 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #include "RefConcatWorkload.hpp" 7 | #include "Concatenate.hpp" 8 | #include "Profiling.hpp" 9 | #include "RefWorkloadUtils.hpp" 10 | 11 | namespace armnn 12 | { 13 | 14 | void RefConcatWorkload::Execute() const 15 | { 16 | Execute(m_Data.m_Inputs, m_Data.m_Outputs); 17 | } 18 | 19 | void RefConcatWorkload::Execute(std::vector inputs, std::vector outputs) const 20 | { 21 | ARMNN_SCOPED_PROFILING_EVENT_REF_NAME_GUID("RefConcatWorkload_Execute"); 22 | Concatenate(m_Data, inputs, outputs); 23 | } 24 | 25 | } //namespace armnn 26 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/RefConcatWorkload.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2022, 2024 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "RefBaseWorkload.hpp" 9 | #include 10 | 11 | namespace armnn 12 | { 13 | 14 | class RefConcatWorkload : public RefBaseWorkload 15 | { 16 | public: 17 | using RefBaseWorkload::RefBaseWorkload; 18 | void Execute() const override; 19 | 20 | private: 21 | void Execute(std::vector inputs, std::vector outputs) const; 22 | }; 23 | 24 | } //namespace armnn 25 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/RefConstantWorkload.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2022, 2024 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "RefBaseWorkload.hpp" 9 | #include 10 | 11 | #include 12 | 13 | namespace armnn 14 | { 15 | 16 | // Base class template providing an implementation of the Constant layer common to all data types. 17 | class RefConstantWorkload : public RefBaseWorkload 18 | { 19 | public: 20 | RefConstantWorkload(const ConstantQueueDescriptor& descriptor, const WorkloadInfo& info); 21 | 22 | void Execute() const override; 23 | 24 | private: 25 | void Execute(std::vector outputs) const; 26 | }; 27 | 28 | } //namespace armnn 29 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/RefConvertFp16ToFp32Workload.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2022, 2024 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "RefBaseWorkload.hpp" 9 | #include 10 | 11 | namespace armnn 12 | { 13 | 14 | class RefConvertFp16ToFp32Workload : public Float16ToFloat32Workload 15 | { 16 | public: 17 | using Float16ToFloat32Workload::Float16ToFloat32Workload; 18 | void Execute() const override; 19 | private: 20 | void Execute(std::vector inputs, std::vector outputs) const; 21 | }; 22 | 23 | } //namespace armnn 24 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/RefConvertFp32ToFp16Workload.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2022, 2024 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "RefBaseWorkload.hpp" 9 | #include 10 | 11 | namespace armnn 12 | { 13 | 14 | class RefConvertFp32ToFp16Workload : public Float32ToFloat16Workload 15 | { 16 | public: 17 | using Float32ToFloat16Workload::Float32ToFloat16Workload; 18 | void Execute() const override; 19 | 20 | private: 21 | void Execute(std::vector inputs, std::vector outputs) const; 22 | }; 23 | 24 | } //namespace armnn 25 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/RefDepthToSpaceWorkload.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2022, 2024 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "RefBaseWorkload.hpp" 9 | 10 | namespace armnn 11 | { 12 | 13 | class RefDepthToSpaceWorkload : public RefBaseWorkload 14 | { 15 | public: 16 | using RefBaseWorkload::RefBaseWorkload; 17 | void Execute() const override; 18 | 19 | private: 20 | void Execute(std::vector inputs, std::vector outputs) const; 21 | }; 22 | 23 | } // namespace armnn 24 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/RefDequantizeWorkload.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2022, 2024 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "RefBaseWorkload.hpp" 9 | 10 | namespace armnn 11 | { 12 | 13 | class RefDequantizeWorkload : public RefBaseWorkload 14 | { 15 | public: 16 | using RefBaseWorkload::m_Data; 17 | using RefBaseWorkload::RefBaseWorkload; 18 | 19 | void Execute() const override; 20 | 21 | private: 22 | void Execute(std::vector inputs, std::vector outputs) const; 23 | }; 24 | 25 | } // namespace armnn 26 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/RefFakeQuantizationFloat32Workload.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2022, 2024 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "RefBaseWorkload.hpp" 9 | #include 10 | 11 | namespace armnn 12 | { 13 | 14 | class RefFakeQuantizationFloat32Workload : public Float32Workload 15 | { 16 | public: 17 | using Float32Workload::Float32Workload; 18 | void Execute() const override; 19 | private: 20 | void Execute(std::vector inputs, std::vector outputs) const; 21 | }; 22 | 23 | } //namespace armnn 24 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/RefFillWorkload.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2022, 2024 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "RefBaseWorkload.hpp" 9 | #include 10 | 11 | namespace armnn 12 | { 13 | 14 | class RefFillWorkload : public RefBaseWorkload 15 | { 16 | public: 17 | using RefBaseWorkload::RefBaseWorkload; 18 | void Execute() const override; 19 | 20 | private: 21 | void Execute(std::vector outputs) const; 22 | }; 23 | 24 | } //namespace armnn 25 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/RefFloorWorkload.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2022, 2024 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "RefBaseWorkload.hpp" 9 | #include 10 | 11 | namespace armnn 12 | { 13 | 14 | class RefFloorWorkload : public RefBaseWorkload 15 | { 16 | public: 17 | using RefBaseWorkload::RefBaseWorkload; 18 | void Execute() const override; 19 | 20 | private: 21 | void Execute(std::vector inputs, std::vector outputs) const; 22 | }; 23 | 24 | } //namespace armnn 25 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/RefGatherNdWorkload.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2022, 2024 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "RefBaseWorkload.hpp" 9 | 10 | namespace armnn 11 | { 12 | 13 | class RefGatherNdWorkload : public RefBaseWorkload 14 | { 15 | public: 16 | using RefBaseWorkload::RefBaseWorkload; 17 | void Execute() const override; 18 | 19 | private: 20 | void Execute(std::vector inputs, std::vector outputs) const; 21 | 22 | }; 23 | 24 | } // namespace armnn 25 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/RefGatherWorkload.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2022, 2024 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "RefBaseWorkload.hpp" 9 | #include 10 | 11 | #include 12 | #include "BaseIterator.hpp" 13 | #include "Decoders.hpp" 14 | #include "Encoders.hpp" 15 | 16 | namespace armnn 17 | { 18 | 19 | class RefGatherWorkload : public RefBaseWorkload 20 | { 21 | public: 22 | using RefBaseWorkload::RefBaseWorkload; 23 | void Execute() const override; 24 | 25 | private: 26 | template 27 | void Execute(std::vector inputs, std::vector outputs) const; 28 | }; 29 | 30 | } // namespace armnn 31 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/RefInstanceNormalizationWorkload.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2022, 2024 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "RefBaseWorkload.hpp" 9 | #include 10 | 11 | namespace armnn 12 | { 13 | 14 | class RefInstanceNormalizationWorkload : public RefBaseWorkload 15 | { 16 | public: 17 | explicit RefInstanceNormalizationWorkload(const InstanceNormalizationQueueDescriptor& descriptor, 18 | const WorkloadInfo& info); 19 | void Execute() const override; 20 | 21 | private: 22 | void Execute(std::vector inputs, std::vector outputs) const; 23 | }; 24 | 25 | } //namespace armnn 26 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/RefL2NormalizationWorkload.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2022, 2024 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "RefBaseWorkload.hpp" 9 | #include 10 | 11 | namespace armnn 12 | { 13 | 14 | class RefL2NormalizationWorkload : public RefBaseWorkload 15 | { 16 | public: 17 | explicit RefL2NormalizationWorkload(const L2NormalizationQueueDescriptor& descriptor, 18 | const WorkloadInfo& info); 19 | 20 | void Execute() const override; 21 | 22 | private: 23 | void Execute(std::vector inputs, std::vector outputs) const; 24 | }; 25 | 26 | } //namespace armnn 27 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/RefLogSoftmaxWorkload.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2022, 2024 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "RefBaseWorkload.hpp" 9 | #include 10 | 11 | namespace armnn 12 | { 13 | 14 | class RefLogSoftmaxWorkload : public RefBaseWorkload 15 | { 16 | public: 17 | using RefBaseWorkload::RefBaseWorkload; 18 | void Execute() const override; 19 | 20 | private: 21 | void Execute(std::vector inputs, std::vector outputs) const; 22 | }; 23 | 24 | } // namespace armnn 25 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/RefMeanWorkload.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2022, 2024 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "RefBaseWorkload.hpp" 9 | #include 10 | 11 | #include "Decoders.hpp" 12 | #include "Encoders.hpp" 13 | 14 | namespace armnn 15 | { 16 | 17 | class RefMeanWorkload : public RefBaseWorkload 18 | { 19 | public: 20 | explicit RefMeanWorkload (const MeanQueueDescriptor& descriptor, const WorkloadInfo& info); 21 | void Execute() const override; 22 | 23 | private: 24 | void Execute(std::vector inputs, std::vector outputs) const; 25 | }; 26 | 27 | } //namespace armnn 28 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/RefNormalizationWorkload.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2022, 2024 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "RefBaseWorkload.hpp" 9 | #include 10 | 11 | namespace armnn 12 | { 13 | 14 | class RefNormalizationWorkload : public RefBaseWorkload 15 | { 16 | public: 17 | explicit RefNormalizationWorkload(const NormalizationQueueDescriptor& descriptor, 18 | const WorkloadInfo& info); 19 | 20 | void Execute() const override; 21 | 22 | private: 23 | void Execute(std::vector inputs, std::vector outputs) const; 24 | }; 25 | 26 | } // namespace armnn 27 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/RefPadWorkload.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2022, 2024 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "RefBaseWorkload.hpp" 9 | #include 10 | 11 | namespace armnn 12 | { 13 | 14 | class RefPadWorkload : public RefBaseWorkload 15 | { 16 | public: 17 | using RefBaseWorkload::RefBaseWorkload; 18 | void Execute() const override; 19 | 20 | private: 21 | void Execute(std::vector inputs, std::vector outputs) const; 22 | }; 23 | 24 | } //namespace armnn 25 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/RefPooling2dWorkload.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2022, 2024 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "RefBaseWorkload.hpp" 9 | #include 10 | 11 | #include "Decoders.hpp" 12 | #include "Encoders.hpp" 13 | 14 | namespace armnn 15 | { 16 | class RefPooling2dWorkload : public RefBaseWorkload 17 | { 18 | public: 19 | using RefBaseWorkload::RefBaseWorkload; 20 | 21 | void Execute() const override; 22 | 23 | private: 24 | void Execute(std::vector inputs, std::vector outputs) const; 25 | }; 26 | } //namespace armnn 27 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/RefPooling3dWorkload.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2022, 2024 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "RefBaseWorkload.hpp" 9 | #include 10 | 11 | #include "Decoders.hpp" 12 | #include "Encoders.hpp" 13 | 14 | namespace armnn 15 | { 16 | class RefPooling3dWorkload : public RefBaseWorkload 17 | { 18 | public: 19 | using RefBaseWorkload::RefBaseWorkload; 20 | 21 | void Execute() const override; 22 | 23 | private: 24 | void Execute(std::vector inputs, std::vector outputs) const; 25 | }; 26 | } //namespace armnn 27 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/RefPreluWorkload.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2022, 2024 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "RefBaseWorkload.hpp" 9 | #include 10 | 11 | namespace armnn 12 | { 13 | 14 | class RefPreluWorkload : public RefBaseWorkload 15 | { 16 | public: 17 | explicit RefPreluWorkload(const PreluQueueDescriptor& descriptor, 18 | const WorkloadInfo& info); 19 | void Execute() const override; 20 | 21 | private: 22 | void Execute(std::vector inputs, std::vector outputs) const; 23 | }; 24 | 25 | } // namespace armnn 26 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/RefQuantizeWorkload.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2022, 2024 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "RefBaseWorkload.hpp" 9 | #include 10 | #include "Decoders.hpp" 11 | #include "Encoders.hpp" 12 | 13 | namespace armnn { 14 | 15 | class RefQuantizeWorkload : public RefBaseWorkload 16 | { 17 | public: 18 | RefQuantizeWorkload(const QuantizeQueueDescriptor& descriptor, const WorkloadInfo &info); 19 | void Execute() const override; 20 | 21 | private: 22 | void Execute(std::vector inputs, std::vector outputs) const; 23 | 24 | size_t m_NumElements; 25 | }; 26 | 27 | } //namespace armnn -------------------------------------------------------------------------------- /src/backends/reference/workloads/RefReshapeWorkload.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2022, 2024 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "RefBaseWorkload.hpp" 9 | #include 10 | 11 | namespace armnn 12 | { 13 | 14 | class RefReshapeWorkload : public RefBaseWorkload 15 | { 16 | public: 17 | using RefBaseWorkload::RefBaseWorkload; 18 | void Execute() const override; 19 | private: 20 | void Execute(std::vector inputs, std::vector outputs) const; 21 | }; 22 | 23 | } //namespace armnn 24 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/RefResizeWorkload.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2022, 2024 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "RefBaseWorkload.hpp" 9 | #include 10 | 11 | namespace armnn 12 | { 13 | 14 | class RefResizeWorkload : public RefBaseWorkload 15 | { 16 | public: 17 | using RefBaseWorkload::RefBaseWorkload; 18 | void Execute() const override; 19 | private: 20 | void Execute(std::vector inputs, std::vector outputs) const; 21 | }; 22 | 23 | } //namespace armnn 24 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/RefReverseV2Workload.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2023-2024 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "RefBaseWorkload.hpp" 9 | #include 10 | 11 | #include "ReverseV2Impl.hpp" 12 | 13 | namespace armnn 14 | { 15 | 16 | class RefReverseV2Workload : public RefBaseWorkload 17 | { 18 | public: 19 | explicit RefReverseV2Workload(const ReverseV2QueueDescriptor& descriptor, 20 | const WorkloadInfo& info); 21 | 22 | void Execute() const override; 23 | 24 | private: 25 | void Execute(std::vector inputs, std::vector outputs) const; 26 | 27 | }; 28 | 29 | } // namespace armnn -------------------------------------------------------------------------------- /src/backends/reference/workloads/RefScatterNdWorkload.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2024 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "RefBaseWorkload.hpp" 9 | #include 10 | 11 | #include "ScatterNd.hpp" 12 | 13 | namespace armnn 14 | { 15 | 16 | class RefScatterNdWorkload : public RefBaseWorkload 17 | { 18 | public: 19 | explicit RefScatterNdWorkload(const ScatterNdQueueDescriptor& descriptor, 20 | const WorkloadInfo& info); 21 | 22 | void Execute() const override; 23 | 24 | private: 25 | void Execute(std::vector inputs, std::vector outputs) const; 26 | 27 | }; 28 | 29 | } // namespace armnn -------------------------------------------------------------------------------- /src/backends/reference/workloads/RefSliceWorkload.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2022, 2024 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "RefBaseWorkload.hpp" 9 | #include 10 | 11 | namespace armnn 12 | { 13 | 14 | class RefSliceWorkload : public RefBaseWorkload 15 | { 16 | public: 17 | using RefBaseWorkload::RefBaseWorkload; 18 | 19 | void Execute() const override; 20 | 21 | private: 22 | void Execute(std::vector inputs, std::vector outputs) const; 23 | }; 24 | 25 | } // namespace armnn 26 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/RefSoftmaxWorkload.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2022, 2024 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "RefBaseWorkload.hpp" 9 | #include 10 | 11 | namespace armnn 12 | { 13 | 14 | class RefSoftmaxWorkload : public RefBaseWorkload 15 | { 16 | public: 17 | using RefBaseWorkload::RefBaseWorkload; 18 | void Execute() const override; 19 | 20 | private: 21 | void Execute(std::vector inputs, std::vector outputs) const; 22 | }; 23 | 24 | } //namespace armnn 25 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/RefSpaceToBatchNdWorkload.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2018-2024 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | #pragma once 6 | 7 | #include "RefBaseWorkload.hpp" 8 | 9 | namespace armnn 10 | { 11 | 12 | class RefSpaceToBatchNdWorkload : public RefBaseWorkload 13 | { 14 | public: 15 | using RefBaseWorkload::RefBaseWorkload; 16 | 17 | void Execute() const override; 18 | 19 | private: 20 | void Execute(std::vector inputs, std::vector outputs) const; 21 | }; 22 | 23 | } //namespace armnn 24 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/RefSpaceToDepthWorkload.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2022, 2024 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | #pragma once 6 | 7 | #include "RefBaseWorkload.hpp" 8 | 9 | #include 10 | 11 | namespace armnn 12 | { 13 | 14 | class RefSpaceToDepthWorkload : public RefBaseWorkload 15 | { 16 | public: 17 | using RefBaseWorkload::RefBaseWorkload; 18 | void Execute() const override; 19 | 20 | private: 21 | void Execute(std::vector inputs, std::vector outputs) const; 22 | }; 23 | 24 | } //namespace armnn 25 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/RefSplitterWorkload.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2019-2024 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #include "RefSplitterWorkload.hpp" 7 | #include "Splitter.hpp" 8 | #include "RefWorkloadUtils.hpp" 9 | #include "Profiling.hpp" 10 | 11 | namespace armnn 12 | { 13 | 14 | void RefSplitterWorkload::Execute() const 15 | { 16 | Execute(m_Data.m_Inputs, m_Data.m_Outputs); 17 | } 18 | 19 | void RefSplitterWorkload::Execute(std::vector inputs, std::vector outputs) const 20 | { 21 | ARMNN_SCOPED_PROFILING_EVENT_REF_NAME_GUID("RefSplitterWorkload_Execute"); 22 | 23 | Split(m_Data, inputs, outputs); 24 | } 25 | 26 | } //namespace armnn 27 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/RefSplitterWorkload.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2022, 2024 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "RefBaseWorkload.hpp" 9 | #include 10 | #include "Decoders.hpp" 11 | #include "Encoders.hpp" 12 | 13 | namespace armnn 14 | { 15 | 16 | class RefSplitterWorkload : public RefBaseWorkload 17 | { 18 | public: 19 | using RefBaseWorkload::RefBaseWorkload; 20 | void Execute() const override; 21 | private: 22 | void Execute(std::vector inputs, std::vector outputs) const; 23 | }; 24 | 25 | } //namespace armnn 26 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/RefStackWorkload.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2022, 2024 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "RefBaseWorkload.hpp" 9 | #include 10 | 11 | namespace armnn 12 | { 13 | 14 | class RefStackWorkload : public RefBaseWorkload 15 | { 16 | public: 17 | explicit RefStackWorkload(const StackQueueDescriptor& descriptor, 18 | const WorkloadInfo& info); 19 | void Execute() const override; 20 | private: 21 | void Execute(std::vector inputs, std::vector outputs) const; 22 | }; 23 | 24 | } // namespace armnn 25 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/RefStridedSliceWorkload.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2022, 2024 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "RefBaseWorkload.hpp" 9 | 10 | namespace armnn 11 | { 12 | 13 | class RefStridedSliceWorkload : public RefBaseWorkload 14 | { 15 | public: 16 | RefStridedSliceWorkload(const StridedSliceQueueDescriptor& descriptor, const WorkloadInfo& info); 17 | void Execute() const override; 18 | private: 19 | void Execute(std::vector inputs, std::vector outputs) const; 20 | }; 21 | 22 | } // namespace armnn 23 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/RefTileWorkload.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2020-2024 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "RefBaseWorkload.hpp" 9 | #include 10 | 11 | #include "Tile.hpp" 12 | 13 | namespace armnn 14 | { 15 | 16 | class RefTileWorkload : public RefBaseWorkload 17 | { 18 | public: 19 | explicit RefTileWorkload(const TileQueueDescriptor& descriptor, 20 | const WorkloadInfo& info); 21 | 22 | void Execute() const override; 23 | 24 | private: 25 | template 26 | void Execute(std::vector inputs, std::vector outputs) const; 27 | 28 | }; 29 | 30 | } // namespace armnn -------------------------------------------------------------------------------- /src/backends/reference/workloads/ReverseV2Impl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2023 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "Encoders.hpp" 9 | #include "Decoders.hpp" 10 | 11 | #include 12 | 13 | namespace armnn 14 | { 15 | 16 | void ReverseV2(const TensorInfo& inputInfo, 17 | const TensorInfo& axisInfo, 18 | Decoder& inputDecoder, 19 | Decoder& axisDecoder, 20 | Encoder& outputEncoder); 21 | 22 | } // namespace armnn 23 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/Rsqrt.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2019 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include 9 | 10 | namespace armnn 11 | { 12 | template 13 | struct rsqrt 14 | { 15 | typedef T result_type; 16 | typedef T argument_type; 17 | 18 | T 19 | operator () (const T& inputData) const 20 | { 21 | return 1 / std::sqrt(inputData); 22 | } 23 | }; 24 | 25 | } //namespace armnn 26 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/Sin.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2021 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include 9 | 10 | namespace armnn 11 | { 12 | template 13 | struct sin 14 | { 15 | typedef T result_type; 16 | typedef T argument_type; 17 | 18 | T 19 | operator () (const T& inputData) const 20 | { 21 | return std::sin(inputData); 22 | } 23 | }; 24 | 25 | } //namespace armnn 26 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/Slice.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2019 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include 9 | 10 | #include "BaseIterator.hpp" 11 | 12 | 13 | namespace armnn 14 | { 15 | 16 | void Slice(const TensorInfo& inputInfo, 17 | const SliceDescriptor& descriptor, 18 | const void* inputData, 19 | void* outputData, 20 | unsigned int dataTypeSize); 21 | 22 | } // namespace armnn 23 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/Softmax.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "BaseIterator.hpp" 9 | #include 10 | 11 | namespace armnn 12 | { 13 | 14 | /// Computes the softmax function on some inputs, into outputs, with a shape given by tensorInfo. 15 | void Softmax(Decoder& in, Encoder& out, const TensorInfo& inputTensorInfo, float beta, int axis = -1); 16 | 17 | } //namespace armnn 18 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/SpaceToBatchNd.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017-2019,2023 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "BaseIterator.hpp" 9 | #include "Decoders.hpp" 10 | #include "Encoders.hpp" 11 | 12 | #include 13 | 14 | namespace armnn 15 | { 16 | 17 | void SpaceToBatchNd(const TensorInfo& inputInfo, 18 | const TensorInfo& outputInfo, 19 | const SpaceToBatchNdDescriptor& params, 20 | Decoder& inputData, 21 | Encoder& outputData); 22 | 23 | } //namespace armnn 24 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/SpaceToDepth.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "BaseIterator.hpp" 9 | #include "Decoders.hpp" 10 | #include "Encoders.hpp" 11 | 12 | #include 13 | #include 14 | 15 | namespace armnn 16 | { 17 | 18 | void SpaceToDepth(const TensorInfo& inputInfo, 19 | const TensorInfo& outputInfo, 20 | const SpaceToDepthDescriptor& params, 21 | Decoder& inputData, 22 | Encoder& outputData); 23 | 24 | } //namespace armnn 25 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/Sqrt.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2019 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include 9 | 10 | namespace armnn 11 | { 12 | template 13 | struct sqrt 14 | { 15 | typedef T result_type; 16 | typedef T argument_type; 17 | 18 | T 19 | operator () (const T& inputData) const 20 | { 21 | return std::sqrt(inputData); 22 | } 23 | }; 24 | 25 | } //namespace armnn 26 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/SquaredDifference.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2023 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include 9 | 10 | namespace armnn 11 | { 12 | 13 | template 14 | struct squaredDifference 15 | { 16 | typedef T result_type; 17 | typedef T first_argument_type; 18 | 19 | T 20 | operator()(const T& input1, const T& input2) const 21 | { 22 | float diff = std::minus<>{}(static_cast(input1),static_cast(input2)); 23 | T squaredDiff = armnn::numeric_cast(std::pow(static_cast(diff), 2)); 24 | return squaredDiff; 25 | } 26 | }; 27 | 28 | } //namespace armnn 29 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/Stack.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "Encoders.hpp" 9 | #include "Decoders.hpp" 10 | 11 | #include 12 | 13 | namespace armnn 14 | { 15 | 16 | void Stack (const StackQueueDescriptor& data, 17 | std::vector>>& inputs, 18 | Encoder& output, 19 | const TensorInfo& inputInfo, 20 | const TensorInfo& outputInfo); 21 | 22 | } // namespace armnn 23 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/StridedSlice.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include 9 | #include 10 | 11 | namespace armnn 12 | { 13 | 14 | void StridedSlice(const TensorInfo& inputInfo, 15 | const StridedSliceDescriptor& params, 16 | const void* inputData, 17 | void* outputData, 18 | unsigned int dataTypeSize); 19 | 20 | } // namespace armnn 21 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/StringMapping.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #include "StringMapping.hpp" 7 | 8 | namespace armnn 9 | { 10 | 11 | const StringMapping& StringMapping::Instance() 12 | { 13 | static StringMapping instance; 14 | return instance; 15 | } 16 | 17 | } // armnn 18 | -------------------------------------------------------------------------------- /src/backends/reference/workloads/Tile.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2023-2024 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include 9 | #include "Encoders.hpp" 10 | #include "Decoders.hpp" 11 | #include "armnn/Descriptors.hpp" 12 | 13 | namespace armnn 14 | { 15 | 16 | template 17 | void Tile(const TileDescriptor& params, 18 | const TensorInfo& inputInfo, 19 | Decoder& inputDecoder, 20 | Encoder& outputEncoder); 21 | 22 | } // namespace armnn 23 | -------------------------------------------------------------------------------- /src/backends/tosaCommon/common.cmake: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright © 2022-2023 Arm Ltd and Contributors. All rights reserved. 3 | # SPDX-License-Identifier: MIT 4 | # 5 | 6 | if(ARMNNTOSACOMMON) 7 | add_subdirectory(${PROJECT_SOURCE_DIR}/src/backends/tosaCommon) 8 | list(APPEND armnnLibraries armnnTosaBackend) 9 | list(APPEND armnnLibraries armnnTosaBackendOperators) 10 | list(APPEND armnnUnitTestLibraries armnnTosaBackendUnitTests) 11 | endif() 12 | -------------------------------------------------------------------------------- /src/backends/tosaCommon/operatorMappings/AvgPool2DIgnoreValueOperator.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2022 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "TosaOperatorUtils.hpp" 9 | 10 | #include 11 | 12 | #include 13 | 14 | using namespace armnn; 15 | using namespace tosa; 16 | 17 | TosaSerializationBasicBlock* ConvertAvgPool2DIgnoreValueToTosaOperator(const Layer* layer, 18 | const std::vector& inputs, 19 | const std::vector& outputs, 20 | const Pooling2dDescriptor* poolDescriptor); 21 | -------------------------------------------------------------------------------- /src/backends/tosaCommon/operatorMappings/BatchMatMulOperator.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2024 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "TosaOperatorUtils.hpp" 9 | 10 | using namespace armnn; 11 | using namespace tosa; 12 | 13 | TosaSerializationBasicBlock* ConvertBatchMatMulToTosaOperator(const Layer* layer, 14 | const std::vector& inputs, 15 | const std::vector& outputs, 16 | const BatchMatMulDescriptor* 17 | descriptor = nullptr); -------------------------------------------------------------------------------- /src/backends/tosaCommon/operatorMappings/ConcatOperator.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2022-2023 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "TosaOperatorUtils.hpp" 9 | 10 | using namespace armnn; 11 | using namespace tosa; 12 | 13 | TosaSerializationBasicBlock* ConvertConcatToTosaOperator(const Layer* layer, 14 | const std::vector& inputs, 15 | const std::vector& outputs, 16 | const OriginsDescriptor* concatDescriptor); 17 | -------------------------------------------------------------------------------- /src/backends/tosaCommon/operatorMappings/ConstantOperator.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2022-2024 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "TosaOperatorUtils.hpp" 9 | 10 | using namespace armnn; 11 | using namespace tosa; 12 | 13 | TosaSerializationBasicBlock* ConvertConstantToTosaOperator(const Layer* layer, 14 | const std::vector& outputs, 15 | bool isDepthwiseConv2dWeights); 16 | 17 | -------------------------------------------------------------------------------- /src/backends/tosaCommon/operatorMappings/Conv2dOperator.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2022-2023 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "TosaOperatorUtils.hpp" 9 | 10 | using namespace armnn; 11 | using namespace tosa; 12 | 13 | TosaSerializationBasicBlock* ConvertConv2dToTosaOperator(const Layer* layer, 14 | const std::vector& inputs, 15 | const std::vector& outputs, 16 | const Convolution2dDescriptor* conv2dDescriptor); 17 | -------------------------------------------------------------------------------- /src/backends/tosaCommon/operatorMappings/Conv3dOperator.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2024 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "TosaOperatorUtils.hpp" 9 | 10 | using namespace armnn; 11 | using namespace tosa; 12 | 13 | TosaSerializationBasicBlock* ConvertConv3dToTosaOperator(const Layer* layer, 14 | const std::vector& inputs, 15 | const std::vector& outputs, 16 | const Convolution3dDescriptor* conv3dDescriptor); -------------------------------------------------------------------------------- /src/backends/tosaCommon/operatorMappings/DepthToSpaceOperator.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2024 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "TosaOperatorUtils.hpp" 9 | 10 | using namespace armnn; 11 | using namespace tosa; 12 | 13 | TosaSerializationBasicBlock* ConvertDepthToSpaceToTosaOperator(const Layer* layer, 14 | const std::vector& inputs, 15 | const std::vector& outputs, 16 | const DepthToSpaceDescriptor* descriptor); -------------------------------------------------------------------------------- /src/backends/tosaCommon/operatorMappings/DepthwiseConv2dOperator.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2022-2023 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "TosaOperatorUtils.hpp" 9 | 10 | using namespace armnn; 11 | using namespace tosa; 12 | 13 | TosaSerializationBasicBlock* ConvertDepthwiseConv2dToTosaOperator( 14 | const Layer* layer, 15 | const std::vector& inputs, 16 | const std::vector& outputs, 17 | const DepthwiseConvolution2dDescriptor* conv2dDescriptor); 18 | -------------------------------------------------------------------------------- /src/backends/tosaCommon/operatorMappings/DequantizeOperator.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2024 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "TosaOperatorUtils.hpp" 9 | 10 | using namespace armnn; 11 | using namespace tosa; 12 | 13 | TosaSerializationBasicBlock* ConvertDequantizeToTosaOperator( 14 | const Layer* layer, 15 | const std::vector& inputs, 16 | const std::vector& outputs); 17 | -------------------------------------------------------------------------------- /src/backends/tosaCommon/operatorMappings/ExpOperator.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2024 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "TosaOperatorUtils.hpp" 9 | 10 | using namespace armnn; 11 | using namespace tosa; 12 | 13 | TosaSerializationBasicBlock* ConvertExpOperator(const Layer* layer, 14 | const std::vector& inputs, 15 | const std::vector& outputs, 16 | const ElementwiseUnaryDescriptor* unaryDescriptor); 17 | -------------------------------------------------------------------------------- /src/backends/tosaCommon/operatorMappings/FullyConnectedOperator.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2024 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "TosaOperatorUtils.hpp" 9 | 10 | using namespace armnn; 11 | using namespace tosa; 12 | 13 | TosaSerializationBasicBlock* ConvertFullyConnectedToTosaOperator(const Layer* layer, 14 | const std::vector& inputs, 15 | const std::vector& outputs, 16 | const FullyConnectedDescriptor* fcDescriptor); 17 | -------------------------------------------------------------------------------- /src/backends/tosaCommon/operatorMappings/GatherOperator.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2024 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "TosaOperatorUtils.hpp" 9 | 10 | using namespace armnn; 11 | using namespace tosa; 12 | 13 | TosaSerializationBasicBlock* ConvertGatherToTosaOperator(const Layer* layer, 14 | const std::vector& inputs, 15 | const std::vector& outputs, 16 | const GatherDescriptor* gatherDescriptor); -------------------------------------------------------------------------------- /src/backends/tosaCommon/operatorMappings/GeluOperator.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2024 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include 9 | 10 | #include 11 | 12 | #include "TosaOperatorUtils.hpp" 13 | 14 | using namespace armnn; 15 | using namespace tosa; 16 | 17 | TosaSerializationBasicBlock* ConvertGeluToTosaOperator(const Layer* layer, 18 | const std::vector& inputs, 19 | const std::vector& outputs, 20 | const ActivationDescriptor* activationDescriptor); 21 | -------------------------------------------------------------------------------- /src/backends/tosaCommon/operatorMappings/HardSwishOperator.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2024 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "TosaOperatorUtils.hpp" 9 | 10 | using namespace armnn; 11 | using namespace tosa; 12 | 13 | TosaSerializationBasicBlock* ConvertHardSwishToTosaOperator(const Layer* layer, 14 | const std::vector& inputs, 15 | const std::vector& outputs, 16 | const ActivationDescriptor* activationDescriptor); 17 | -------------------------------------------------------------------------------- /src/backends/tosaCommon/operatorMappings/LeakyReluOperator.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2024 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include 9 | 10 | #include 11 | 12 | #include "TosaOperatorUtils.hpp" 13 | 14 | using namespace armnn; 15 | using namespace tosa; 16 | 17 | TosaSerializationBasicBlock* ConvertLeakyReluToTosaOperator(const Layer* layer, 18 | const std::vector& inputs, 19 | const std::vector& outputs, 20 | const ActivationDescriptor* activationDescriptor); 21 | -------------------------------------------------------------------------------- /src/backends/tosaCommon/operatorMappings/LogOperator.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2024 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "TosaOperatorUtils.hpp" 9 | 10 | using namespace armnn; 11 | using namespace tosa; 12 | 13 | TosaSerializationBasicBlock* ConvertLogOperator(const Layer* layer, 14 | const std::vector& inputs, 15 | const std::vector& outputs, 16 | const ElementwiseUnaryDescriptor* unaryDescriptor); 17 | -------------------------------------------------------------------------------- /src/backends/tosaCommon/operatorMappings/PadOperator.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2024 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "TosaOperatorUtils.hpp" 9 | 10 | using namespace armnn; 11 | using namespace tosa; 12 | 13 | TosaSerializationBasicBlock* ConvertPadToTosaOperator(const Layer* layer, 14 | const std::vector& inputs, 15 | const std::vector& outputs, 16 | const PadDescriptor* padDescriptor); 17 | -------------------------------------------------------------------------------- /src/backends/tosaCommon/operatorMappings/Pooling2DOperator.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2022-2023 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "TosaOperatorUtils.hpp" 9 | 10 | using namespace armnn; 11 | using namespace tosa; 12 | 13 | TosaSerializationBasicBlock* ConvertPooling2DToTosaOperator(const Layer* layer, 14 | const std::vector& inputs, 15 | const std::vector& outputs, 16 | const Pooling2dDescriptor* poolDescriptor); 17 | -------------------------------------------------------------------------------- /src/backends/tosaCommon/operatorMappings/QuantizeOperator.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2023 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | 7 | #pragma once 8 | 9 | #include "TosaOperatorUtils.hpp" 10 | 11 | using namespace armnn; 12 | using namespace tosa; 13 | 14 | TosaSerializationBasicBlock* ConvertQuantizeToTosaOperator(const Layer* layer, 15 | const std::vector& inputs, 16 | const std::vector& outputs); -------------------------------------------------------------------------------- /src/backends/tosaCommon/operatorMappings/ReduceOperator.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2024 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "TosaOperatorUtils.hpp" 9 | 10 | TosaSerializationBasicBlock* ConvertReduceToTosaOperator(const Layer* layer, 11 | const std::vector& inputs, 12 | const std::vector& outputs, 13 | const ReduceDescriptor* reduceDescriptor); 14 | -------------------------------------------------------------------------------- /src/backends/tosaCommon/operatorMappings/ReluOperator.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2024 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include 9 | 10 | #include 11 | 12 | #include "TosaOperatorUtils.hpp" 13 | 14 | using namespace armnn; 15 | using namespace tosa; 16 | 17 | TosaSerializationBasicBlock* ConvertReluToTosaOperator(const Layer* layer, 18 | const std::vector& inputs, 19 | const std::vector& outputs, 20 | const ActivationDescriptor* activationDescriptor); 21 | -------------------------------------------------------------------------------- /src/backends/tosaCommon/operatorMappings/ReshapeOperator.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2022-2023 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "TosaOperatorUtils.hpp" 9 | 10 | using namespace armnn; 11 | using namespace tosa; 12 | 13 | TosaSerializationBasicBlock* ConvertReshapeToTosaOperator(const Layer* layer, 14 | const std::vector& inputs, 15 | const std::vector& outputs, 16 | const ReshapeDescriptor* reshapeDescriptor); 17 | -------------------------------------------------------------------------------- /src/backends/tosaCommon/operatorMappings/ResizeOperator.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2023-2024 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "TosaOperatorUtils.hpp" 9 | 10 | using namespace armnn; 11 | using namespace tosa; 12 | 13 | TosaSerializationBasicBlock* ConvertResizeToTosaOperator(const Layer* layer, 14 | const std::vector& inputs, 15 | const std::vector& outputs, 16 | const ResizeDescriptor* resizeDescriptor); 17 | -------------------------------------------------------------------------------- /src/backends/tosaCommon/operatorMappings/RsqrtOperator.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2023 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "TosaOperatorUtils.hpp" 9 | 10 | using namespace armnn; 11 | using namespace tosa; 12 | 13 | TosaSerializationBasicBlock* ConvertRsqrtOperator(const Layer* layer, 14 | const std::vector& inputs, 15 | const std::vector& outputs, 16 | const ElementwiseUnaryDescriptor* unaryDescriptor); 17 | -------------------------------------------------------------------------------- /src/backends/tosaCommon/operatorMappings/SigmoidOperator.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2024 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "TosaOperatorUtils.hpp" 9 | 10 | using namespace armnn; 11 | using namespace tosa; 12 | 13 | TosaSerializationBasicBlock* ConvertSigmoidToTosaOperator(const Layer* layer, 14 | const std::vector& inputs, 15 | const std::vector& outputs, 16 | const ActivationDescriptor* activationDescriptor); 17 | -------------------------------------------------------------------------------- /src/backends/tosaCommon/operatorMappings/SliceOperator.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2022-2023 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "TosaOperatorUtils.hpp" 9 | 10 | using namespace armnn; 11 | using namespace tosa; 12 | 13 | TosaSerializationBasicBlock* ConvertSliceToTosaOperator(const Layer* layer, 14 | const std::vector& inputs, 15 | const std::vector& outputs, 16 | const SliceDescriptor* sliceDescriptor); -------------------------------------------------------------------------------- /src/backends/tosaCommon/operatorMappings/SoftmaxOperator.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2023 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | 7 | #pragma once 8 | 9 | #include "TosaOperatorUtils.hpp" 10 | 11 | using namespace armnn; 12 | using namespace tosa; 13 | 14 | TosaSerializationBasicBlock* ConvertSoftmaxToTosaOperator(const Layer* layer, 15 | const std::vector& inputs, 16 | const std::vector& outputs, 17 | const SoftmaxDescriptor* softmaxDescriptor); -------------------------------------------------------------------------------- /src/backends/tosaCommon/operatorMappings/SplitOperator.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2023 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "TosaOperatorUtils.hpp" 9 | 10 | using namespace armnn; 11 | using namespace tosa; 12 | 13 | TosaSerializationBasicBlock* ConvertSplitToTosaOperator(const Layer* layer, 14 | const std::vector& inputs, 15 | const std::vector& outputs, 16 | const SplitterDescriptor* splitDescriptor); -------------------------------------------------------------------------------- /src/backends/tosaCommon/operatorMappings/StackOperator.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2024 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "TosaOperatorUtils.hpp" 9 | 10 | using namespace armnn; 11 | using namespace tosa; 12 | 13 | TosaSerializationBasicBlock* ConvertStackToTosaOperator(const Layer* layer, 14 | const std::vector& inputs, 15 | const std::vector& outputs, 16 | const StackDescriptor* stackDescriptor); -------------------------------------------------------------------------------- /src/backends/tosaCommon/operatorMappings/StridedSliceOperator.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2024 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "TosaOperatorUtils.hpp" 9 | 10 | using namespace armnn; 11 | using namespace tosa; 12 | 13 | TosaSerializationBasicBlock* ConvertStridedSliceToTosaOperator(const Layer* layer, 14 | const std::vector& inputs, 15 | const std::vector& outputs, 16 | const StridedSliceDescriptor* sliceDescriptor); -------------------------------------------------------------------------------- /src/backends/tosaCommon/operatorMappings/TanhOperator.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2024 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "TosaOperatorUtils.hpp" 9 | 10 | using namespace armnn; 11 | using namespace tosa; 12 | 13 | TosaSerializationBasicBlock* ConvertTanHToTosaOperator(const Layer* layer, 14 | const std::vector& inputs, 15 | const std::vector& outputs, 16 | const ActivationDescriptor* activationDescriptor); 17 | -------------------------------------------------------------------------------- /src/backends/tosaCommon/operatorMappings/TransposeConv2dOperator.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2022-2023 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "TosaOperatorUtils.hpp" 9 | 10 | using namespace armnn; 11 | using namespace tosa; 12 | 13 | TosaSerializationBasicBlock* ConvertTransposeConv2dToTosaOperator(const Layer* layer, 14 | const std::vector& inputs, 15 | const std::vector& outputs, 16 | const TransposeConvolution2dDescriptor* descriptor); 17 | -------------------------------------------------------------------------------- /src/backends/tosaCommon/operatorMappings/TransposeOperator.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2022-2023 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "TosaOperatorUtils.hpp" 9 | 10 | using namespace armnn; 11 | using namespace tosa; 12 | 13 | TosaSerializationBasicBlock* ConvertTransposeToTosaOperator(const Layer* layer, 14 | const std::vector& inputs, 15 | const std::vector& outputs, 16 | const TransposeDescriptor* transposeDescriptor); 17 | -------------------------------------------------------------------------------- /src/backends/tosaCommon/test/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright © 2022 Arm Ltd and Contributors. All rights reserved. 3 | # SPDX-License-Identifier: MIT 4 | # 5 | 6 | list(APPEND armnnTosaBackendUnitTests_sources 7 | OneToManyMappingTests.cpp 8 | OneToOneMappingTests.cpp 9 | ) 10 | 11 | add_library(armnnTosaBackendUnitTests OBJECT ${armnnTosaBackendUnitTests_sources}) 12 | target_include_directories(armnnTosaBackendUnitTests PRIVATE ${PROJECT_SOURCE_DIR}/src/armnn) 13 | target_include_directories(armnnTosaBackendUnitTests PRIVATE ${PROJECT_SOURCE_DIR}/src/armnnUtils) 14 | target_include_directories(armnnTosaBackendUnitTests PRIVATE ${PROJECT_SOURCE_DIR}/src/armnnTestUtils) 15 | target_include_directories(armnnTosaBackendUnitTests PRIVATE ${PROJECT_SOURCE_DIR}/src/backends) 16 | -------------------------------------------------------------------------------- /src/backends/tosaReference/TosaRefBackendId.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2022 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | #pragma once 6 | 7 | namespace armnn 8 | { 9 | 10 | constexpr const char * TosaRefBackendId() { return "TosaRef"; } 11 | 12 | } // namespace armnn 13 | -------------------------------------------------------------------------------- /src/backends/tosaReference/TosaRefRegistryInitializer.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2022 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #include "TosaRefBackend.hpp" 7 | 8 | #include 9 | 10 | namespace 11 | { 12 | 13 | using namespace armnn; 14 | 15 | static BackendRegistry::StaticRegistryInitializer g_RegisterHelper 16 | { 17 | BackendRegistryInstance(), 18 | TosaRefBackend::GetIdStatic(), 19 | []() 20 | { 21 | return IBackendInternalUniquePtr(new TosaRefBackend); 22 | } 23 | }; 24 | 25 | } // Anonymous namespace 26 | -------------------------------------------------------------------------------- /src/backends/tosaReference/backend.cmake: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright © 2022 Arm Ltd and Contributors. All rights reserved. 3 | # SPDX-License-Identifier: MIT 4 | # 5 | 6 | add_subdirectory(${PROJECT_SOURCE_DIR}/src/backends/tosaReference) 7 | list(APPEND armnnLibraries armnnTosaRefBackend) 8 | 9 | if(ARMNNTOSAREF) 10 | list(APPEND armnnLibraries armnnTosaRefBackendWorkloads) 11 | list(APPEND armnnUnitTestLibraries armnnTosaRefBackendUnitTests) 12 | else() 13 | message(STATUS "TOSA Reference backend is disabled") 14 | endif() 15 | -------------------------------------------------------------------------------- /src/backends/tosaReference/test/TosaRefLayerTests.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2022 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #include "TosaRefWorkloadFactoryHelper.hpp" 7 | 8 | #include 9 | 10 | #include 11 | 12 | #include 13 | -------------------------------------------------------------------------------- /src/backends/tosaReference/workloads/TosaRefWorkloads.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2022 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include "TosaRefPreCompiledWorkload.hpp" 9 | -------------------------------------------------------------------------------- /src/dynamic/README.md.license: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright © 2019-2021 Arm Ltd and Contributors. All rights reserved. 3 | # SPDX-License-Identifier: MIT 4 | # 5 | -------------------------------------------------------------------------------- /src/dynamic/sample/SampleDynamicAdditionWorkload.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2020 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | #pragma once 6 | 7 | #include 8 | #include 9 | 10 | namespace sdb // sample dynamic backend 11 | { 12 | 13 | class SampleDynamicAdditionWorkload : public armnn::BaseWorkload 14 | { 15 | public: 16 | SampleDynamicAdditionWorkload(const armnn::AdditionQueueDescriptor& descriptor, const armnn::WorkloadInfo& info); 17 | 18 | void Execute() const override; 19 | }; 20 | 21 | } // namespace sdb 22 | -------------------------------------------------------------------------------- /src/dynamic/sample/SampleDynamicBackend.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2020 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include 9 | 10 | extern "C" 11 | { 12 | const char* GetBackendId(); 13 | void GetVersion(uint32_t* outMajor, uint32_t* outMinor); 14 | void* BackendFactory(); 15 | } 16 | -------------------------------------------------------------------------------- /src/profiling/test/PrintPacketHeaderHandler.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2020 Arm Ltd and Contributors. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | 6 | #pragma once 7 | 8 | #include 9 | 10 | #include 11 | 12 | namespace arm 13 | { 14 | 15 | namespace pipe 16 | { 17 | 18 | class PrintPacketHeaderHandler : public ILocalPacketHandler 19 | { 20 | virtual std::vector GetHeadersAccepted(); 21 | 22 | virtual void HandlePacket(const arm::pipe::Packet& packet); 23 | }; 24 | 25 | } // namespace pipe 26 | 27 | } // namespace arm 28 | -------------------------------------------------------------------------------- /tests/Cifar10Database.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | #pragma once 6 | 7 | #include "ClassifierTestCaseData.hpp" 8 | 9 | #include 10 | #include 11 | 12 | class Cifar10Database 13 | { 14 | public: 15 | using DataType = float; 16 | using TTestCaseData = ClassifierTestCaseData; 17 | 18 | explicit Cifar10Database(const std::string& binaryFileDirectory, bool rgbPack = false); 19 | std::unique_ptr GetTestCaseData(unsigned int testCaseId); 20 | 21 | private: 22 | std::string m_BinaryDirectory; 23 | bool m_RgbPack; 24 | }; 25 | -------------------------------------------------------------------------------- /tests/ClassifierTestCaseData.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | #pragma once 6 | 7 | #include 8 | 9 | template 10 | class ClassifierTestCaseData 11 | { 12 | public: 13 | ClassifierTestCaseData(unsigned int label, std::vector inputImage) 14 | : m_Label(label) 15 | , m_InputImage(std::move(inputImage)) 16 | { 17 | } 18 | 19 | const unsigned int m_Label; 20 | std::vector m_InputImage; 21 | }; 22 | -------------------------------------------------------------------------------- /tests/ExecuteNetwork/evaluate_network.md.license: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright © 2023-2024 Arm Ltd and Contributors. 3 | # SPDX-License-Identifier: MIT 4 | # 5 | -------------------------------------------------------------------------------- /tests/ImageCSVFileGenerator/README.md: -------------------------------------------------------------------------------- 1 | # The ImageCSVFileGenerator 2 | 3 | The `ImageCSVFileGenerator` is a program for creating a CSV file that contains a list of .raw tensor files. These 4 | .raw tensor files can be generated using the`ImageTensorGenerator`. 5 | 6 | |Cmd:||| 7 | | ---|---|---| 8 | | -h | --help | Display help messages | 9 | | -i | --indir | Directory that .raw files are stored in | 10 | | -o | --outfile | Output CSV file path | 11 | 12 | Example usage:
13 | ./ImageCSVFileGenerator -i /path/to/directory/ -o /output/path/csvfile.csv 14 | -------------------------------------------------------------------------------- /tests/ImageCSVFileGenerator/README.md.license: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright © 2019 Arm Ltd and Contributors. All rights reserved. 3 | # SPDX-License-Identifier: MIT 4 | # 5 | -------------------------------------------------------------------------------- /tests/ImageTensorGenerator/README.md.license: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright © 2019, 2021 Arm Ltd and Contributors. All rights reserved. 3 | # SPDX-License-Identifier: MIT 4 | # 5 | -------------------------------------------------------------------------------- /tests/InterfaceTests/README.md.license: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright © 2023 Arm Ltd and Contributors. 3 | # SPDX-License-Identifier: MIT 4 | # 5 | -------------------------------------------------------------------------------- /tests/InterfaceTests/simple_conv2d_1_op.tflite: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ARM-software/armnn/e1ec5b81cf484f50dd50b480a8c16213edaff5e3/tests/InterfaceTests/simple_conv2d_1_op.tflite -------------------------------------------------------------------------------- /tests/InterfaceTests/simple_conv2d_1_op.tflite.license: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright © 2023 Arm Ltd and Contributors. 3 | # SPDX-License-Identifier: MIT 4 | # 5 | -------------------------------------------------------------------------------- /tests/LstmCommon.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | #pragma once 6 | 7 | #include 8 | #include 9 | 10 | namespace 11 | { 12 | 13 | struct LstmInput 14 | { 15 | LstmInput(const std::vector& inputSeq, 16 | const std::vector& stateH, 17 | const std::vector& stateC) 18 | : m_InputSeq(inputSeq) 19 | , m_StateH(stateH) 20 | , m_StateC(stateC) 21 | {} 22 | 23 | std::vector m_InputSeq; 24 | std::vector m_StateH; 25 | std::vector m_StateC; 26 | }; 27 | 28 | using LstmInputs = std::pair>; 29 | 30 | } // anonymous namespace -------------------------------------------------------------------------------- /tests/MnistDatabase.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright © 2017 Arm Ltd. All rights reserved. 3 | // SPDX-License-Identifier: MIT 4 | // 5 | #pragma once 6 | 7 | #include "ClassifierTestCaseData.hpp" 8 | 9 | #include 10 | #include 11 | 12 | class MnistDatabase 13 | { 14 | public: 15 | using DataType = float; 16 | using TTestCaseData = ClassifierTestCaseData; 17 | 18 | explicit MnistDatabase(const std::string& binaryFileDirectory, bool scaleValues = false); 19 | std::unique_ptr GetTestCaseData(unsigned int testCaseId); 20 | 21 | private: 22 | std::string m_BinaryDirectory; 23 | bool m_ScaleValues; 24 | }; -------------------------------------------------------------------------------- /tests/ModelAccuracyTool-Armnn/README.md.license: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright © 2019, 2021 Arm Ltd and Contributors. All rights reserved. 3 | # SPDX-License-Identifier: MIT 4 | # 5 | -------------------------------------------------------------------------------- /tests/OnnxMnist-Armnn/Validation.txt.license: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright © 2018 Arm Ltd and Contributors. All rights reserved. 3 | # SPDX-License-Identifier: MIT 4 | # 5 | -------------------------------------------------------------------------------- /tests/OnnxMobileNet-Armnn/Validation.txt.license: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright © 2018 Arm Ltd and Contributors. All rights reserved. 3 | # SPDX-License-Identifier: MIT 4 | # 5 | -------------------------------------------------------------------------------- /tests/OnnxMobileNet-Armnn/labels.txt.license: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright © 2018 Arm Ltd and Contributors. All rights reserved. 3 | # SPDX-License-Identifier: MIT 4 | # 5 | -------------------------------------------------------------------------------- /tests/TfLiteInceptionV3Quantized-Armnn/Validation.txt.license: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright © 2019 Arm Ltd and Contributors. All rights reserved. 3 | # SPDX-License-Identifier: MIT 4 | # 5 | -------------------------------------------------------------------------------- /tests/TfLiteInceptionV4Quantized-Armnn/Validation.txt.license: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright © 2019 Arm Ltd and Contributors. All rights reserved. 3 | # SPDX-License-Identifier: MIT 4 | # 5 | -------------------------------------------------------------------------------- /tests/TfLiteMobileNetQuantizedSoftmax-Armnn/Validation.txt.license: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright © 2019 Arm Ltd and Contributors. All rights reserved. 3 | # SPDX-License-Identifier: MIT 4 | # 5 | -------------------------------------------------------------------------------- /tests/TfLiteMobilenetQuantized-Armnn/Validation.txt.license: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright © 2018 Arm Ltd and Contributors. All rights reserved. 3 | # SPDX-License-Identifier: MIT 4 | # 5 | -------------------------------------------------------------------------------- /tests/TfLiteMobilenetQuantized-Armnn/labels.txt.license: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright © 2018 Arm Ltd and Contributors. All rights reserved. 3 | # SPDX-License-Identifier: MIT 4 | # 5 | -------------------------------------------------------------------------------- /tests/TfLiteVGG16Quantized-Armnn/Validation.txt.license: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright © 2018-2019 Arm Ltd and Contributors. All rights reserved. 3 | # SPDX-License-Identifier: MIT 4 | # 5 | -------------------------------------------------------------------------------- /third-party/REUSE.toml: -------------------------------------------------------------------------------- 1 | # SPDX-FileCopyrightText: Copyright © 2023-2024 Arm Ltd and Contributors. 2 | # SPDX-License-Identifier: MIT 3 | version = 1 4 | [[annotations]] 5 | path = "gemmlowp/**" 6 | precedence = "closest" 7 | SPDX-FileCopyrightText = "NOASSERTION" 8 | SPDX-License-Identifier = "Apache-2.0" -------------------------------------------------------------------------------- /third-party/cxxopts/CHANGELOG.md.license: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (c) 2014-2022 Jarryd Beck 3 | # SPDX-License-Identifier: MIT 4 | # 5 | -------------------------------------------------------------------------------- /third-party/cxxopts/LICENSE.spdx: -------------------------------------------------------------------------------- 1 | PackageName: cxxopts 2 | SPDXID: SPDXRef-cxxopts 3 | FilesAnalyzed: true 4 | PackageLicenseConcluded: MIT 5 | PackageLicenseInfoFromFiles: MIT 6 | PackageLicenseDeclared: MIT 7 | PackageCopyrightText: Copyright (c) 2014-2022 Jarryd Beck 8 | -------------------------------------------------------------------------------- /third-party/cxxopts/README.md.license: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (c) 2014-2022 Jarryd Beck 3 | # SPDX-License-Identifier: MIT 4 | # 5 | -------------------------------------------------------------------------------- /third-party/doctest/LICENSE.spdx: -------------------------------------------------------------------------------- 1 | PackageName: doctest 2 | SPDXID: SPDXRef-doctest 3 | FilesAnalyzed: true 4 | PackageLicenseConcluded: MIT 5 | PackageLicenseInfoFromFiles: MIT 6 | PackageLicenseDeclared: MIT 7 | PackageCopyrightText: Copyright (c) 2016-2021 Viktor Kirilov 8 | -------------------------------------------------------------------------------- /third-party/fmt/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright © 2020 Arm Ltd. All rights reserved. 3 | # SPDX-License-Identifier: MIT 4 | # 5 | 6 | add_library(fmt STATIC src/format.cc) 7 | target_include_directories(fmt PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}) 8 | 9 | install( 10 | TARGETS fmt 11 | EXPORT armnn-targets 12 | LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} 13 | ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} 14 | ) -------------------------------------------------------------------------------- /third-party/fmt/LICENSE.spdx: -------------------------------------------------------------------------------- 1 | PackageName: fmt 2 | SPDXID: SPDXRef-fmt 3 | FilesAnalyzed: true 4 | PackageLicenseConcluded: MIT 5 | PackageLicenseInfoFromFiles: MIT 6 | PackageLicenseDeclared: MIT 7 | PackageCopyrightText: Copyright (c) 2012 - present, Victor Zverovich 8 | -------------------------------------------------------------------------------- /third-party/fmt/README.rst.license: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (c) 2012 - present, Victor Zverovich 3 | # SPDX-License-Identifier: MIT 4 | # 5 | -------------------------------------------------------------------------------- /third-party/gemmlowp/AUTHORS: -------------------------------------------------------------------------------- 1 | # This is the official list of gemmlowp authors for copyright purposes. 2 | # This file is distinct from the CONTRIBUTORS.txt file. 3 | # See the latter for an explanation. 4 | 5 | # Names should be added to this file as: 6 | # Name or Organization 7 | # The email address is not required for organizations. 8 | 9 | Google Inc. 10 | Intel Corporation 11 | ARM Ltd. 12 | Silk Labs Inc. 13 | MIPS Tech LLC 14 | Wave Computing Inc. 15 | -------------------------------------------------------------------------------- /third-party/gemmlowp/LICENSE.spdx: -------------------------------------------------------------------------------- 1 | PackageName: gemmlowp 2 | SPXID: SPDXRef-gemmlowp 3 | FilesAnalyzed: true 4 | PackageLicenseConcluded: Apache-2.0 5 | PackageLicenseInfoFromFiles: Apache-2.0 6 | PackageLicenseDeclared: Apache-2.0 7 | PackageCopyrightText: Copyright (c) 2024 The gemmlowp Authors. All rights reserved. 8 | -------------------------------------------------------------------------------- /third-party/ghc/LICENSE.spdx: -------------------------------------------------------------------------------- 1 | PackageName: ghc 2 | SPDXID: SPDXRef-ghc 3 | FilesAnalyzed: true 4 | PackageLicenseConcluded: MIT 5 | PackageLicenseInfoFromFiles: MIT 6 | PackageLicenseDeclared: MIT 7 | PackageCopyrightText: Copyright (c) 2018, Steffen Schümann 8 | -------------------------------------------------------------------------------- /third-party/ghc/README.md.license: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (c) 2018, Steffen Schümann 3 | # SPDX-License-Identifier: MIT 4 | # 5 | -------------------------------------------------------------------------------- /third-party/half/ChangeLog.txt.license: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (c) 2012-2017 Christian Rau 3 | # SPDX-License-Identifier: MIT 4 | # 5 | -------------------------------------------------------------------------------- /third-party/half/LICENSE.spdx: -------------------------------------------------------------------------------- 1 | PackageName: half 2 | SPDXID: SPDXRef-half 3 | FilesAnalyzed: true 4 | PackageLicenseConcluded: MIT 5 | PackageLicenseInfoFromFiles: MIT 6 | PackageLicenseDeclared: MIT 7 | PackageCopyrightText:Copyright (c) 2012-2017 Christian Rau 8 | -------------------------------------------------------------------------------- /third-party/half/README.txt.license: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (c) 2012-2017 Christian Rau 3 | # SPDX-License-Identifier: MIT 4 | # 5 | -------------------------------------------------------------------------------- /third-party/mapbox/LICENSE.spdx: -------------------------------------------------------------------------------- 1 | PackageName: MapBox 2 | SPDXID: SPDXRef-MapBox 3 | FilesAnalyzed: true 4 | PackageLicenseConcluded: BSD-3-Clause 5 | PackageLicenseInfoFromFiles: BSD-3-Clause 6 | PackageLicenseDeclared: BSD-3-Clause 7 | PackageCopyrightText: Copyright (c) MapBox All rights reserved. 8 | -------------------------------------------------------------------------------- /third-party/mapbox/LICENSE_1_0.txt.license: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (c) MapBox All rights reserved. 3 | # SPDX-License-Identifier: BSD-3-Clause 4 | # -------------------------------------------------------------------------------- /third-party/mapbox/README.md.license: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (c) MapBox 2016. All rights reserved. 3 | # SPDX-License-Identifier: BSD-3-Clause 4 | # -------------------------------------------------------------------------------- /third-party/stb/LICENSE.spdx: -------------------------------------------------------------------------------- 1 | PackageName: stb 2 | SPDXID: SPDXRef-stb 3 | FilesAnalyzed: true 4 | PackageLicenseConcluded: MIT 5 | PackageLicenseInfoFromFiles: MIT 6 | PackageLicenseDeclared: MIT 7 | PackageCopyrightText: Copyright (c) 2017 Sean Barrett 8 | --------------------------------------------------------------------------------