text stringlengths 1 24.5M |
|---|
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#ifdef ARMNN_HEAP_PROFILING_ENABLED
#include "HeapProfiling.hpp"
#include "gperftools/heap-profiler.h"
#include <sstream>
#include <cstdlib>
namespace armnnUtils
{
ScopedHeapProfiler::ScopedHeapProfiler(const std::string & tag)... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#ifdef ARMNN_HEAP_PROFILING_ENABLED
#include <string>
#include <cstddef>
// This is conditional so we can change the environment variable
// at build time.
#ifndef ARMNN_HEAP_PROFILE_DUMP_DIR
#define ARMNN_HEAP_PROF... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#ifdef ARMNN_LEAK_CHECKING_ENABLED
#include "LeakChecking.hpp"
#include "gperftools/heap-checker.h"
namespace armnnUtils
{
struct ScopedLeakChecker::Impl
{
HeapLeakChecker m_LeakChecker;
Impl(const std::string & name)
... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#ifdef ARMNN_LEAK_CHECKING_ENABLED
#include <string>
#include <cstddef>
#include <memory>
namespace armnnUtils
{
class ScopedLeakChecker final
{
public:
ScopedLeakChecker(const std::string & name);
~ScopedL... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "ModelAccuracyChecker.hpp"
#include <armnn/Exceptions.hpp>
#include <armnn/Logging.hpp>
#include <map>
#include <vector>
namespace armnnUtils
{
armnnUtils::ModelAccuracyChecker::ModelAccuracyChecker(const std::map<std... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <algorithm>
#include <armnn/Types.hpp>
#include <armnn/utility/Assert.hpp>
#include <mapbox/variant.hpp>
#include <cstddef>
#include <functional>
#include <iostream>
#include <map>
#include <string>
#include... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "ParserHelper.hpp"
#include <armnn/Descriptors.hpp>
#include <armnnUtils/Permute.hpp>
#include <fmt/format.h>
namespace armnnUtils
{
const armnn::PermutationVector NHWCToArmNN = { 0, 2, 3, 1 };
const armnn::Permutatio... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/DescriptorsFwd.hpp>
#include <armnn/TensorFwd.hpp>
#include <set>
namespace armnnUtils
{
void ProcessConcatInputTensorInfo(armnn::TensorInfo& inputTensorInfo,
armn... |
//
// Copyright © 2017-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/IRuntime.hpp>
#include <armnnTestUtils/TensorHelpers.hpp>
#include <Network.hpp>
#include <VerificationHelpers.hpp>
#include <doctest/doctest.h>
#include <fmt/format.h>
#inclu... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <armnn/Tensor.hpp>
#include <armnnUtils/Permute.hpp>
#include "Half.hpp"
#include <cstring>
namespace
{
class PermuteLoop
{
public:
using size_type = unsigned int;
PermuteLoop(const armnn::TensorShape& dstSh... |
//
// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "ProfilingOptionsConverter.hpp"
#include <algorithm>
#include <iterator>
namespace arm
{
namespace pipe
{
ProfilingOptions ConvertExternalProfilingOptions(
const armnn::IRuntime::CreationOptions::... |
//
// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/IRuntime.hpp>
#include <client/include/ProfilingOptions.hpp>
namespace arm
{
namespace pipe
{
ProfilingOptions ConvertExternalProfilingOptions(
const armnn::IRuntime::Creation... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "PrototxtConversions.hpp"
#include "armnn/Tensor.hpp"
#include <iomanip>
#include <sstream>
#include <string>
namespace armnnUtils
{
/// Converts an int value into the Prototxt octal representation
std::string ConvertI... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <string>
namespace armnn
{
class TensorShape;
} // namespace armnn
namespace armnnUtils
{
/// Converts an int value into the Prototxt octal representation
std::string ConvertInt32ToOctalString(int value);... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/Tensor.hpp>
#include <fmt/format.h>
#include <mapbox/variant.hpp>
namespace armnnUtils
{
template<typename TContainer>
inline armnn::InputTensors MakeInputTensors(const std::vector<armnn::BindingPo... |
//
// Copyright © 2017-2023 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <armnnUtils/TensorUtils.hpp>
#include <armnn/Exceptions.hpp>
#include <armnn/backends/ITensorHandle.hpp>
#include <armnn/utility/Assert.hpp>
#include <armnn/utility/NumericCast.hpp>
#include <fmt/format.h>
using ... |
//
// Copyright © 2020 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <armnn/Tensor.hpp>
#include <armnnUtils/Transpose.hpp>
#include "Half.hpp"
#include <cstring>
namespace
{
class TransposeLoop
{
public:
using size_type = unsigned int;
TransposeLoop(const armnn::TensorShape&... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "VerificationHelpers.hpp"
#include <armnn/Exceptions.hpp>
#include <fmt/format.h>
using namespace armnn;
namespace armnnUtils
{
void CheckValidSize(std::initializer_list<size_t> validInputCounts,
s... |
//
// Copyright © 2017,2023 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <iostream>
#include <sstream>
#include <cstdint>
#include <armnn/Exceptions.hpp>
namespace armnnUtils
{
void CheckValidSize(std::initializer_list<size_t> validInputCounts,
size_... |
//
// Copyright © 2020 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <armnnUtils/FloatingPointComparison.hpp>
#include <doctest/doctest.h>
using namespace armnnUtils;
TEST_SUITE("FloatingPointComparisonSuite")
{
TEST_CASE("FloatingPointComparisonDefaultTolerance")
{
// 1% range of 1... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "../ParserHelper.hpp"
#include <armnn/Tensor.hpp>
#include <armnn/Types.hpp>
#include <doctest/doctest.h>
using namespace armnn;
using namespace armnnUtils;
TEST_SUITE("ParserHelperSuite")
{
TEST_CASE("CalculateReduc... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <PrototxtConversions.hpp>
#include "armnn/Tensor.hpp"
#include <doctest/doctest.h>
TEST_SUITE("PrototxtConversions")
{
TEST_CASE("ConvertInt32ToOctalStringTest")
{
using armnnUtils::ConvertInt32ToOctalString;
s... |
//
// Copyright © 2019 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <armnnUtils/QuantizeHelper.hpp>
#include <armnn/utility/IgnoreUnused.hpp>
#include <doctest/doctest.h>
#include <vector>
TEST_SUITE("QuantizeHelper")
{
namespace
{
template<typename T>
bool IsFloatIterFunc(T iter)
{
... |
//
// Copyright © 2019,2021-2023 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <armnn/Types.hpp>
#include <armnnUtils/TensorUtils.hpp>
#include <doctest/doctest.h>
using namespace armnn;
using namespace armnnUtils;
TEST_SUITE("TensorUtilsSuite")
{
TEST_CASE("ExpandDims... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <armnn/utility/TransformIterator.hpp>
#include <doctest/doctest.h>
#include <vector>
#include <iostream>
using namespace armnn;
TEST_SUITE("TransformIteratorSuite")
{
namespace
{
static int square(con... |
//
// Copyright © 2020-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/backends/OptimizationViews.hpp>
#include <aclCommon/ArmComputeUtils.hpp>
#include <backendsCommon/SubgraphUtils.hpp>
namespace armnn
{
namespace
{
//
// this helper only work... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/backends/ITensorHandle.hpp>
#include <arm_compute/runtime/IMemoryGroup.h>
#include <arm_compute/runtime/Tensor.h>
namespace armnn
{
class IAclTensorHandle : public ITensorHandle
{
public:
virtu... |
//
// Copyright © 2017-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <armnn/Exceptions.hpp>
#include <aclCommon/ArmComputeTensorUtils.hpp>
#include <aclCommon/ArmComputeUtils.hpp>
#include "ArmComputeUtils.hpp"
#include <armnn/Descriptors.hpp>
#include <fmt/format.h... |
//
// Copyright © 2017-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/Tensor.hpp>
#include <armnn/DescriptorsFwd.hpp>
#include <armnn/utility/NumericCast.hpp>
#include <arm_compute/core/ITensor.h>
#include <arm_compute/core/TensorInfo.h>
#include ... |
//
// Copyright © 2023 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "ArmComputeTuningUtils.hpp"
namespace armnn
{
IGpuAccTunedParameters* IGpuAccTunedParameters::CreateRaw(IGpuAccTunedParameters::Mode mode,
IGpuA... |
//
// Copyright © 2023 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/BackendOptions.hpp>
#include <armnn/IRuntime.hpp>
#include <armnn/Logging.hpp>
#include <arm_compute/runtime/CL/CLTuner.h>
#include <arm_compute/runtime/CL/CLTunerTypes.h>
#include <a... |
//
// Copyright © 2017-2024 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/Descriptors.hpp>
#include <armnn/Exceptions.hpp>
#include <armnn/Tensor.hpp>
#include <armnn/utility/NumericCast.hpp>
#include <armnn/backends/WorkloadData.hpp>
#include <armnnUtils/TensorUtils.hp... |
//
// Copyright © 2017-2024 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "BaseMemoryManager.hpp"
#if defined(ARMCOMPUTENEON_ENABLED) || defined(ARMCOMPUTECL_ENABLED)
#include "arm_compute/runtime/BlobLifetimeManager.h"
#include "arm_compute/runtime/PoolManager.h"
#include "arm_compute/run... |
//
// Copyright © 2017-2023 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/backends/IMemoryManager.hpp>
#include <armnn/backends/WorkloadFactory.hpp>
#if defined(ARMCOMPUTENEON_ENABLED) || defined(ARMCOMPUTECL_ENABLED)
#include <arm_compute/runtime/MemoryGroup.h>
#inclu... |
//
// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <arm_compute/core/CL/ICLTensor.h>
#include <arm_compute/runtime/MemoryGroup.h>
namespace armnn
{
class IClTensorHandle : public IAclTensorHandle
{
public:
virtual arm_compute::ICLTensor... |
//
// Copyright © 2019, 2024 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <aclCommon/ArmComputeTensorUtils.hpp>
#include <aclCommon/ArmComputeUtils.hpp>
#include <doctest/doctest.h>
using namespace armnn::armcomputetensorutils;
TEST_SUITE("ArmComputeTensorUtils")
{
TEST_CASE("BuildArmC... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <CreateWorkload.hpp>
#include <armnnTestUtils/PredicateResult.hpp>
#include <armnn/utility/PolymorphicDowncast.hpp>
#include <armnn/backends/MemCopyWorkload.hpp>
#include <reference/RefWorkloadFactory.hpp>
#i... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <aclCommon/ArmComputeTensorUtils.hpp>
#if defined(ARMCOMPUTECL_ENABLED) && defined(ARMCOMPUTENEON_ENABLED)
#include <armnnTestUtils/LayerTestResult.hpp>
#include <armnnTestUtils/MemCopyTestImpl.hpp>
#include <cl/ClWorklo... |
//
// Copyright © 2021 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <cstddef>
#include <memory>
#include <armnn/MemorySources.hpp>
#include <armnn/utility/IgnoreUnused.hpp>
namespace armnn
{
/** Default Memory Allocator class returned from IBackendInternal... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <armnn/backends/DynamicBackend.hpp>
#include <backendsCommon/DynamicBackendUtils.hpp>
namespace armnn
{
DynamicBackend::DynamicBackend(const void* sharedObjectHandle)
: m_BackendIdFunction(nullptr)
, m_BackendVe... |
//
// Copyright © 2017 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <armnn/Logging.hpp>
#include <backendsCommon/DynamicBackendUtils.hpp>
#include "armnn/utility/StringUtils.hpp"
#include <armnnUtils/Filesystem.hpp>
#include <regex>
namespace armnn
{
void* DynamicBacke... |
//
// Copyright © 2017 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/backends/DynamicBackend.hpp>
#include <armnn/backends/IBackendInternal.hpp>
#include <armnn/Exceptions.hpp>
#include <fmt/format.h>
#include <string>
#include <vector>
#if defined(... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <armnn/BackendOptions.hpp>
#include <armnn/backends/IBackendInternal.hpp>
#include <armnn/backends/WorkloadFactory.hpp>
namespace armnn
{
IMemoryManagerUniquePtr IBackendInternal::CreateMemoryManager() const
{
retur... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <armnn/backends/ITensorHandleFactory.hpp>
namespace armnn
{
const ITensorHandleFactory::FactoryId ITensorHandleFactory::LegacyFactoryId = "armnn_legacy_factory";
const ITensorHandleFactory::FactoryId ITensorHandleFactor... |
//
// Copyright © 2017 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <armnn/Deprecated.hpp>
#include <armnn/Exceptions.hpp>
#include <armnn/Types.hpp>
#include <backendsCommon/LayerSupportBase.hpp>
#include <armnn/utility/IgnoreUnused.hpp>
#include <armnn/utility/Polymor... |
//
// Copyright © 2017 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/backends/ILayerSupport.hpp>
namespace armnn
{
class LayerSupportBase : public ILayerSupport
{
public:
bool IsLayerSupported(const LayerType& type,
con... |
//
// Copyright © 2017, 2024 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <algorithm>
namespace armnn
{
inline armnn::Optional<armnn::DataType> GetBiasTypeFromWeightsType(armnn::Optional<armnn::DataType> weightsType)
{
if (!weightsType)
{
return weightsType... |
//
// Copyright © 2017, 2024 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
namespace armnn
{
namespace
{
// Make a workload of the specified WorkloadType.
template<typename WorkloadType>
struct MakeWorkloadForType
{
template<typename QueueDescriptorType, typename... Args>
stat... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <backendsCommon/MapWorkload.hpp>
namespace armnn
{
MapWorkload::MapWorkload(const MapQueueDescriptor& descriptor,
const WorkloadInfo& info)
: BaseWorkload<MapQueueDescriptor... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/backends/Workload.hpp>
namespace armnn
{
class MapWorkload : public BaseWorkload<MapQueueDescriptor>
{
public:
MapWorkload(const MapQueueDescriptor& descriptor, const WorkloadInf... |
//
// Copyright © 2022, 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <ResolveType.hpp>
#include "WorkloadUtils.hpp"
#include <armnn/backends/MemCopyWorkload.hpp>
#include <armnn/backends/TensorHandle.hpp>
#include <armnn/utility/PolymorphicDowncast.hpp>
#include ... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <ResolveType.hpp>
#include <backendsCommon/MemImportWorkload.hpp>
#include <armnn/backends/TensorHandle.hpp>
#include <cstring>
namespace armnn
{
ImportMemGenericWorkload::ImportMemGenericWorkload(const MemImportQueue... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "WorkloadUtils.hpp"
#include <armnn/backends/TensorHandleFwd.hpp>
#include <armnn/backends/Workload.hpp>
#include <utility>
namespace armnn
{
class ImportMemGenericWorkload : public BaseWorkload<MemImport... |
//
// Copyright © 2021 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "MemoryManager.hpp"
#include <armnn/utility/IgnoreUnused.hpp>
namespace armnn
{
void MemoryManager::StoreMemToAllocate(std::vector<BufferStorage> bufferStorageVector,
... |
//
// Copyright © 2021 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/backends/ICustomAllocator.hpp>
namespace armnn
{
struct Allocator
{
/// Pointer to @ICustomAllocator.
std::shared_ptr<ICustomAllocator> m_CustomAllocator{};
/// Value whic... |
//
// Copyright © 2022, 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <backendsCommon/MemSyncWorkload.hpp>
#include <armnn/backends/TensorHandle.hpp>
namespace armnn
{
SyncMemGenericWorkload::SyncMemGenericWorkload(const MemSyncQueueDescriptor& descriptor,
... |
//
// Copyright © 2022, 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "WorkloadUtils.hpp"
#include <armnn/backends/TensorHandleFwd.hpp>
#include <armnn/backends/Workload.hpp>
#include <utility>
namespace armnn
{
class SyncMemGenericWorkload : public B... |
//
// Copyright © 2017,2022 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <armnn/backends/OptimizationViews.hpp>
namespace armnn
{
bool OptimizationViews::Validate(const armnn::SubgraphView& originalSubgraph) const
{
//This needs to verify that:
// 1) the sum of ... |
//
// Copyright © 2022-2025 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/StrategyBase.hpp>
#include <armnn/Descriptors.hpp>
#include <optimizations/FoldPadIntoLayer2d.hpp>
#include <type_traits>
namespace armnn
{
namespace
{
/// Checks if a Layer h... |
//
// Copyright © 2021 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <armnn/Exceptions.hpp>
#include <armnn/utility/IgnoreUnused.hpp>
#include <armnn/backends/TensorHandle.hpp>
#include <cstring>
namespace armnn
{
TensorShape GetUnpaddedTensorStrides(const TensorInfo& t... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <backendsCommon/TensorHandleFactoryRegistry.hpp>
#include <armnn/backends/IMemoryManager.hpp>
namespace armnn
{
void TensorHandleFactoryRegistry::RegisterFactory(std::unique_ptr <ITensorHandleFactory> newFactory)
{
... |
//
// Copyright © 2017,2022 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/Types.hpp>
#include <armnn/backends/ITensorHandleFactory.hpp>
#include <map>
#include <memory>
#include <vector>
namespace armnn
{
//Forward
class IMemoryManager;
using CopyAn... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <backendsCommon/UnmapWorkload.hpp>
namespace armnn
{
UnmapWorkload::UnmapWorkload(const UnmapQueueDescriptor& descriptor,
const WorkloadInfo& info)
: BaseWorkload<UnmapQ... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/backends/Workload.hpp>
namespace armnn
{
class UnmapWorkload : public BaseWorkload<UnmapQueueDescriptor>
{
public:
UnmapWorkload(const UnmapQueueDescriptor& descriptor, const Wor... |
//
// Copyright © 2017-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <armnn/backends/TensorHandle.hpp>
#include <armnn/backends/WorkloadData.hpp>
#include <armnn/backends/WorkloadInfo.hpp>
#include <armnnUtils/DataLayoutIndexed.hpp>
#include <armnnUtils/TensorUtils.hp... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/Tensor.hpp>
#include <vector>
namespace armnn
{
class ITensorHandle;
class WorkloadDataCollector
{
public:
WorkloadDataCollector(std::vector<ITensorHandle*>& handles, std::vector<TensorInfo>& in... |
//
// Copyright © 2017-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <Layer.hpp>
#include <LayersFwd.hpp>
#include <armnn/Types.hpp>
#include <armnn/backends/IBackendInternal.hpp>
#include <armnn/backends/ILayerSupport.hpp>
#include <armnn/BackendHelper.hpp>
#include... |
//
// Copyright © 2019, 2023 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/backends/WorkloadFactory.hpp>
namespace armnn
{
class WorkloadFactoryBase : public IWorkloadFactory
{
public:
bool SupportsSubTensors() const override
{ return false; };
std::uniq... |
//
// Copyright © 2017-2024 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <backendsCommon/WorkloadUtils.hpp>
#include <armnn/Utils.hpp>
#include <armnn/utility/NumericCast.hpp>
#include <armnnUtils/DataLayoutIndexed.hpp>
#include <armnnUtils/TensorUtils.hpp>
#include <fmt/format.h>
#incl... |
//
// Copyright © 2017-2024 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/backends/ITensorHandle.hpp>
#include <armnn/backends/TensorHandle.hpp>
#include <armnn/Tensor.hpp>
#include <armnn/utility/PolymorphicDowncast.hpp>
#include <armnnUtils/Permute.hpp>
#include <Ha... |
//
// Copyright © 2021 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/backends/IMemoryOptimizerStrategy.hpp>
#include <algorithm>
namespace armnn
{
struct IMemoryOptimizerStrategyFactory
{
virtual ~IMemoryOptimizerStrategyFactory() = default;
... |
//
// Copyright © 2021 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/backends/IMemoryOptimizerStrategy.hpp>
#include "MemoryOptimizerStrategyFactory.hpp"
#include "strategies/ConstantMemoryStrategy.hpp"
#include "strategies/StrategyValidator.hpp"
#incl... |
//
// Copyright © 2021 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "ConstantMemoryStrategy.hpp"
namespace armnn
{
std::string ConstantMemoryStrategy::GetName() const
{
return m_Name;
}
MemBlockStrategyType ConstantMemoryStrategy::GetMemBlockStrategyType() const
{
... |
//
// Copyright © 2021 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/Types.hpp>
#include <armnn/backends/IMemoryOptimizerStrategy.hpp>
namespace armnn
{
// ConstLayerMemoryOptimizer: Create a unique MemBin for each MemBlock and assign it an offset of 0... |
//
// Copyright © 2021 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "SingleAxisPriorityList.hpp"
#include <algorithm>
#include <cstdlib>
#include <iostream>
namespace armnn
{
// This strategy uses a vector of size_ts/words to represent occupancy of a memBlock in a mem... |
//
// Copyright © 2021 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/Types.hpp>
#include <armnn/backends/IMemoryOptimizerStrategy.hpp>
#include <tuple>
#include <utility>
#include <algorithm>
#include <list>
namespace armnn
{
/// SingleAxisPriori... |
//
// Copyright © 2021 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <unordered_map>
#include <iostream>
#include "StrategyValidator.hpp"
namespace armnn
{
std::vector<MemBin> StrategyValidator::Optimize(std::vector<MemBlock>& memBlocks)
{
// Condition #1: All Memblo... |
//
// Copyright © 2021 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/Types.hpp>
#include <armnn/Exceptions.hpp>
#include <armnn/backends/IMemoryOptimizerStrategy.hpp>
namespace armnn
{
class StrategyValidator : public IMemoryOptimizerStrategy
{
public... |
//
// Copyright © 2021 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <backendsCommon/memoryOptimizerStrategyLibrary/strategies/ConstantMemoryStrategy.hpp>
#include <backendsCommon/memoryOptimizerStrategyLibrary/strategies/StrategyValidator.hpp>
#include <doctest/doctest.h... |
//
// Copyright © 2021 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <backendsCommon/memoryOptimizerStrategyLibrary/MemoryOptimizerStrategyLibrary.hpp>
#include <doctest/doctest.h>
using namespace armnn;
TEST_SUITE("StrategyLibraryTestSuite")
{
TEST_CASE("StrategyLibra... |
//
// Copyright © 2021 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <backendsCommon/memoryOptimizerStrategyLibrary/strategies/SingleAxisPriorityList.hpp>
#include <backendsCommon/memoryOptimizerStrategyLibrary/strategies/StrategyValidator.hpp>
#include "TestMemBlocks.hpp"... |
//
// Copyright © 2021 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
size_t GetMinPossibleMemorySize(const std::vector<armnn::MemBlock>& blocks)
{
unsigned int maxLifetime = 0;
for (auto& block: blocks)
{
maxLifetime = std::max(maxLifetime, block.m_EndOfLife);
... |
//
// Copyright © 2021 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <backendsCommon/memoryOptimizerStrategyLibrary/strategies/StrategyValidator.hpp>
#include <doctest/doctest.h>
#include <vector>
using namespace armnn;
TEST_SUITE("MemoryOptimizerStrategyValidatorTestSu... |
//
// Copyright © 2020-2021,2023-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "EndToEndTestImpl.hpp"
#include <armnn/INetwork.hpp>
#include <armnn/TypesUtils.hpp>
#include <CommonTestUtils.hpp>
#include <ResolveType.hpp>
namespace
{
/** Defines the ... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnnTestUtils/TensorCopyUtils.hpp>
#include <armnnTestUtils/WorkloadTestUtils.hpp>
#include <armnn/utility/NumericCast.hpp>
#include <armnnTestUtils/TensorHelpers.hpp>
struct ActivationFixture
{
Acti... |
//
// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/INetwork.hpp>
#include <CommonTestUtils.hpp>
#include <ResolveType.hpp>
#include <doctest/doctest.h>
namespace
{
template<typename armnn::DataType DataType>
armnn::INetworkPtr Crea... |
//
// Copyright © 2019 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <CommonTestUtils.hpp>
#include <armnnUtils/QuantizeHelper.hpp>
#include <ResolveType.hpp>
namespace
{
armnn::INetworkPtr CreateArgMinMaxNetwork(const armnn::TensorInfo& inputTensorInfo,
... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <armnn/BackendId.hpp>
#include <armnn/Types.hpp>
#include <doctest/doctest.h>
using namespace armnn;
TEST_SUITE("BackendIdTests")
{
TEST_CASE("CreateBackendIdFromCompute")
{
BackendId fromCompute{Compute::GpuAcc};
... |
//
// Copyright © 2020, 2023-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "ArmNNProfilingServiceInitialiser.hpp"
#include "MockBackendId.hpp"
#include "ProfilingOptionsConverter.hpp"
#include <TestUtils.hpp>
#include <armnn/BackendId.hpp>
#include <armnn/Logging.hp... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <armnn/Types.hpp>
#include <armnn/BackendRegistry.hpp>
#include <armnn/backends/IBackendInternal.hpp>
#include <backendsCommon/memoryOptimizerStrategyLibrary/strategies/ConstantMemoryStrategy.hpp>
#include <reference/Ref... |
//
// Copyright © 2022-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <ResolveType.hpp>
#include <armnn/INetwork.hpp>
#include <doctest/doctest.h>
#include <CommonTestUtils.hpp>
namespace
{
template<typename armnn::DataType DataType>
armnn::INetworkPtr... |
//
// Copyright © 2025 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/INetwork.hpp>
#include <armnn/Descriptors.hpp>
#include <CommonTestUtils.hpp>
#include <ResolveType.hpp>
#include <optional>
// helper function that computes the SpaceToBatch Output ... |
//
// Copyright © 2017,2019-2021,2023 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <ResolveType.hpp>
#include <armnn/INetwork.hpp>
#include <CommonTestUtils.hpp>
#include <doctest/doctest.h>
#include <vector>
namespace
{
template<typename armnn::DataTyp... |
//
// Copyright © 2023 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "armnn/INetwork.hpp"
#include "armnnUtils/QuantizeHelper.hpp"
#include "ElementwiseBinaryEndToEndTestImpl.hpp"
#include "Optimizer.hpp"
#include <CommonTestUtils.hpp>
#include <ResolveType.hpp... |
//
// Copyright © 2021,2023 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <CommonTestUtils.hpp>
#include <armnn/INetwork.hpp>
#include <ResolveType.hpp>
#include <doctest/doctest.h>
namespace{
armnn::INetworkPtr CreateChannelShuffleNetwork(const armnn::Te... |
//
// Copyright © 2019-2021,2023 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <CommonTestUtils.hpp>
#include <ResolveType.hpp>
#include <armnn/INetwork.hpp>
#include <armnn/utility/NumericCast.hpp>
#include <doctest/doctest.h>
#include <vector>
namespac... |
//
// Copyright © 2017,2019-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#if defined(ARMCOMPUTECL_ENABLED)
#include <cl/ClBackend.hpp>
#endif
#if defined(ARMCOMPUTENEON_ENABLED)
#include <neon/NeonBackend.hpp>
#endif
#include <reference/RefBackend.hpp>
#include <armnn/Backend... |
//
// Copyright © 2017, 2022, 2024 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <CommonTestUtils.hpp>
#include <ResolveType.hpp>
#include <armnn/INetwork.hpp>
#include <armnn/utility/NumericCast.hpp>
#include <doctest/doctest.h>
#include <vector>
namespace
{
template<t... |
//
// Copyright © 2022, 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "EndToEndTestImpl.hpp"
#include <armnnUtils/QuantizeHelper.hpp>
#include <ResolveType.hpp>
#include <CommonTestUtils.hpp>
#include <armnnTestUtils/DataLayoutUtils.hpp>
#include <map>... |
//
// Copyright © 2021, 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "EndToEndTestImpl.hpp"
#include <armnnUtils/QuantizeHelper.hpp>
#include <armnnTestUtils/DataLayoutUtils.hpp>
#include <CommonTestUtils.hpp>
#include <ResolveType.hpp>
#include <map>
... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.