text stringlengths 1 24.5M |
|---|
//
// Copyright © 2023 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "TosaOperatorUtils.hpp"
using namespace armnn;
using namespace tosa;
TosaSerializationBasicBlock* ConvertRsqrtOperator(const Layer* layer,
... |
//
// Copyright © 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
//
// Copyright © 2020 The TensorFlow Authors. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
//
#include "SigmoidOperator.hpp"
#include "TosaTableUtils.hpp"
// This function is paraphrased from:
//... |
//
// Copyright © 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "TosaOperatorUtils.hpp"
using namespace armnn;
using namespace tosa;
TosaSerializationBasicBlock* ConvertSigmoidToTosaOperator(const Layer* layer,
... |
//
// Copyright © 2022-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "SliceOperator.hpp"
TosaSerializationBasicBlock* ConvertSliceToTosaOperator(const Layer* layer,
const std::vector<const TensorInfo*>& inputs,
... |
//
// Copyright © 2022-2023 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "TosaOperatorUtils.hpp"
using namespace armnn;
using namespace tosa;
TosaSerializationBasicBlock* ConvertSliceToTosaOperator(const Layer* layer,
... |
//
// Copyright © 2025 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
//
// Copyright © 2020 The TensorFlow Authors. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
//
#include "SoftmaxOperator.hpp"
#include "TosaRescaleOperatorUtils.hpp"
#include "TosaSoftmaxOperatorU... |
//
// Copyright © 2023 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "TosaOperatorUtils.hpp"
using namespace armnn;
using namespace tosa;
TosaSerializationBasicBlock* ConvertSoftmaxToTosaOperator(const Layer* layer,
... |
//
// Copyright © 2025 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
//
// Copyright © 2020 The TensorFlow Authors. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
//
#include "SpaceToBatchOperator.hpp"
TosaSerializationBasicBlock* ConvertSpaceToBatchToTosaOperator(co... |
//
// Copyright © 2025 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "TosaOperatorUtils.hpp"
using namespace armnn;
using namespace tosa;
TosaSerializationBasicBlock* ConvertSpaceToBatchToTosaOperator(const Layer* layer,
... |
//
// Copyright © 2023-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
// Copyright © 2020 The TensorFlow Authors. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
//
#include "SplitOperator.hpp"
#include <backendsCommon/WorkloadUtils.hpp>
// This function is paraph... |
//
// Copyright © 2023 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "TosaOperatorUtils.hpp"
using namespace armnn;
using namespace tosa;
TosaSerializationBasicBlock* ConvertSplitToTosaOperator(const Layer* layer,
... |
//
// Copyright © 2024 2025 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
//
// Copyright © 2020 The TensorFlow Authors. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
//
#include "StackOperator.hpp"
// This function is paraphrased from:
// tensorflow/compiler/mlir/t... |
//
// Copyright © 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "TosaOperatorUtils.hpp"
using namespace armnn;
using namespace tosa;
TosaSerializationBasicBlock* ConvertStackToTosaOperator(const Layer* layer,
... |
//
// Copyright © 2024-2025 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "SliceOperator.hpp"
// This function is paraphrased from:
// tensorflow/compiler/mlir/tosa/transforms/legalize_common.cc
TosaSerializationBasicBlock* ConvertStridedSliceToTosaOperator(const Layer* ... |
//
// Copyright © 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "TosaOperatorUtils.hpp"
using namespace armnn;
using namespace tosa;
TosaSerializationBasicBlock* ConvertStridedSliceToTosaOperator(const Layer* layer,
... |
//
// Copyright © 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
//
// Copyright © 2020 The TensorFlow Authors. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
//
#include "TanhOperator.hpp"
#include "TosaTableUtils.hpp"
// This function is paraphrased from:
// te... |
//
// Copyright © 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "TosaOperatorUtils.hpp"
using namespace armnn;
using namespace tosa;
TosaSerializationBasicBlock* ConvertTanHToTosaOperator(const Layer* layer,
... |
//
// Copyright © 2022-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "ReluOperator.hpp"
#include "GeluOperator.hpp"
#include "LeakyReluOperator.hpp"
#include "AvgPool2DIgnoreValueOperator.hpp"
#include "BatchMatMulOperator.hpp"
#include "ConcatOperator.h... |
//
// Copyright © 2022-2025 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
//
// Copyright © 2020 The TensorFlow Authors. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
//
#pragma once
#include <Layer.hpp>
#include <armnn/Tensor.hpp>
#include <armnn/Types.hpp>
#inclu... |
//
// Copyright © 2024-2025 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <armnn/Exceptions.hpp>
#pragma once
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Creates a raw rescale TOSA operator.
/... |
//
// Copyright © 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
//
// Copyright © 2020 The TensorFlow Authors. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
//
#pragma once
#include <gemmlowp/fixedpoint.h>
static void SoftmaxScaling5Bits(double softmaxBeta,
... |
//
// Copyright © 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
//
// Copyright © 2020 The TensorFlow Authors. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
//
#include <cfloat>
#include <vector>
#include <functional>
#include <cstdint>
#include <cmath>
// Abs... |
//
// Copyright © 2022-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "TransposeConv2dOperator.hpp"
#include "layers/TransposeConvolution2dLayer.hpp"
TosaSerializationBasicBlock* ConvertTransposeConv2dToTosaOperator(const Layer* layer,
... |
//
// Copyright © 2022-2023 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "TosaOperatorUtils.hpp"
using namespace armnn;
using namespace tosa;
TosaSerializationBasicBlock* ConvertTransposeConv2dToTosaOperator(const Layer* layer,
... |
//
// Copyright © 2022-2023 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "TransposeOperator.hpp"
TosaSerializationBasicBlock* ConvertTransposeToTosaOperator(const Layer* layer,
const std::vector<const TensorInfo... |
//
// Copyright © 2022-2023 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "TosaOperatorUtils.hpp"
using namespace armnn;
using namespace tosa;
TosaSerializationBasicBlock* ConvertTransposeToTosaOperator(const Layer* layer,
... |
//
// Copyright © 2022,2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "TosaTestUtils.hpp"
using namespace armnn;
using namespace tosa;
void VerifyAvgPool2DIgnoreValue(TosaSerializationBasicBlock* basicBlock,
std::vector<std::vector<int... |
//
// Copyright © 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "TosaTestUtils.hpp"
using namespace armnn;
using namespace tosa;
void VerifyFullyConnected(TosaSerializationBasicBlock* fcBlock,
const std::vector<std::vector<int32_t>>& inputS... |
//
// Copyright © 2022-2025 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
// This file contains tests for validating the creation and configuration of
// TOSA rescale operators. It includes tests for error scenarios such as null
// operator pointers, empty vectors, and mismatched v... |
//
// Copyright © 2022-2025 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
// This file contains test cases for Tosa operator mappings using one-to-many strategies.
// It validates the mapping of operators for various layers such as AvgPool2D with IgnoreValue,
// FullyConnected, Qua... |
//
// Copyright © 2022-2025 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
// This file contains test cases for Tosa operator mappings using one-to-one strategies.
// It validates that the mapping of Tosa operators to the runtime layers is correctly performed,
// ensuring that tenso... |
//
// Copyright © 2023 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "TosaTestUtils.hpp"
using namespace armnn;
using namespace tosa;
void VerifyQuantize(TosaSerializationBasicBlock* quantizeBlock,
std::vector<int32_t> shape,
DType... |
//
// Copyright © 2025 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "TosaTestUtils.hpp"
using namespace armnn;
using namespace tosa;
void VerifySoftmax(TosaSerializationBasicBlock* softmaxBlock,
std::vector<std::vector<int32_t>> inputShape,
... |
//
// Copyright © 2023-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "TosaTestUtils.hpp"
using namespace armnn;
using namespace tosa;
void VerifySplit(TosaSerializationBasicBlock* splitBlock,
std::vector<std::vector<int32_t>> inputShape,
... |
//
// Copyright © 2022-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <Layer.hpp>
#include <tosaCommon/TosaMappings.hpp>
#include <tosaCommon/operatorMappings/TosaOperatorUtils.hpp>
#include <tosaCommon/operatorMappings/TosaRescaleOperatorUtils.hpp>
#in... |
//
// Copyright © 2022-2025 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "TosaRefBackend.hpp"
#include "TosaRefBackendId.hpp"
#include "TosaRefWorkloadFactory.hpp"
#include "TosaRefLayerSupport.hpp"
#include "TosaRefTensorHandleFactory.hpp"
#include <tosaCommon/TosaMappi... |
//
// Copyright © 2022 2025 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/backends/IBackendInternal.hpp>
namespace armnn
{
class TosaRefBackend : public IBackendInternal
{
public:
TosaRefBackend() = default;
~TosaRefBackend() = default;
s... |
//
// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
namespace armnn
{
constexpr const char * TosaRefBackendId() { return "TosaRef"; }
} // namespace armnn
|
//
// Copyright © 2022-2025 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "TosaRefLayerSupport.hpp"
#include <tosaCommon/TosaMappings.hpp>
#include <armnn/Types.hpp>
#include <armnn/utility/IgnoreUnused.hpp>
#include <graph_status.h>
#include <model_runner.h>
#include ... |
//
// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <backendsCommon/LayerSupportBase.hpp>
#include <backendsCommon/LayerSupportRules.hpp>
namespace armnn {
class TosaRefLayerSupport : public ILayerSupport {
public:
bool IsLayerSupported(... |
//
// Copyright © 2022, 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "TosaRefMemoryManager.hpp"
#include <armnn/Exceptions.hpp>
#include <algorithm>
namespace armnn
{
TosaRefMemoryManager::TosaRefMemoryManager()
{}
TosaRefMemoryManager::~TosaRefMemoryManager()
{}
... |
//
// 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 RefTensorHandle
class TosaRefMemoryMa... |
//
// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "TosaRefBackend.hpp"
#include <armnn/BackendRegistry.hpp>
namespace
{
using namespace armnn;
static BackendRegistry::StaticRegistryInitializer g_RegisterHelper
{
BackendRegistryInstance(),
Tos... |
//
// Copyright © 2022, 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "TosaRefTensorHandle.hpp"
namespace armnn
{
TosaRefTensorHandle::TosaRefTensorHandle(const TensorInfo& tensorInfo,
std::shared_ptr<TosaRefMemoryManager>& me... |
//
// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/backends/TensorHandle.hpp>
#include "TosaRefMemoryManager.hpp"
namespace armnn
{
// An implementation of ITensorHandle with simple "bump the pointer" memory-management behaviour
cla... |
//
// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "TosaRefTensorHandleFactory.hpp"
#include "TosaRefTensorHandle.hpp"
#include <armnn/utility/IgnoreUnused.hpp>
namespace armnn
{
using FactoryId = ITensorHandleFactory::FactoryId;
const FactoryId& Tosa... |
//
// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "TosaRefMemoryManager.hpp"
#include <armnn/backends/ITensorHandleFactory.hpp>
namespace armnn
{
constexpr const char * TosaRefTensorHandleFactoryId() { return "Arm/TosaRef/TensorHandleFac... |
//
// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <Layer.hpp>
#include <armnn/backends/MemCopyWorkload.hpp>
#include <backendsCommon/MemImportWorkload.hpp>
#include <backendsCommon/MakeWorkloadHelper.hpp>
#include <armnn/backends/TensorHandle.hpp>
#includ... |
//
// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "TosaRefMemoryManager.hpp"
#include <armnn/Optional.hpp>
#include <armnn/backends/WorkloadFactory.hpp>
#include <armnn/utility/IgnoreUnused.hpp>
namespace armnn
{
// Reference workload fa... |
//
// Copyright © 2022-2025 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/Bat... |
//
// Copyright © 2022-2025 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <armnn/Optional.hpp>
#include <armnn/Types.hpp>
#include <tosaReference/TosaRefLayerSupport.hpp>
#include <doctest/doctest.h>
#include <string>
using namespace armnn;
TEST_SUITE("TosaRefLayerSup... |
//
// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "TosaRefWorkloadFactoryHelper.hpp"
#include <backendsCommon/test/LayerTests.hpp>
#include <tosaReference/TosaRefWorkloadFactory.hpp>
#include <UnitTests.hpp>
|
//
// Copyright © 2022-2023 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <armnn/INetwork.hpp>
#include <GraphUtils.hpp>
#include <TestUtils.hpp>
#include <doctest/doctest.h>
TEST_SUITE("TosaReferenceOptimizedNetwork")
{
TEST_CASE("SimpleSupportedOptimizedNetwork")
{
... |
//
// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <backendsCommon/test/WorkloadFactoryHelper.hpp>
#include <armnn/utility/PolymorphicDowncast.hpp>
#include <tosaReference/TosaRefBackend.hpp>
#include <tosaReference/TosaRefWorkloadFactory.... |
//
// 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 TosaRefBaseWorkload : public BaseWorkload<QueueDescriptor>
{
public:
TosaRefBaseWorkload(const... |
//
// Copyright © 2022-2023 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "TosaRefPreCompiledWorkload.hpp"
namespace armnn
{
TosaRefPreCompiledWorkload::TosaRefPreCompiledWorkload(const PreCompiledQueueDescriptor& descriptor,
... |
//
// Copyright © 2022-2023 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "armnn/backends/Workload.hpp"
#include <graph_status.h>
#include <model_runner.h>
#include <memory>
#include <string>
#include <vector>
namespace armnn
{
bool TosaRefPreCompiledWork... |
//
// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "TosaRefPreCompiledWorkload.hpp"
|
//
// Copyright © 2020 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <armnn/backends/ITensorHandle.hpp>
#include "SampleDynamicAdditionWorkload.hpp"
#include "SampleTensorHandle.hpp"
namespace sdb // sample dynamic backend
{
inline const armnn::TensorInfo& GetTensorInfo(const armnn::ITe... |
//
// Copyright © 2020 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/backends/Workload.hpp>
#include <armnn/backends/WorkloadData.hpp>
namespace sdb // sample dynamic backend
{
class SampleDynamicAdditionWorkload : public armnn::BaseWorkload<armnn::AdditionQueueDescri... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "SampleDynamicBackend.hpp"
#include "SampleDynamicLayerSupport.hpp"
#include "SampleDynamicWorkloadFactory.hpp"
#include "SampleMemoryManager.hpp"
#include "SampleDynamicTensorHandleFactory.hpp"
#include... |
//
// Copyright © 2020 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <cstdint>
extern "C"
{
const char* GetBackendId();
void GetVersion(uint32_t* outMajor, uint32_t* outMinor);
void* BackendFactory();
}
|
//
// Copyright © 2020 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "SampleDynamicLayerSupport.hpp"
#include <InternalTypes.hpp>
#include <LayerSupportCommon.hpp>
#include <armnn/Types.hpp>
namespace sdb // sample dynamic backend
{
bool SampleDynamicLayerSupport::IsLayerSupported(const... |
//
// Copyright © 2020 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <backendsCommon/LayerSupportBase.hpp>
namespace sdb // sample dynamic backend
{
class SampleDynamicLayerSupport : public armnn::LayerSupportBase
{
public:
bool IsAdditionSupported(const armnn::TensorIn... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "SampleDynamicTensorHandleFactory.hpp"
#include "SampleTensorHandle.hpp"
#include <armnn/utility/IgnoreUnused.hpp>
namespace sdb // sample dynamic backend
{
using FactoryId = armnn::ITensorHandleFactor... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "SampleMemoryManager.hpp"
#include <armnn/backends/ITensorHandleFactory.hpp>
namespace sdb // sample dynamic backend
{
constexpr const char * SampleDynamicTensorHandleFactoryId() { return... |
//
// Copyright © 2020 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <armnn/backends/MemCopyWorkload.hpp>
#include <armnn/backends/TensorHandle.hpp>
#include <armnn/utility/PolymorphicDowncast.hpp>
#include "SampleDynamicAdditionWorkload.hpp"
#include "SampleDynamicBackend.hpp"
#include "... |
//
// Copyright © 2020 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "SampleMemoryManager.hpp"
#include <armnn/Optional.hpp>
#include <armnn/backends/WorkloadFactory.hpp>
namespace sdb // sample dynamic backend
{
// Sample Dynamic workload factory.
class SampleDynamicWorklo... |
//
// Copyright © 2020 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "SampleMemoryManager.hpp"
#include <algorithm>
namespace sdb // sample dynamic backend
{
SampleMemoryManager::SampleMemoryManager()
{}
SampleMemoryManager::~SampleMemoryManager()
{}
SampleMemoryManager::Pool* SampleM... |
//
// Copyright © 2020 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/backends/IMemoryManager.hpp>
#include <forward_list>
#include <vector>
namespace sdb // sample dynamic backend
{
// An implementation of IMemoryManager to be used with SampleTensorHandle
class Sampl... |
//
// Copyright © 2020 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "SampleTensorHandle.hpp"
namespace sdb // sample dynamic backend
{
SampleTensorHandle::SampleTensorHandle(const armnn::TensorInfo &tensorInfo,
std::shared_ptr<SampleMemoryManager> ... |
//
// Copyright © 2020 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/backends/TensorHandle.hpp>
#include "SampleMemoryManager.hpp"
namespace sdb // sample dynamic backend
{
// An implementation of ITensorHandle with simple "bump the pointer" memory-management behavio... |
//
// Copyright © 2019 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <client/src/BufferManager.hpp>
#include <client/src/PacketBuffer.hpp>
#include <client/src/ProfilingUtils.hpp>
#include <common/include/SwTrace.hpp>
#include <doctest/doctest.h>
using namespace arm::pi... |
//
// Copyright © 2019 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "PrintPacketHeaderHandler.hpp"
#include "ProfilingOptionsConverter.hpp"
#include "ProfilingTestUtils.hpp"
#include <Runtime.hpp>
#include "TestTimelinePacketHandler.hpp"
#include <armnnUtils/Filesystem.h... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "PrintPacketHeaderHandler.hpp"
#include <iostream>
#include <sstream>
namespace arm
{
namespace pipe
{
std::vector<uint32_t> PrintPacketHeaderHandler::GetHeadersAccepted()
{
return std::vector<uin... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <client/include/ILocalPacketHandler.hpp>
#include <common/include/Packet.hpp>
namespace arm
{
namespace pipe
{
class PrintPacketHeaderHandler : public ILocalPacketHandler
{
virtual s... |
//
// Copyright © 2019 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <client/src/ProfilingConnectionDumpToFileDecorator.hpp>
#include <Runtime.hpp>
#include <armnnUtils/Filesystem.hpp>
#include <common/include/IgnoreUnused.hpp>
#include <common/include/NumericCast.hpp>
... |
//
// Copyright © 2019-2023 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <armnn/Types.hpp>
#include <common/include/LabelsAndEventClasses.hpp>
#include <algorithm>
#include <functional>
#include <set>
#include <doctest/doctest.h>
#include <fmt/format.h>
#include <thread... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <client/src/IProfilingConnectionFactory.hpp>
#include <client/src/ProfilingService.hpp>
#include <client/src/ProfilingUtils.hpp>
#include <client/src/SendCounterPacket.hpp>
#include <client/... |
//
// Copyright © 2019, 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "ProfilingTests.hpp"
#include "ProfilingTestUtils.hpp"
#include <Runtime.hpp>
#include <ArmNNProfilingServiceInitialiser.hpp>
#include <client/src/CommandHandler.hpp>
#include <client/src/Connectio... |
//
// Copyright © 2019 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "ProfilingMocks.hpp"
#include <armnn/utility/PolymorphicDowncast.hpp>
#include <client/src/IProfilingConnection.hpp>
#include <client/src/ProfilingService.hpp>
#include <armnn/profiling/A... |
//
// Copyright © 2019 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <ArmNNProfilingServiceInitialiser.hpp>
#include "ProfilingOptionsConverter.hpp"
#include "ProfilingTestUtils.hpp"
#include <armnn/Descriptors.hpp>
#include <armnn/profiling/ArmNNProfiling.hpp>
#include ... |
//
// Copyright © 2019 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "Runtime.hpp"
#include <client/src/BufferManager.hpp>
#include <client/src/ProfilingService.hpp>
#include <client/src/ProfilingUtils.hpp>
#include <armnn/profiling/ArmNNProfiling.hpp>
#i... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "RequestCountersPacketHandler.hpp"
#include <common/include/NumericCast.hpp>
#include <common/include/PacketVersionResolver.hpp>
#include <common/include/ProfilingException.hpp>
#include <server/include... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <client/src/ProfilingUtils.hpp>
#include <client/include/ILocalPacketHandler.hpp>
#include <client/include/ProfilingOptions.hpp>
#include <common/include/Packet.hpp>
namespace arm
{
name... |
//
// Copyright © 2019 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "ProfilingMocks.hpp"
#include "ProfilingTestUtils.hpp"
#include "SendCounterPacketTests.hpp"
#include <client/src/BufferManager.hpp>
#include <client/src/ProfilingUtils.hpp>
#include <client/src/SendCoun... |
//
// Copyright © 2019 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <client/src/SendCounterPacket.hpp>
#include <client/src/SendThread.hpp>
#include <client/src/ProfilingUtils.hpp>
#include <client/src/IProfilingConnectionFactory.hpp>
#include <armnn/profil... |
//
// Copyright © 2019, 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "ProfilingMocks.hpp"
#include "ProfilingTestUtils.hpp"
#include "ProfilingOptionsConverter.hpp"
#include <Runtime.hpp>
#include <ArmNNProfilingServiceInitialiser.hpp>
#include <armnn/profiling/ArmN... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "TestTimelinePacketHandler.hpp"
#include <client/src/IProfilingConnection.hpp>
#include <common/include/LabelsAndEventClasses.hpp>
#include <chrono>
#include <iostream>
namespace arm
{
namespace pipe... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "TimelineModel.hpp"
#include <client/include/ILocalPacketHandler.hpp>
#include <client/src/ProfilingUtils.hpp>
#include <common/include/Packet.hpp>
#include <server/include/timelineDecod... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "TimelineModel.hpp"
#include <common/include/LabelsAndEventClasses.hpp>
#include <algorithm>
namespace arm
{
namespace pipe
{
void TimelineModel::AddLabel(const arm::pipe::ITimelineDecoder::Label& la... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <common/include/ProfilingException.hpp>
#include <server/include/timelineDecoder/ITimelineDecoder.hpp>
#include <map>
#include <sstream>
#include <vector>
namespace arm
{
namespace pipe
{... |
//
// Copyright © 2019 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <client/src/ProfilingUtils.hpp>
#include <common/include/NumericCast.hpp>
#include <common/include/SwTrace.hpp>
#include <common/include/Threads.hpp>
#include <doctest/doctest.h>
using namespace arm::p... |
//
// Copyright © 2019 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "ProfilingMocks.hpp"
#include "ProfilingTestUtils.hpp"
#include <ArmNNProfilingServiceInitialiser.hpp>
#include <armnn/profiling/ArmNNProfiling.hpp>
#include <client/include/TimelineUtilityMethods.hpp>... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "JSONTimelineDecoder.hpp"
#include <client/src/ProfilingUtils.hpp>
#include <string>
namespace armnn
{
namespace timelinedecoder
{
static const char *const CONNECTION = "connection";
static const char... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <server/include/timelineDecoder/ITimelineDecoder.hpp>
#include <armnnUtils/Filesystem.hpp>
#include <map>
#include <vector>
namespace armnn
{
namespace timelinedecoder
{
class JSONTimelin... |
//
// Copyright © 2020, 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <JSONTimelineDecoder.hpp>
#include <server/include/timelineDecoder/TimelineCaptureCommandHandler.hpp>
#include <server/include/timelineDecoder/TimelineDecoder.hpp>
#include <armnnUtils/Filesystem.hp... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "Cifar10Database.hpp"
#include <armnn/Logging.hpp>
#include <armnn/utility/NumericCast.hpp>
#include <fstream>
#include <vector>
constexpr unsigned int g_kCifar10ImageByteSize = 1 + 3 * 32 * 32;
Cifar10Database::Cifar1... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "ClassifierTestCaseData.hpp"
#include <string>
#include <memory>
class Cifar10Database
{
public:
using DataType = float;
using TTestCaseData = ClassifierTestCaseData<DataType>;
explicit Cifar10... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <vector>
template <typename DataType>
class ClassifierTestCaseData
{
public:
ClassifierTestCaseData(unsigned int label, std::vector<DataType> inputImage)
: m_Label(label)
, m_InputImage(std::mo... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.