text stringlengths 1 24.5M |
|---|
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "RefBackend.hpp"
#include <armnn/BackendRegistry.hpp>
namespace
{
using namespace armnn;
static BackendRegistry::StaticRegistryInitializer g_RegisterHelper
{
BackendRegistryInstance(),
RefBackend::GetIdStatic(... |
//
// Copyright © 2019-2024 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "RefTensorHandle.hpp"
namespace armnn
{
RefTensorHandle::RefTensorHandle(const TensorInfo& tensorInfo, std::shared_ptr<RefMemoryManager>& memoryManager):
m_TensorInfo(tensorInfo),
m_MemoryManager(memoryMana... |
//
// Copyright © 2019-2023 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/backends/TensorHandle.hpp>
#include "RefMemoryManager.hpp"
namespace armnn
{
class RefTensorHandleDecorator;
// An implementation of ITensorHandle with simple "bump the pointer" memory-managem... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "RefTensorHandleFactory.hpp"
#include "RefTensorHandle.hpp"
#include <armnn/utility/IgnoreUnused.hpp>
namespace armnn
{
using FactoryId = ITensorHandleFactory::FactoryId;
const FactoryId& RefTensorHandleFactory::GetId... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "RefMemoryManager.hpp"
#include <armnn/backends/ITensorHandleFactory.hpp>
namespace armnn
{
constexpr const char * RefTensorHandleFactoryId() { return "Arm/Ref/TensorHandleFactory"; }
class RefTensorHand... |
//
// Copyright © 2017-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <Layer.hpp>
#include <backendsCommon/MemImportWorkload.hpp>
#include <backendsCommon/MakeWorkloadHelper.hpp>
#include <armnn/backends/MemCopyWorkload.hpp>
#include <armnn/backends/TensorHandle.hpp>
... |
//
// Copyright © 2017-2023 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "RefMemoryManager.hpp"
#include <armnn/Optional.hpp>
#include <armnn/backends/WorkloadFactory.hpp>
#include <armnn/utility/IgnoreUnused.hpp>
namespace armnn
{
template <typename Queu... |
//
// Copyright © 2019 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <reference/workloads/ArgMinMax.hpp>
#include <doctest/doctest.h>
TEST_SUITE("RefArgMinMax")
{
TEST_CASE("ArgMinTest")
{
const armnn::TensorInfo inputInfo({ 1, 2, 3 } , armnn::DataType::Float32);
const armnn::Ten... |
//
// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <backendsCommon/TensorHandleFactoryRegistry.hpp>
#include <reference/RefBackend.hpp>
#include <reference/RefTensorHandleFactory.hpp>
#include <armnn/backends/WorkloadFactory.hpp>
#include <doctest/doctes... |
//
// Copyright © 2017, 2023 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <CreateWorkload.hpp>
#include <armnn/utility/PolymorphicDowncast.hpp>
#include <reference/RefTensorHandle.hpp>
#include <reference/RefTensorHandleFactory.hpp>
#include <reference/RefWorkloadFactory... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <reference/workloads/DetectionPostProcess.hpp>
#include <armnn/Descriptors.hpp>
#include <armnn/Types.hpp>
#include <doctest/doctest.h>
TEST_SUITE("RefDetectionPostProcess")
{
TEST_CASE("TopKSortTest")
{
unsigned i... |
//
// Copyright © 2017-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <backendsCommon/test/EndToEndTestImpl.hpp>
#include <backendsCommon/test/ActivationEndToEndTestImpl.hpp>
#include <backendsCommon/test/AdditionEndToEndTestImpl.hpp>
#include <backendsCommon/test/Arg... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <armnn/BackendId.hpp>
#include <backendsCommon/test/JsonPrinterTestImpl.hpp>
#include <doctest/doctest.h>
#include <vector>
TEST_SUITE("RefJsonPrinter")
{
TEST_CASE("SoftmaxProfilerJsonPrinterCpuRefTest")
{
std::v... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <layers/ConvertFp16ToFp32Layer.hpp>
#include <layers/ConvertFp32ToFp16Layer.hpp>
#include <armnnTestUtils/TensorHelpers.hpp>
#include <armnn/backends/TensorHandle.hpp>
#include <reference/RefWorkloadFactory.hpp>
#includ... |
//
// Copyright © 2017,2022-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "RefWorkloadFactoryHelper.hpp"
#include <backendsCommon/test/LayerTests.hpp>
#include <reference/RefWorkloadFactory.hpp>
#include <UnitTests.hpp>
TEST_SUITE("Compute_Reference")
{
using nam... |
//
// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <reference/RefWorkloadFactory.hpp>
#include <reference/RefBackend.hpp>
#include <armnnTestUtils/LayerTestResult.hpp>
#include <armnnTestUtils/MemCopyTestImpl.hpp>
#include <armnnTestUtils/MockBackend.hpp>... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <reference/RefMemoryManager.hpp>
#include <doctest/doctest.h>
TEST_SUITE("RefMemoryManagerTests")
{
using namespace armnn;
using Pool = RefMemoryManager::Pool;
TEST_CASE("ManageOneThing")
{
RefMemoryManager memoryM... |
//
// Copyright © 2017-2023 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <doctest/doctest.h>
#include <Graph.hpp>
#include <armnn/BackendId.hpp>
#include <armnn/Descriptors.hpp>
#include <armnn/INetwork.hpp>
#include <armnn/IRuntime.hpp>
#include <armnn/Tensor.hpp>
#inclu... |
//
// Copyright © 2021 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <reference/workloads/Decoders.hpp>
#include <armnn/utility/IgnoreUnused.hpp>
#include <fmt/format.h>
#include <doctest/doctest.h>
#include <chrono>
template<typename T>
void CompareVector(std::vector... |
//
// Copyright © 2021 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <reference/workloads/Decoders.hpp>
#include <fmt/format.h>
#include <doctest/doctest.h>
TEST_SUITE("RefPerChannelDecoder")
{
template<typename T>
void CompareVector(std::vector<T> vec1, std::vector<T> ... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <test/RuntimeTests.hpp>
#include <LeakChecking.hpp>
#include <backendsCommon/test/RuntimeTestImpl.hpp>
#include <doctest/doctest.h>
#ifdef ARMNN_LEAK_CHECKING_ENABLED
TEST_SUITE("RefRuntime")
{
TEST_CASE("RuntimeMemo... |
//
// Copyright © 2017, 2022, 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <doctest/doctest.h>
#include <armnn/BackendId.hpp>
#include <armnn/INetwork.hpp>
#include <armnn/Tensor.hpp>
#include <armnn/Types.hpp>
#include <armnn/backends/ITensorHandle.hpp>
#include <a... |
//
// Copyright © 2017 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <backendsCommon/test/WorkloadFactoryHelper.hpp>
#include <armnn/utility/PolymorphicDowncast.hpp>
#include <reference/RefBackend.hpp>
#include <reference/RefWorkloadFactory.hpp>
#include "r... |
//
// Copyright © 2019 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <iostream>
namespace armnn
{
template<typename T>
struct abs
{
typedef T result_type;
typedef T argument_type;
T
operator () (const T& inputData) const
{
... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "Activation.hpp"
#include <cmath>
namespace armnn
{
float Activation(float in,
ActivationFunction function,
float a,
float b)
{
float output;
// Compute the r... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "BaseIterator.hpp"
#include <armnn/Tensor.hpp>
#include <armnn/Types.hpp>
namespace armnn
{
float Activation(float in,
ActivationFunction function,
float a,
float b);
... |
//
// Copyright © 2019 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "ArgMinMax.hpp"
#include <armnnUtils/TensorUtils.hpp>
#include <armnn/utility/IgnoreUnused.hpp>
#include <armnn/utility/NumericCast.hpp>
namespace armnn
{
template <typename OUT>
void ArgMinMax(Decoder<float>& in, OUT... |
//
// Copyright © 2019 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "armnn/Tensor.hpp"
#include "armnn/Descriptors.hpp"
#include "Decoders.hpp"
namespace armnn
{
template <typename OUT>
void ArgMinMax(Decoder<float>& in, OUT *out, const TensorInfo& inputTensorInfo,
... |
//
// Copyright © 2017-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/TypesUtils.hpp>
#include <armnn/utility/NumericCast.hpp>
#include <armnnUtils/FloatingPointConverter.hpp>
#include <armnnUtils/TensorUtils.hpp>
#include <ResolveType.hpp>
names... |
//
// Copyright © 2022, 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "BatchMatMulImpl.hpp"
#include <armnn/backends/WorkloadData.hpp>
#include <armnn/Logging.hpp>
#include <armnnUtils/Permute.hpp>
namespace armnn
{
BatchMatMul::BatchMatMul(const BatchMatMulDescrip... |
//
// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "Encoders.hpp"
#include "Decoders.hpp"
#include <armnn/backends/WorkloadData.hpp>
namespace armnn
{
class BatchMatMul {
public:
BatchMatMul(const BatchMatMulDescriptor& params,
... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "BatchNormImpl.hpp"
#include "RefWorkloadUtils.hpp"
#include <armnn/Tensor.hpp>
#include <armnnUtils/DataLayoutIndexed.hpp>
#include <cmath>
namespace armnn
{
void BatchNormImpl(const BatchNormalizationQueueDescripto... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "Encoders.hpp"
#include "Decoders.hpp"
#include <armnn/backends/WorkloadData.hpp>
namespace armnn
{
void BatchNormImpl(const BatchNormalizationQueueDescriptor& data,
Decoder<float>& mea... |
//
// Copyright © 2017-2020,2023 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "BatchToSpaceNd.hpp"
#include <armnnUtils/DataLayoutIndexed.hpp>
using namespace armnnUtils;
namespace armnn
{
unsigned int Offset(const TensorShape& shape,
unsigned int ... |
//
// Copyright © 2017-2019,2021,2023 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "BaseIterator.hpp"
#include "Decoders.hpp"
#include "Encoders.hpp"
#include <armnn/Descriptors.hpp>
namespace armnn
{
void BatchToSpaceNd(const TensorInfo& inputInfo,
... |
//
// Copyright © 2019,2024 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "Broadcast.hpp"
namespace armnn
{
BroadcastLoop::BroadcastLoop(const TensorShape& inShape0, const TensorShape& inShape1, const TensorShape& outShape)
: m_DimData(outShape.GetNumDimensions())
{
const unsigned in... |
//
// Copyright © 2019 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "BaseIterator.hpp"
#include <armnn/Tensor.hpp>
#include <functional>
namespace armnn
{
struct BroadcastLoop
{
BroadcastLoop(const TensorShape& inShape0, const TensorShape& inShape1, const TensorShape& outShape);
... |
//
// Copyright © 2023 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <iostream>
namespace armnn
{
template<typename T>
struct ceil
{
typedef T result_type;
typedef T argument_type;
T
operator () (const T& inputData) cons... |
//
// Copyright © 2017, 2024 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "Concatenate.hpp"
#include "RefWorkloadUtils.hpp"
#include "Decoders.hpp"
#include "Encoders.hpp"
namespace armnn
{
void Concatenate(const ConcatQueueDescriptor &data,
std::vector<ITensorHandle*> ... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/backends/WorkloadData.hpp>
#include <armnn/Tensor.hpp>
namespace armnn
{
void Concatenate(const ConcatQueueDescriptor &data,
std::vector<ITensorHandle*> inputs,
std:... |
//
// Copyright © 2021 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "Conv3dImpl.hpp"
namespace armnn
{
void Convolve3d(const TensorShape& rInputShape,
Decoder<float>& rInputDecoder,
const TensorShape& rOutputShape,
Encoder... |
//
// Copyright © 2021 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "BaseIterator.hpp"
#include "Decoders.hpp"
#include "Encoders.hpp"
#include <armnn/Tensor.hpp>
#include <armnnUtils/DataLayoutIndexed.hpp>
namespace armnn
{
void Convolve3d(const TensorS... |
//
// Copyright © 2017, 2024 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "ConvImpl.hpp"
#include <cmath>
#include <limits>
namespace armnn
{
QuantizedMultiplierSmallerThanOne::QuantizedMultiplierSmallerThanOne(float multiplier)
{
ARMNN_THROW_INVALIDARG_MSG_IF_FALSE(multiplier >= 0... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "RefWorkloadUtils.hpp"
#include "TensorBufferArrayView.hpp"
#include "BaseIterator.hpp"
#include "Decoders.hpp"
#include "Encoders.hpp"
#include <armnn/Tensor.hpp>
#include <armnnUtils/DataLayoutIndexed.hp... |
//
// Copyright © 2017-2023 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "Debug.hpp"
#include <common/include/ProfilingGuid.hpp>
#include <armnnUtils/Filesystem.hpp>
#include <BFloat16.hpp>
#include <Half.hpp>
#include <algorithm>
#include <iostream>
#include <iosfwd>
#... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/Tensor.hpp>
namespace armnn
{
template <typename T>
void Debug(const TensorInfo& inputInfo,
const T* inputData,
LayerGuid guid,
const std::string& layerName,
... |
//
// Copyright © 2017, 2024 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "BaseIterator.hpp"
#include <armnnUtils/FloatingPointConverter.hpp>
#include <armnnUtils/TensorUtils.hpp>
namespace armnn
{
namespace
{
inline std::unique_ptr<Decoder<float>> MakeSigned32PerAxisDec... |
//
// Copyright © 2019, 2024 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "DepthToSpace.hpp"
#include <armnnUtils/DataLayoutIndexed.hpp>
#include <armnnUtils/Permute.hpp>
using namespace armnnUtils;
namespace armnn
{
void DepthToSpace(const TensorInfo& inputInfo,
con... |
//
// Copyright © 2019 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/Descriptors.hpp>
#include <armnn/Tensor.hpp>
namespace armnn
{
void DepthToSpace(const TensorInfo& inputInfo,
const DepthToSpaceDescriptor& descriptor,
const void... |
//
// Copyright © 2019, 2024 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "Dequantize.hpp"
namespace armnn
{
void Dequantize(Decoder<float>& inputDecoder,
Encoder<float>& outputEncoder,
const TensorInfo& inputInfo,
const TensorInfo& output... |
//
// Copyright © 2019 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/Tensor.hpp>
#include "Encoders.hpp"
#include "Decoders.hpp"
namespace armnn
{
void Dequantize(Decoder<float>& inputDecoder,
Encoder<float>& outputEncoder,
const Tenso... |
//
// Copyright © 2017, 2024 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "DetectionPostProcess.hpp"
#include <armnn/utility/NumericCast.hpp>
#include <algorithm>
#include <numeric>
namespace armnn
{
std::vector<unsigned int> GenerateRangeK(unsigned int k)
{
std::vector<unsigned i... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "armnn/Tensor.hpp"
#include "armnn/Descriptors.hpp"
#include "Decoders.hpp"
#include <vector>
namespace armnn
{
void DetectionPostProcess(const TensorInfo& boxEncodingsInfo,
cons... |
//
// Copyright © 2017-2021, 2023-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "ElementwiseFunction.hpp"
#include "Broadcast.hpp"
#include "Minimum.hpp"
#include "Maximum.hpp"
#include "Abs.hpp"
#include "Ceil.hpp"
#include "Exp.hpp"
#include "Log.hpp"
#include "Rsqr... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "BaseIterator.hpp"
#include <armnn/Tensor.hpp>
namespace armnn
{
template <typename Functor>
struct ElementwiseBinaryFunction
{
using OutType = typename Functor::result_type;
using InType = typenam... |
//
// Copyright © 2017-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "BaseIterator.hpp"
#include <armnnUtils/TensorUtils.hpp>
namespace armnn
{
template<typename T>
inline std::unique_ptr<Encoder<T>> MakeEncoder(const TensorInfo& info, void* data = nu... |
//
// Copyright © 2019 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <iostream>
namespace armnn
{
template<typename T>
struct exp
{
typedef T result_type;
typedef T argument_type;
T
operator () (const T& inputData) const
{
... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "Fill.hpp"
#include "RefWorkloadUtils.hpp"
namespace armnn
{
void Fill(Encoder<float>& output,
const TensorShape& desiredOutputShape,
const float value)
{
for(unsigned int i = 0... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "BaseIterator.hpp"
#include "Decoders.hpp"
#include "Encoders.hpp"
#include <armnn/Tensor.hpp>
#include <armnn/backends/WorkloadData.hpp>
namespace armnn
{
/// Creates a tensor and fills i... |
//
// Copyright © 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
namespace armnn
{
template<typename T>
struct floorDiv
{
typedef T result_type;
typedef T first_argument_type;
T operator () (const T& inputData0, const T& inputData1) const
{
... |
//
// Copyright © 2017, 2024 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "FullyConnected.hpp"
#include "RefWorkloadUtils.hpp"
namespace armnn
{
void FullyConnected(const TensorShape& rInputShape,
Decoder<float>& rInputDecoder,
const TensorShape&... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "BaseIterator.hpp"
#include "Decoders.hpp"
#include "Encoders.hpp"
#include <armnn/Tensor.hpp>
#include <armnn/backends/WorkloadData.hpp>
namespace armnn
{
/// Performs a matrix multiplication and optional... |
//
// Copyright © 2017,2022-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "Gather.hpp"
#include <armnn/backends/WorkloadData.hpp>
#include <fmt/format.h>
namespace armnn
{
template<typename I, typename O>
void Gather(const TensorInfo& paramsInfo,
const ... |
//
// Copyright © 2017, 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "armnn/Tensor.hpp"
#include "BaseIterator.hpp"
#include "Decoders.hpp"
#include "Encoders.hpp"
namespace armnn
{
template<typename I, typename O>
void Gather(const TensorInfo& param... |
//
// Copyright © 2019 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "InstanceNorm.hpp"
#include "RefWorkloadUtils.hpp"
#include <armnn/Tensor.hpp>
#include <armnnUtils/DataLayoutIndexed.hpp>
#include <cmath>
namespace armnn
{
void InstanceNorm(const InstanceNormalizationQueueDescript... |
//
// Copyright © 2019 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "Encoders.hpp"
#include "Decoders.hpp"
#include <armnn/backends/WorkloadData.hpp>
namespace armnn
{
void InstanceNorm(const InstanceNormalizationQueueDescriptor& data,
const TensorInfo& ... |
//
// Copyright © 2021 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <iostream>
namespace armnn
{
template<typename T>
struct log
{
typedef T result_type;
typedef T argument_type;
T
operator () (const T& inputData) const... |
//
// Copyright © 2019, 2024 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "LogSoftmax.hpp"
#include <armnnUtils/TensorUtils.hpp>
#include <armnn/utility/NumericCast.hpp>
#include <cmath>
namespace
{
inline bool ValidateAxis(int axis, unsigned int numDimensions)
{
const int sNumDim... |
//
// Copyright © 2019 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/Descriptors.hpp>
#include <armnn/Tensor.hpp>
#include "BaseIterator.hpp"
namespace armnn
{
void LogSoftmax(Decoder<float>& input,
Encoder<float>& output,
const Tenso... |
//
// Copyright © 2021 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "Activation.hpp"
#include "Lstm.hpp"
#include "LstmUtils.hpp"
namespace armnn
{
void LstmImpl(const LstmDescriptor& descriptor,
const TensorInfo& inputInfo,
const TensorInfo&... |
//
// Copyright © 2021 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/TypesUtils.hpp>
#include <armnn/backends/WorkloadData.hpp>
#include "Encoders.hpp"
#include "Decoders.hpp"
namespace armnn
{
void LstmImpl(const LstmDescriptor& descriptor,
... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
//#pragma once
#include "LstmUtils.hpp"
#include "BaseIterator.hpp"
#include <armnn/backends/TensorHandle.hpp>
// Helper functions ported from the Android code base
// Refer to: android/external/tensorflow/tensorflow/contrib/li... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "BaseIterator.hpp"
#include <armnn/backends/TensorHandle.hpp>
// Helper functions ported from the Android code base
// Refer to: android/external/tensorflow/tensorflow/contrib/lite/kernels/internal/referenc... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
namespace armnn
{
template<typename T>
struct maximum
{
typedef T result_type;
typedef T first_argument_type;
T operator () (const T& inputData0, const T& inputData1) const
{
return std::... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
namespace armnn
{
template<typename T>
struct minimum
{
typedef T result_type;
typedef T first_argument_type;
T
operator()(const T& input1, const T& input2) const
{
return std::min(input... |
//
// Copyright © 2021, 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "MirrorPad.hpp"
#include "BaseIterator.hpp"
#include "Decoders.hpp"
#include "Encoders.hpp"
namespace
{
// Convert a linear index into n-dimensional coordinates.
// E.g. index = 2 returns [0, 0, ... |
//
// Copyright © 2021 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "armnn/Tensor.hpp"
#include <armnn/backends/Workload.hpp>
#include <armnn/backends/WorkloadData.hpp>
namespace armnn
{
void MirrorPad(const TensorInfo& inputInfo,
const Ten... |
//
// Copyright © 2017,2024 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "Pad.hpp"
#include "BaseIterator.hpp"
#include "Decoders.hpp"
#include "Encoders.hpp"
#include <armnnUtils/TensorUtils.hpp>
#include <cmath>
#include <cstddef>
#include <functional>
#include <limits>
#include <cas... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "armnn/Tensor.hpp"
#include <armnn/backends/Workload.hpp>
#include <armnn/backends/WorkloadData.hpp>
namespace armnn
{
void Pad(const TensorInfo& inputInfo,
const TensorInfo& outputInfo,
... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "Pooling2d.hpp"
#include <armnn/Exceptions.hpp>
#include <armnn/Types.hpp>
#include <armnnUtils/DataLayoutIndexed.hpp>
#include <armnn/utility/NumericCast.hpp>
#include <limits>
#include <algorithm>
#include <functiona... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/Descriptors.hpp>
#include <armnn/Tensor.hpp>
#include "BaseIterator.hpp"
namespace armnn
{
/// Computes the Pooling2d operation.
void Pooling2d(Decoder<float>& rInputDecoder,
Encoder<... |
//
// Copyright © 2021 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "Pooling3d.hpp"
#include <armnn/Exceptions.hpp>
#include <armnn/Types.hpp>
#include <armnnUtils/DataLayoutIndexed.hpp>
#include <armnn/utility/NumericCast.hpp>
#include <limits>
#include <algorithm>
#i... |
//
// Copyright © 2021 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/Descriptors.hpp>
#include <armnn/Tensor.hpp>
#include "BaseIterator.hpp"
namespace armnn
{
/// Computes the Pooling3d operation.
void Pooling3d(Decoder<float>& rInputDecoder,
... |
//
// Copyright © 2023 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <iostream>
namespace armnn
{
template<typename T>
struct power
{
typedef T result_type;
typedef T first_argument_type;
T
operator()(const T& input1, const T& input2) const... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "PreluImpl.hpp"
#include "RefWorkloadUtils.hpp"
#include "Broadcast.hpp"
namespace armnn
{
void PreluImpl(const TensorInfo& inputInfo,
const TensorInfo& alphaInfo,
const TensorInfo& outputI... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "Encoders.hpp"
#include "Decoders.hpp"
#include <armnn/backends/WorkloadData.hpp>
namespace armnn
{
void PreluImpl(const TensorInfo& inputInfo,
const TensorInfo& alphaInfo,
c... |
//
// Copyright © 2021, 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "Reduce.hpp"
#include <armnn/utility/NumericCast.hpp>
#include <armnn/backends/WorkloadData.hpp>
#include <cstddef>
#include <functional>
#include <limits>
namespace armnn
{
bool NextIndex(cons... |
//
// Copyright © 2021 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "BaseIterator.hpp"
#include "Decoders.hpp"
#include "Encoders.hpp"
#include <armnn/Tensor.hpp>
namespace armnn
{
void Reduce(const TensorInfo& inputInfo,
const TensorInfo& ou... |
//
// Copyright © 2017,2019-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "RefActivationWorkload.hpp"
#include "Activation.hpp"
#include "Decoders.hpp"
#include "Encoders.hpp"
#include "RefWorkloadUtils.hpp"
#include "Profiling.hpp"
namespace armnn
{
void RefActiv... |
//
// Copyright © 2022, 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "RefBaseWorkload.hpp"
#include <armnn/backends/WorkloadData.hpp>
namespace armnn
{
class RefActivationWorkload : public RefBaseWorkload<ActivationQueueDescriptor>
{
public:
using... |
//
// Copyright © 2019-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "RefArgMinMaxWorkload.hpp"
#include "ArgMinMax.hpp"
#include "RefWorkloadUtils.hpp"
#include "Decoders.hpp"
#include "Profiling.hpp"
namespace armnn
{
RefArgMinMaxWorkload::RefArgMinMaxWorkload(
... |
//
// Copyright © 2022, 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "RefBaseWorkload.hpp"
#include <armnn/backends/WorkloadData.hpp>
namespace armnn
{
class RefArgMinMaxWorkload : public RefBaseWorkload<ArgMinMaxQueueDescriptor>
{
public:
explicit... |
//
// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/backends/Workload.hpp>
namespace armnn
{
template <typename QueueDescriptor>
class RefBaseWorkload : public BaseWorkload<QueueDescriptor>
{
public:
RefBaseWor... |
//
// Copyright © 2022-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "RefBatchMatMulWorkload.hpp"
#include "BatchMatMulImpl.hpp"
#include "RefWorkloadUtils.hpp"
#include "Profiling.hpp"
namespace armnn
{
RefBatchMatMulWorkload::RefBatchMatMulWorkload(const BatchMat... |
//
// Copyright © 2022, 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "RefBaseWorkload.hpp"
#include <armnn/backends/WorkloadData.hpp>
#include "BatchMatMulImpl.hpp"
namespace armnn
{
class RefBatchMatMulWorkload : public RefBaseWorkload<BatchMatMulQu... |
//
// Copyright © 2017,2019-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "RefBatchNormalizationWorkload.hpp"
#include "BatchNormImpl.hpp"
#include "RefWorkloadUtils.hpp"
#include "Profiling.hpp"
namespace armnn
{
RefBatchNormalizationWorkload::RefBatchNormalizati... |
//
// Copyright © 2022, 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "RefBaseWorkload.hpp"
#include <armnn/backends/WorkloadData.hpp>
namespace armnn
{
class RefBatchNormalizationWorkload : public RefBaseWorkload<BatchNormalizationQueueDescriptor>
{
p... |
//
// Copyright © 2017,2019,2021-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "RefBatchToSpaceNdWorkload.hpp"
#include "BatchToSpaceNd.hpp"
#include "RefWorkloadUtils.hpp"
namespace armnn
{
void RefBatchToSpaceNdWorkload::Execute() const
{
Execute(m_Data.m_Inp... |
//
// Copyright © 2018-2019,2021-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "RefBaseWorkload.hpp"
namespace armnn
{
class RefBatchToSpaceNdWorkload : public RefBaseWorkload<BatchToSpaceNdQueueDescriptor>
{
public:
using RefBaseWorkload<BatchToS... |
//
// Copyright © 2023-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "RefBroadcastToWorkload.hpp"
#include "RefWorkloadUtils.hpp"
#include "Profiling.hpp"
#include "Broadcast.hpp"
#include "Decoders.hpp"
#include "Encoders.hpp"
namespace armnn
{
RefBroadcastToWorkl... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.