text stringlengths 1 24.5M |
|---|
//
// Copyright © 2022-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "TestUtils.hpp"
#include <armnn_delegate.hpp>
#include <DelegateTestInterpreter.hpp>
#include <tensorflow/lite/version.h>
namespace
{
std::vector<char> CreateStridedSliceTfLiteModel... |
//
// Copyright © 2020, 2023 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "TestUtils.hpp"
namespace armnnDelegate
{
void CompareData(bool tensor1[], bool tensor2[], size_t tensorSize)
{
auto compareBool = [](auto a, auto b) {return (((a == 0) && (b == 0)) || ((a != ... |
//
// Copyright © 2020, 2023-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <tensorflow/lite/c/common.h>
#include <armnn/BackendId.hpp>
#include <half/half.hpp>
#include <doctest/doctest.h>
using Half = half_float::half;
namespace
{
/**
* Based on th... |
//
// Copyright © 2023-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "TileTestHelper.hpp"
#include <doctest/doctest.h>
namespace armnnDelegate
{
void TileFloat32Test()
{
// Set input data
std::vector<float> inputValues =
{
0.f, 1.f, 2.f,
... |
//
// Copyright © 2023-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "TestUtils.hpp"
#include <armnn_delegate.hpp>
#include <DelegateTestInterpreter.hpp>
#include <tensorflow/lite/version.h>
namespace
{
std::vector<char> CreateTileTfLiteModel(tflite::... |
//
// Copyright © 2023-2025 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "ConvolutionTestHelper.hpp"
#include <DelegateTestInterpreter.hpp>
#include <doctest/doctest.h>
#include <tensorflow/lite/schema/schema_generated.h>
namespace armnnDelegate
{
void TransposeConvInt8... |
//
// Copyright © 2020, 2023-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "TransposeTestHelper.hpp"
#include <doctest/doctest.h>
namespace armnnDelegate
{
void TransposeFP32Test()
{
// set test input data
std::vector<int32_t> input0Shape {4, 2, 3};
std... |
//
// Copyright © 2020, 2023-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "TestUtils.hpp"
#include <armnn_delegate.hpp>
#include <DelegateTestInterpreter.hpp>
#include <tensorflow/lite/version.h>
namespace
{
std::vector<char> CreateTransposeTfLiteMod... |
//
// Copyright © 2021, 2023-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "UnidirectionalSequenceLstmTestHelper.hpp"
#include <doctest/doctest.h>
namespace armnnDelegate
{
void UnidirectionalSequenceLstmTest(const std::vector<armnn::BackendId>& backends = {})
{
... |
//
// Copyright © 2021, 2023-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "TestUtils.hpp"
#include <armnn_delegate.hpp>
#include <DelegateTestInterpreter.hpp>
#include <tensorflow/lite/version.h>
#include <armnn/utility/NumericCast.hpp>
#include <arm... |
//
// Copyright © 2021, 2023-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "UnpackTestHelper.hpp"
#include <doctest/doctest.h>
namespace armnnDelegate
{
template <typename T>
void UnpackAxis0Num4Test(tflite::TensorType tensorType)
{
std::vector<int32_t> inputSh... |
//
// Copyright © 2021, 2023-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "TestUtils.hpp"
#include <armnn_delegate.hpp>
#include <DelegateTestInterpreter.hpp>
#include <tensorflow/lite/version.h>
namespace
{
std::vector<char> CreateUnpackTfLiteModel... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "BackendId.hpp"
#include "BackendHelper.hpp"
#include "Descriptors.hpp"
#include "Exceptions.hpp"
#include "INetwork.hpp"
#include "IRuntime.hpp"
#include "LstmParams.hpp"
#include "Optional.hpp"
#include "Qu... |
//
// Copyright © 2017-2019,2021-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/BackendId.hpp>
#include <armnn/BackendOptions.hpp>
#include <armnn/Descriptors.hpp>
#include <armnn/Optional.hpp>
#include <functional>
#include <memory>
#include <stri... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <memory>
#include <ostream>
#include <set>
#include <string>
#include <unordered_set>
#include <vector>
namespace armnn
{
///
/// The Compute enum is now deprecated and it is now
/// being replaced by Backe... |
//
// Copyright © 2019 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "BackendId.hpp"
#include <armnn/Exceptions.hpp>
#include <cassert>
namespace armnn
{
struct BackendOptions;
using NetworkOptions = std::vector<BackendOptions>;
using ModelOptions = std::vector<BackendOpti... |
//
// Copyright © 2017, 2022, 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/BackendId.hpp>
#include <armnn/Optional.hpp>
#include <memory>
#include <unordered_map>
#include <functional>
#include <stddef.h>
#include <string>
namespace arm
{
namespa... |
//
// Copyright © 2019 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#if __GNUC__
# define ARMNN_NO_CONVERSION_WARN_BEGIN \
_Pragma("GCC diagnostic push") \
_Pragma("GCC diagnostic ignored \"-Wconversion\"") \
_Pragma("GCC diagnostic ignored \"-Wsign-co... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#if __GNUC__
# define ARMNN_NO_DEPRECATE_WARN_BEGIN \
_Pragma("GCC diagnostic push") \
_Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
# define ARMNN_NO_DEPRECATE_WARN_END \
_Pragma(... |
//
// Copyright © 2017-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "Deprecated.hpp"
#include "DescriptorsFwd.hpp" // Required for class equivalence declarations.
#include "Tensor.hpp"
#include "Types.hpp"
#include <armnn/Exceptions.hpp>
#include <cstdi... |
//
// Copyright © 2017-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
namespace armnn
{
struct BaseDescriptor;
struct ActivationDescriptor;
struct ArgMinMaxDescriptor;
struct BatchMatMulDescriptor;
struct BatchNormalizationDescriptor;
struct BatchToSpaceNdDescrip... |
//
// Copyright © 2017-2023 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <sstream>
#include <stdexcept>
#include <string>
namespace armnn
{
struct CheckLocation
{
const char* m_Function;
const char* m_File;
unsigned int m_Line;
CheckLocation(const char* fun... |
//
// Copyright © 2017-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/BackendOptions.hpp>
#include <armnn/Deprecated.hpp>
#include <armnn/DescriptorsFwd.hpp>
#include <armnn/IStrategy.hpp>
#include <armnn/NetworkFwd.hpp>
#include <armnn/Optional.hpp... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <iostream>
#include <memory>
#include <vector>
namespace armnn
{
class ProfilerImpl;
class BackendId;
class Instrument;
class Event;
struct WorkloadInfo;
class IProfiler
{
public:
/// Enables/disables... |
//
// Copyright © 2017-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "BackendOptions.hpp"
#include "INetwork.hpp"
#include "IProfiler.hpp"
#include "Tensor.hpp"
#include "Types.hpp"
#include "TypesUtils.hpp"
#include <armnn/backends/ICustomAllocator.hpp>... |
//
// Copyright © 2021 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/DescriptorsFwd.hpp>
#include <armnn/Types.hpp>
#include <armnn/NetworkFwd.hpp>
#include <armnn/TensorFwd.hpp>
namespace armnn
{
class IStrategy
{
protected:
IStrategy() {}
virtual ~... |
//
// Copyright © 2019,2022 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/Utils.hpp>
#include <ctype.h>
#include <iostream>
#include <algorithm>
#include <memory>
#include <string>
#include <utility>
#include <vector>
#include <armnn/Exceptions.hpp>
... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "TensorFwd.hpp"
#include "Exceptions.hpp"
namespace armnn
{
struct LstmInputParams
{
LstmInputParams()
: m_InputToInputWeights(nullptr)
, m_InputToForgetWeights(nullptr)
, m_Inpu... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/Types.hpp>
#include <type_traits>
namespace armnn
{
using MemorySourceFlags = unsigned int;
template<typename T>
struct IsMemorySource
{
static const bool value = false;
};
template<>
struct ... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
namespace armnn
{
struct LstmInputParams;
struct QuantizedLstmInputParams;
class INetwork;
class IOptimizedNetwork;
class Graph;
class IInputSlot;
class IOutputSlot;
class IConnectableLayer;
class IDataLayer;
} // ... |
//
// Copyright © 2024-2025 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
// Copyright © 2021 Leon Merten Lohse
// SPDX-License-Identifier: MIT
//
#ifndef NUMPY_HPP
#define NUMPY_HPP
#include <fmt/format.h>
#include "Types.hpp"
#include "Tensor.hpp"
#include <fstream>
#include <... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "Exceptions.hpp"
#include <cstring>
#include <type_traits>
/// Optional is a drop in replacement for std::optional until we migrate
/// to c++-17. Only a subset of the optional features are implemented that... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "TensorFwd.hpp"
#include "Exceptions.hpp"
namespace armnn
{
struct QuantizedLstmInputParams
{
QuantizedLstmInputParams()
: m_InputToInputWeights(nullptr)
, m_InputToForgetWeights(nullptr... |
//
// Copyright © 2021 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/INetwork.hpp>
#include <armnn/IStrategy.hpp>
#include <armnn/utility/IgnoreUnused.hpp>
namespace armnn
{
struct ThrowingStrategy
{
void Apply(const std::string& errorMessage = "... |
//
// Copyright © 2017,2022-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "Exceptions.hpp"
#include "Optional.hpp"
#include "Types.hpp"
#include <stdint.h>
#include <array>
#include <initializer_list>
#include <vector>
#include <utility>
namespace armnn... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
namespace armnn
{
class TensorShape;
class TensorInfo;
class Tensor;
class ConstTensor;
}
|
//
// Copyright © 2018-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <array>
#include <functional>
#include <stdint.h>
#include <chrono>
#include "BackendId.hpp"
#include "Exceptions.hpp"
#include "Deprecated.hpp"
namespace arm
{
namespace pipe
{
class ... |
//
// Copyright © 2018-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/BackendId.hpp>
#include <armnn/Exceptions.hpp>
#include <armnn/Tensor.hpp>
#include <armnn/Types.hpp>
#include <stdint.h>
#include <cmath>
#include <ostream>
#include <set>
#incl... |
//
// Copyright © 2017,2022 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <string>
#include <cmath>
namespace armnn
{
enum class LogSeverity
{
Trace,
Debug,
Info,
Warning,
Error,
Fatal
};
/// Configures the logging behaviour of the A... |
//
// Copyright © 2017-2025 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
/// Macro utils
#define STRINGIFY_VALUE(s) STRINGIFY_MACRO(s)
#define STRINGIFY_MACRO(s) #s
// ArmNN version components
#define ARMNN_MAJOR_VERSION 35
#define ARMNN_MINOR_VERSION 0
#define ARMN... |
//
// Copyright © 2017,2022 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "IBackendInternal.hpp"
#include <armnn/BackendRegistry.hpp>
#include <armnn/BackendId.hpp>
#include <stdint.h>
#include <functional>
#include <memory>
#include <string>
namespace armn... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/BackendOptions.hpp>
#include <armnn/IRuntime.hpp>
#include <memory>
namespace armnn
{
class IBackendContext
{
protected:
IBackendContext(const IRuntime::CreationOptions&) {}
public:
/// Befo... |
//
// Copyright © 2022, 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/Types.hpp>
#include <armnn/IRuntime.hpp>
#include <armnn/Deprecated.hpp>
#include <ISubgraphViewConverter.hpp>
#include <armnn/backends/IBackendContext.hpp>
#include <armnn/ba... |
//
// 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
{
/** Custom Allocator interface */
class ICustomAllocator
{
public:... |
//
// Copyright © 2017 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/Deprecated.hpp>
#include <armnn/Descriptors.hpp>
#include <armnn/LstmParams.hpp>
#include <armnn/Optional.hpp>
#include <armnn/QuantizedLstmParams.hpp>
#include <cctype>
#include <fun... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <memory>
namespace armnn
{
class IMemoryManager
{
protected:
IMemoryManager() {}
public:
virtual void Acquire() = 0;
virtual void Release() = 0;
virtual ~IMemoryManager() {}
};
using IMem... |
//
// Copyright © 2021 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/Types.hpp>
namespace armnn
{
// A MemBlock represents a memory usage requirement in time and space and can be seen as essentially a rectangle
struct MemBlock
{
MemBlock(const uns... |
//
// Copyright © 2017-2023 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/MemorySources.hpp>
#include <armnn/utility/IgnoreUnused.hpp>
#include <armnn/Tensor.hpp>
namespace armnn
{
class TensorShape;
class ITensorHandle
{
public:
virtual ~ITensor... |
//
// Copyright © 2017, 2019-2022 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "ITensorHandle.hpp"
#include <armnn/MemorySources.hpp>
#include <armnn/Tensor.hpp>
#include <armnn/Types.hpp>
#include <armnn/utility/IgnoreUnused.hpp>
#include <memory>
#include... |
//
// Copyright © 2020-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/Types.hpp>
#include <armnn/backends/WorkloadInfo.hpp>
namespace armnn
{
/// Workload interface to enqueue a layer computation.
class IWorkload {
public:
virtual ~IWorkload()... |
//
// Copyright © 2022, 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "TensorHandle.hpp"
#include "Workload.hpp"
#include <utility>
namespace armnn
{
class CopyMemGenericWorkload : public BaseWorkload<MemCopyQueueDescriptor>
{
public:
CopyMemGeneri... |
//
// Copyright © 2017, 2019, 2021-2023 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/BackendOptions.hpp>
#include <armnn/Deprecated.hpp>
#include <armnn/INetwork.hpp>
#include <armnn/backends/SubgraphView.hpp>
#include <vector>
namespace armnn
{
cla... |
//
// Copyright © 2017, 2022-2023 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/Deprecated.hpp>
#include <vector>
#include <list>
#include <iterator>
#include <memory>
namespace armnn
{
class Graph;
class IConnectableLayer;
class IInputSlot;
class IO... |
//
// Copyright © 2021 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "ITensorHandle.hpp"
#include <armnn/TypesUtils.hpp>
#include <armnn/utility/Assert.hpp>
#include <armnnUtils/CompatibleTypes.hpp>
#include <algorithm>
namespace armnn
{
// Get a TensorSh... |
//
// Copyright © 2021 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
namespace armnn
{
class ConstTensorHandle;
class TensorHandle;
class ScopedTensorHandle;
class PassthroughTensorHandle;
class ConstPassthroughTensorHandle;
} // namespace armnn
|
//
// Copyright © 2021-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "IWorkload.hpp"
#include "WorkloadData.hpp"
#include "WorkloadInfo.hpp"
#include <armnn/Logging.hpp>
#include <Profiling.hpp>
#include <client/include/IProfilingService.hpp>
#include... |
//
// Copyright © 2021-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "TensorHandle.hpp"
#include <armnn/Deprecated.hpp>
#include <armnn/Descriptors.hpp>
#include <armnn/Exceptions.hpp>
#include <armnn/Types.hpp>
#include <armnn/Tensor.hpp>
#include <comm... |
//
// Copyright © 2021-2023 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "ITensorHandle.hpp"
#include "Workload.hpp"
#include <armnn/Optional.hpp>
#include <armnn/INetwork.hpp>
#include <armnn/TensorFwd.hpp>
#include <memory>
namespace armnn
{
class Layer... |
//
// Copyright © 2020-2023 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/Tensor.hpp>
#include <vector>
namespace armnn
{
/// Contains information about TensorInfos of a layer.
/// This is needed at construction of workloads, but are not stored.
stru... |
//
// Copyright © 2022, 2025 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/Version.hpp>
#include <cstdint>
namespace arm
{
namespace pipe
{
// Static constants describing ArmNN's counter UID's
static const uint16_t NETWORK_LOADS = 0;
static ... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <cassert>
namespace armnn
{
#ifndef NDEBUG
# define ARMNN_ASSERT(COND) assert(COND)
# define ARMNN_ASSERT_MSG(COND, MSG) assert((COND) && MSG)
#else
# define ARMNN_ASSERT(COND)
# d... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
namespace armnn
{
// Utility function to selectively silence unused variable compiler warnings
template<typename ... Ts>
inline void IgnoreUnused(Ts&&...){}
} //namespace armnn |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "Assert.hpp"
#include <type_traits>
#include <limits>
namespace armnn
{
#if !defined(NDEBUG) || defined(ARMNN_NUMERIC_CAST_TESTABLE)
#define ENABLE_NUMERIC_CAST_CHECKS 1
#else
#define ENA... |
//
// Copyright © 2020 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "Assert.hpp"
#include <armnn/Exceptions.hpp>
#include <memory>
#include <type_traits>
namespace armnn
{
// If we are testing then throw an exception, otherwise regular assert
#if defined(ARMNN_POLYMORPHI... |
//
// Copyright © 2020 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <iostream>
#include <sstream>
#include <algorithm>
#include <vector>
#include <armnn/Exceptions.hpp>
namespace armnn
{
namespace stringUtils
{
/// Function to take a string and a list of delimiters and sp... |
//
// Copyright © 2020 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <chrono>
#include <iomanip>
namespace armnn
{
inline std::chrono::high_resolution_clock::time_point GetTimeNow()
{
return std::chrono::high_resolution_clock::now();
}
inline std::chrono::duration<doub... |
//
// Copyright © 2020,2023 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <iterator>
namespace armnn
{
template<typename Function,
typename Iterator,
typename Category = typename std::iterator_traits<Iterator>::iterator_category,
typen... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "armnn/Types.hpp"
#include "armnn/NetworkFwd.hpp"
#include "armnn/Tensor.hpp"
#include "armnn/INetwork.hpp"
#include <memory>
#include <map>
#include <vector>
namespace armnnDeserializer
{
struct BindingPoi... |
//
// Copyright © 2017,2022,2024 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/INetwork.hpp>
#include <armnn/Tensor.hpp>
#include <memory>
#include <vector>
#include <map>
namespace armnnOnnxParser
{
using BindingPointInfo = armnn::BindingPointInfo;
class OnnxParser... |
//
// Copyright © 2021 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
namespace armnnOnnxParser
{
/// Macro utils
#define STRINGIFY_VALUE(s) STRINGIFY_MACRO(s)
#define STRINGIFY_MACRO(s) #s
// OnnxParser version components
#define ONNX_PARSER_MAJOR_VERSION 24
#define... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "armnn/INetwork.hpp"
#include "armnn/NetworkFwd.hpp"
#include "armnn/Types.hpp"
namespace armnnSerializer
{
class ISerializer;
using ISerializerPtr = std::unique_ptr<ISerializer, void(*)(ISerializer* serial... |
//
// Copyright © 2019 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/Tensor.hpp>
#include <armnn/Types.hpp>
#include <armnnUtils/Permute.hpp>
template<typename T>
void PermuteTensorNchwToNhwc(armnn::TensorInfo& tensorInfo, std::vector<T>& tensorData)... |
//
// Copyright © 2017 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/Tensor.hpp>
#include <armnn/utility/Assert.hpp>
#include <cstddef>
#include <vector>
template <typename T, std::size_t n>
struct LayerTestResult
{
LayerTestResult(const armnn::T... |
//
// Copyright © 2017 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "LayerTestResult.hpp"
#include "TensorCopyUtils.hpp"
#include "TensorHelpers.hpp"
#include "WorkloadTestUtils.hpp"
#include <ResolveType.hpp>
#include <armnn/backends/IBackendInternal.hpp>
#i... |
//
// Copyright © 2022-2023 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/Deprecated.hpp>
#include <armnn/Descriptors.hpp>
#include <armnn/Exceptions.hpp>
#include <armnn/IRuntime.hpp>
#include <armnn/Optional.hpp>
#include <armnn/Tensor.hpp>
#include <... |
//
// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/backends/IMemoryManager.hpp>
#include <forward_list>
#include <vector>
namespace armnn
{
// An implementation of IMemoryManager to be used with MockTensorHandle
class MockMemoryMana... |
//
// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "MockMemoryManager.hpp"
#include <armnn/backends/TensorHandle.hpp>
#include <armnn/MemorySources.hpp>
#include <armnn/Tensor.hpp>
#include <armnn/Types.hpp>
#include <armnn/backends/ITensorH... |
//
// Copyright © 2021 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <sstream>
namespace armnn
{
class PredicateResult
{
public:
explicit PredicateResult(bool result)
: m_Result(result)
{}
PredicateResult(const PredicateResult& predicate... |
//
// Copyright © 2017,2022 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
namespace armnn
{
class ITensorHandle;
} // namespace armnn
void CopyDataToITensorHandle(armnn::ITensorHandle* tensorHandle, const void* memory);
void CopyDataFromITensorHandle(void* mem, cons... |
//
// Copyright © 2017, 2021-2023 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnnTestUtils/PredicateResult.hpp>
#include <armnn/Tensor.hpp>
#include <armnn/utility/Assert.hpp>
#include <armnnUtils/FloatingPointComparison.hpp>
#include <armnnUtils/Quanti... |
//
// Copyright © 2022-2023 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
/// Macro utils
#define STRINGIFY_VALUE(s) STRINGIFY_MACRO(s)
#define STRINGIFY_MACRO(s) #s
// ArmnnTestUtils version components
#define ARMNN_TEST_UTILS_MAJOR_VERSION 3
#define ARMNN_TEST_UTIL... |
//
// Copyright © 2017 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/Tensor.hpp>
#include <armnn/backends/IBackendInternal.hpp>
#include <armnn/backends/IMemoryManager.hpp>
#include <armnn/backends/Workload.hpp>
#include <armnn/backends/WorkloadInfo.hp... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "armnn/Types.hpp"
#include "armnn/NetworkFwd.hpp"
#include "armnn/Tensor.hpp"
#include "armnn/INetwork.hpp"
#include "armnn/Optional.hpp"
#include <memory>
#include <map>
#include <vector>
namespace armnnTf... |
//
// Copyright © 2021-2025 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
namespace armnnTfLiteParser
{
/// Macro utils
#define STRINGIFY_VALUE(s) STRINGIFY_MACRO(s)
#define STRINGIFY_MACRO(s) #s
// TfLiteParser version components
#define TFLITE_PARSER_MAJOR_VERSION... |
//
// Copyright © 2021 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/Types.hpp>
namespace armnnUtils
{
template<typename T>
bool CompatibleTypes(armnn::DataType);
} //namespace armnnUtils
|
//
// Copyright © 2018-2021,2023 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/Types.hpp>
#include <armnn/Tensor.hpp>
#include <armnn/utility/Assert.hpp>
namespace armnnUtils
{
/// Provides access to the appropriate indexes for Channels, Height and Width based on Da... |
//
// Copyright © 2020,2022 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#if !defined(ARMNN_DISABLE_FILESYSTEM)
#if defined(_MSC_VER)
// ghc includes Windows.h directly, bringing in macros that we don't want (e.g. min/max).
// By including Windows.h ourselves first (... |
//
// Copyright © 2020 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <cmath>
namespace armnnUtils
{
/**
* Compare two floats and return true if their values are within a specified tolerance of each other.
* @param a
* @param b
* @param tolerancePercentage If not supplie... |
//
// Copyright © 2019 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <cstddef>
namespace armnnUtils
{
class FloatingPointConverter
{
public:
/// Converts a buffer of FP32 values to FP16, and stores in the given dstFloat16Buffer.
/// dstFloat16Buffer should be (numEl... |
//
// Copyright © 2019,2022 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/TensorFwd.hpp>
#include <armnn/Types.hpp>
#include <stddef.h>
namespace armnnUtils
{
armnn::TensorShape Permuted(const armnn::TensorShape& srcShape,
... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/utility/IgnoreUnused.hpp>
#include <armnn/utility/NumericCast.hpp>
#include <armnn/TypesUtils.hpp>
#include <BFloat16.hpp>
#include <Half.hpp>
#include <initializer_list>
#include <iterator>
#includ... |
//
// Copyright © 2020 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/TypesUtils.hpp>
#include <mapbox/variant.hpp>
namespace armnnUtils
{
// Standard definition of TContainer used by ArmNN, use this definition or add alternative definitions here instead of
// defini... |
//
// Copyright © 2018-2023 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/TypesUtils.hpp>
#include <armnn/Tensor.hpp>
#include <armnn/Types.hpp>
#include <armnnUtils/TensorUtils.hpp>
#include <utility>
#include <vector>
namespace armnn
{
class ITensor... |
//
// Copyright © 2020,2022 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/TensorFwd.hpp>
#include <armnn/Types.hpp>
#include <stddef.h>
namespace armnnUtils
{
armnn::TensorShape TransposeTensorShape(const armnn::TensorShape& srcShape, const armnn::Pe... |
//
// Copyright © 2020,2023 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <cstdint>
#include <map>
#include <string>
namespace arm
{
namespace pipe
{
class ICounterMappings
{
public:
virtual uint16_t GetGlobalId(uint16_t backendCounterId, const std::stri... |
//
// Copyright © 2022 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <cstdint>
namespace arm
{
namespace pipe
{
struct CounterStatus
{
CounterStatus(uint16_t backendCounterId,
uint16_t globalCounterId,
bool enabled,
... |
//
// Copyright © 2022 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
namespace arm
{
namespace pipe
{
struct CounterValue
{
CounterValue(uint16_t id, uint32_t value) :
counterId(id), counterValue(value) {}
uint16_t counterId;
uint32_t counterValue;
};
} // na... |
//
// Copyright © 2017, 2023 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <mutex>
#include <vector>
#include <set>
#include <string>
namespace arm
{
namespace pipe
{
class CaptureData
{
public:
CaptureData()
: m_CapturePeriod(0)
, m_Co... |
//
// Copyright © 2019 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <cstdint>
namespace arm
{
namespace pipe
{
class IReadCounterValues
{
public:
virtual ~IReadCounterValues() {}
virtual bool IsCounterRegistered(uint16_t counterUid) const = 0;
virtual bool Is... |
//
// Copyright © 2022 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
namespace arm
{
namespace pipe
{
// forward declaration
class IProfilingService;
class IInitialiseProfilingService
{
public:
virtual ~IInitialiseProfilingService() {}
virtual void InitialiseProfilingServic... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.