text stringlengths 1 24.5M |
|---|
//
// Copyright © 2020 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <cxxopts/cxxopts.hpp>
/**
* Ensure all mandatory command-line parameters have been passed to cxxopts.
* @param result returned from the cxxopts parse(argc, argv) call
* @param required vector of strings ... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "LstmCommon.hpp"
#include <memory>
#include <string>
#include <vector>
#include <armnn/TypesUtils.hpp>
#include <armnn/utility/NumericCast.hpp>
#include <array>
#include <string>
#include "InferenceTestIm... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "InferenceTest.hpp"
#include "DeepSpeechV1Database.hpp"
#include <armnn/utility/Assert.hpp>
#include <armnn/utility/IgnoreUnused.hpp>
#include <armnnUtils/FloatingPointComparison.hpp>
#include <vector>
nam... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "InferenceTestImage.hpp"
#include "ImagePreprocessor.hpp"
#include <armnn/TypesUtils.hpp>
#include <armnnUtils/Permute.hpp>
#include <armnn/utility/NumericCast.hpp>
#include <iostream>
#include <fcntl.h>
#include <arra... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "ClassifierTestCaseData.hpp"
#include <array>
#include <string>
#include <vector>
#include <memory>
///Tf requires RGB images, normalized in range [0, 1] and resized using Bilinear algorithm
using ImageSe... |
//
// Copyright © 2022-2025 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/ArmNN.hpp>
#include <armnn/Logging.hpp>
#include <armnn/utility/Timer.hpp>
#include <armnn/BackendRegistry.hpp>
#include <armnn/utility/NumericCast.hpp>
#include <armnnUtils/TCon... |
//
// Copyright © 2017, 2023 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "InferenceTest.hpp"
#include <armnn/utility/Assert.hpp>
#include <armnnUtils/Filesystem.hpp>
#include "../src/armnn/Profiling.hpp"
#include <cxxopts/cxxopts.hpp>
#include <fstream>
#include <iostr... |
//
// Copyright © 2017, 2023, 2025 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "InferenceModel.hpp"
#include <armnn/ArmNN.hpp>
#include <armnn/Logging.hpp>
#include <armnn/TypesUtils.hpp>
#include <armnn/utility/IgnoreUnused.hpp>
#include <armnnUtils/TCont... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "InferenceTestImage.hpp"
#include <armnn/utility/Assert.hpp>
#include <armnn/utility/IgnoreUnused.hpp>
#include <armnn/utility/NumericCast.hpp>
#include <fmt/format.h>
#include <array>
#define STB_IMAGE_IMPLEMENTATION
... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/Exceptions.hpp>
#include <VerificationHelpers.hpp>
#include <array>
#include <cstdint>
#include <vector>
#include <utility>
class InferenceTestImageException : public armnn::Exception
{
public:
u... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <string>
#include <utility>
namespace
{
struct LstmInput
{
LstmInput(const std::vector<float>& inputSeq,
const std::vector<float>& stateH,
const std::vector<float>& stateC)
... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "MnistDatabase.hpp"
#include <armnn/Logging.hpp>
#include <fstream>
#include <vector>
constexpr int g_kMnistImageByteSize = 28 * 28;
void EndianSwap(unsigned int &x)
{
x = (x >> 24) | ((x << 8) & 0x00FF0000) | ((x ... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "ClassifierTestCaseData.hpp"
#include <string>
#include <memory>
class MnistDatabase
{
public:
using DataType = float;
using TTestCaseData = ClassifierTestCaseData<DataType>;
explicit MnistData... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "InferenceTestImage.hpp"
#include "ObjectDetectionCommon.hpp"
#include <armnnUtils/QuantizeHelper.hpp>
#include <armnn/TypesUtils.hpp>
#include <armnn/utility/NumericCast.hpp>
#include <array>
#include <m... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "InferenceTest.hpp"
#include "MobileNetSsdDatabase.hpp"
#include <armnn/utility/Assert.hpp>
#include <armnn/utility/IgnoreUnused.hpp>
#include <armnn/utility/NumericCast.hpp>
#include <armnnUtils/FloatingPoi... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <string>
#include <utility>
namespace
{
struct BoundingBox
{
BoundingBox()
: BoundingBox(0.0f, 0.0f, 0.0f, 0.0f)
{}
BoundingBox(float xMin, float yMin, float xMax, float yMax)
:... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "YoloDatabase.hpp"
#include <armnn/Exceptions.hpp>
#include <armnn/Logging.hpp>
#include <armnn/utility/NumericCast.hpp>
#include <array>
#include <cstdint>
#include <tuple>
#include <utility>
#include "InferenceTestIm... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "ClassifierTestCaseData.hpp"
#include <array>
#include <string>
#include <memory>
struct YoloBoundingBox
{
float m_X;
float m_Y;
float m_W;
float m_H;
};
struct YoloDetectedObject
{
Yol... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "InferenceTest.hpp"
#include "YoloDatabase.hpp"
#include <armnn/utility/Assert.hpp>
#include <armnn/utility/IgnoreUnused.hpp>
#include <armnnUtils/FloatingPointComparison.hpp>
#include <algorithm>
#include ... |
//
// Copyright © 2022-2025 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "ArmNNExecutor.hpp"
#include "NetworkExecutionUtils/NetworkExecutionUtils.hpp"
#if defined(ARMNN_SERIALIZER)
#include <armnnSerializer/ISerializer.hpp>
#endif
using namespace armnn;
using namespace... |
//
// Copyright © 2022-2024 Arm Ltd and Contributors.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "IExecutor.hpp"
#include "NetworkExecutionUtils/NetworkExecutionUtils.hpp"
#include "ExecuteNetworkProgramOptions.hpp"
#include "armnn/utility/NumericCast.hpp"
#include "armnn/utility/Timer.hpp"
#include <... |
//
// Copyright © 2022-2025 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "ArmNNExecutor.hpp"
#include "ExecuteNetworkProgramOptions.hpp"
#if defined(ARMNN_TFLITE_DELEGATE) || defined(ARMNN_TFLITE_OPAQUE_DELEGATE)
#include "TfliteExecutor.hpp"
#endif
#include "FileComparis... |
//
// Copyright © 2022-2023 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "ExecuteNetworkParams.hpp"
#include "NetworkExecutionUtils/NetworkExecutionUtils.hpp"
#include <armnn/Logging.hpp>
#include <fmt/format.h>
#include <armnnUtils/Filesystem.hpp>
void CheckClTuningPa... |
//
// Copyright © 2022, 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/BackendId.hpp>
#include <armnn/Tensor.hpp>
#if defined(ARMNN_TFLITE_DELEGATE)||defined(ARMNN_TFLITE_OPAQUE_DELEGATE)
#include <DelegateOptions.hpp>
#endif
/// Holds all parame... |
//
// Copyright © 2022-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "ExecuteNetworkProgramOptions.hpp"
#include "NetworkExecutionUtils/NetworkExecutionUtils.hpp"
#include <armnn/BackendRegistry.hpp>
#include <armnn/Exceptions.hpp>
#include <armnn/utility/Assert.hpp>... |
//
// Copyright © 2020, 2025 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "ExecuteNetworkParams.hpp"
#include <armnn/IRuntime.hpp>
/*
* Historically we use the ',' character to separate dimensions in a tensor shape. However, cxxopts will read this
* an an... |
//
// Copyright © 2023-2025 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "FileComparisonExecutor.hpp"
#include <NetworkExecutionUtils/NetworkExecutionUtils.hpp>
#include <armnn/Numpy.hpp>
#include <algorithm>
#include <ghc/filesystem.hpp>
#include <iterator>
// File limi... |
//
// Copyright © 2023, 2024 Arm Ltd and Contributors.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "ExecuteNetworkProgramOptions.hpp"
#include "IExecutor.hpp"
class FileComparisonExecutor : public IExecutor
{
public:
FileComparisonExecutor(const ExecuteNetworkParams& params);
~FileComparisonExe... |
//
// Copyright © 2022, 2024 Arm Ltd and Contributors.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <vector>
/// IExecutor executes a network
class IExecutor
{
public:
/// Execute the given network
/// @return std::vector<const void*> A type erased vector of the outputs,
/// that can be compa... |
//
// Copyright © 2022-2025 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#if defined(ARMNN_TFLITE_OPAQUE_DELEGATE)
#include <../delegate/opaque/include/armnn_delegate.hpp>
#endif
#include <tensorflow/lite/core/c/c_api.h>
#include "TfliteExecutor.hpp"
#include <tensorflow/lite/ker... |
//
// Copyright © 2022-2024 Arm Ltd and Contributors.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "IExecutor.hpp"
#include "NetworkExecutionUtils/NetworkExecutionUtils.hpp"
#include "ExecuteNetworkProgramOptions.hpp"
#include "armnn/utility/NumericCast.hpp"
#include "armnn/utility/Timer.hpp"
#include <a... |
//
// Copyright © 2023 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <ExecuteNetwork/FileComparisonExecutor.hpp>
#include <doctest/doctest.h>
#include <fstream>
#include <ghc/filesystem.hpp>
namespace
{
namespace fs = ghc::filesystem;
TEST_SUITE("FileComparisonExecutorT... |
//
// Copyright © 2017, 2023, 2025 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <armnnUtils/Filesystem.hpp>
#include <cstdint>
#include <cxxopts/cxxopts.hpp>
#include <algorithm>
#include <fstream>
#include <iostream>
#include <string>
namespace
{
// parses the command... |
//
// Copyright © 2017, 2023, 2025 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "ImageTensorGenerator.hpp"
#include "../InferenceTestImage.hpp"
#include <armnn/Logging.hpp>
#include <armnn/TypesUtils.hpp>
#include <armnnUtils/Filesystem.hpp>
#include <cstdint>
#include <... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "../InferenceTestImage.hpp"
#include <armnn/TypesUtils.hpp>
#include <armnnUtils/TContainer.hpp>
#include <armnnUtils/Permute.hpp>
#include <algorithm>
#include <fstream>
#include <iterator>
#include <string>
// Param... |
//
// Copyright © 2023 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <armnn_delegate.hpp>
#include <tensorflow/lite/c/common.h>
#include <tensorflow/lite/core/c/c_api.h>
#include <tensorflow/lite/interpreter.h>
#include <tensorflow/lite/kernels/register.h>
#include <strin... |
//
// Copyright © 2023 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <armnn/INetwork.hpp>
#include <armnn/IRuntime.hpp>
#include <armnnOnnxParser/IOnnxParser.hpp>
#include <iostream>
int main()
{
// Raw protobuf text for a single layer CONV2D model.
std::string m_P... |
//
// Copyright © 2023 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <armnn_delegate.hpp>
#include <tensorflow/lite/c/common.h>
#include <tensorflow/lite/core/model.h>
#include <tensorflow/lite/interpreter.h>
#include <tensorflow/lite/kernels/register.h>
int main()
{
... |
//
// Copyright © 2023 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <armnn/INetwork.hpp>
#include <armnn/IRuntime.hpp>
#include <armnnTfLiteParser/ITfLiteParser.hpp>
#include <iostream>
int main()
{
using namespace armnn;
// Create ArmNN runtime
IRuntime::Cr... |
//
// Copyright © 2021, 2025 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "TestBlocks.hpp"
#include "TestStrategy.hpp"
#include <IMemoryOptimizerStrategy.hpp>
#include <MemoryOptimizerStrategyLibrary.hpp>
#include <strategies/StrategyValidator.hpp>
#include <cstdint>
#in... |
//
// Copyright © 2021 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <vector>
#include <IMemoryOptimizerStrategy.hpp>
struct TestBlock
{
std::string m_Name;
std::vector<armnn::MemBlock>& m_Blocks;
};
// Generated from fsrcnn_720p.tflite
std::vector<armnn::MemBloc... |
//
// Copyright © 2021 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "TestStrategy.hpp"
namespace armnn
{
std::string TestStrategy::GetName() const
{
return m_Name;
}
MemBlockStrategyType TestStrategy::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 © 2017, 2023, 2025 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "../ImageTensorGenerator/ImageTensorGenerator.hpp"
#include "../InferenceTest.hpp"
#include "ModelAccuracyChecker.hpp"
#include "armnnDeserializer/IDeserializer.hpp"
#include <armnnUtils/File... |
//
// Copyright © 2017, 2023 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "armnn/ArmNN.hpp"
#include "armnn/Utils.hpp"
#include "armnn/INetwork.hpp"
#include "armnnTfLiteParser/TfLiteParser.hpp"
#include "../Cifar10Database.hpp"
#include "../InferenceTest.hpp"
#include ".... |
//
// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "NetworkExecutionUtils.hpp"
#include <armnnUtils/Filesystem.hpp>
#include <iterator>
std::vector<std::string> ParseStringList(const std::string& inputString, const char* delimiter)
{
std::stringstrea... |
//
// Copyright © 2022, 2023-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/BackendRegistry.hpp> // for BackendRegistryInstance
#include <armnn/Logging.hpp> // for ScopedRecord, ARMNN_LOG
#include <armnn/utility/NumericCast.hpp> ... |
//
// Copyright © 2023 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "../NetworkExecutionUtils.hpp"
#include <doctest/doctest.h>
namespace
{
TEST_SUITE("NetworkExecutionUtilsTests")
{
TEST_CASE ("ComputeByteLevelRMSE")
{
// Bytes.
const uint8_t expected[] = {1,... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "../InferenceTest.hpp"
#include "../MnistDatabase.hpp"
#include "armnnOnnxParser/IOnnxParser.hpp"
int main(int argc, char* argv[])
{
armnn::TensorShape inputTensorShape({ 1, 1, 28, 28 });
int retVal = EXIT_FAILUR... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "../InferenceTest.hpp"
#include "../ImagePreprocessor.hpp"
#include "armnnOnnxParser/IOnnxParser.hpp"
int main(int argc, char* argv[])
{
int retVal = EXIT_FAILURE;
try
{
// Coverity fix: The following ... |
//
// Copyright © 2019 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "CommandFileParser.hpp"
#include <algorithm>
#include <fstream>
#include <iostream>
#include <iterator>
namespace armnn
{
namespace gatordmock
{
void CommandFileParser::ParseFile(std::string CommandFi... |
//
// Copyright © 2019 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "GatordMockService.hpp"
#include <string>
namespace armnn
{
namespace gatordmock
{
/// This class parses a command file for the GatordMockService. The file contains one command per line.
... |
//
// Copyright © 2019, 2023, 2025 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "CommandLineProcessor.hpp"
#include <cstdint>
#include <cxxopts/cxxopts.hpp>
#include <iostream>
namespace armnn
{
namespace gatordmock
{
bool CommandLineProcessor::ProcessCommandLine(int a... |
//
// Copyright © 2019 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <string>
namespace armnn
{
namespace gatordmock
{
/// Use Boost program options to process the command line.
/// -h or --help to print the options.
/// -n or --namespace to specify the UDS... |
//
// Copyright © 2019 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "GatordMockService.hpp"
#include "MockUtils.hpp"
#include <common/include/Packet.hpp>
#include <common/include/CommandHandlerFunctor.hpp>
#include "SendCounterPacket.hpp"
#include "IPerio... |
//
// Copyright © 2019 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "CommandFileParser.hpp"
#include "CommandLineProcessor.hpp"
#include "GatordMockService.hpp"
#include <server/include/basePipeServer/ConnectionHandler.hpp>
#include <string>
#include <signal.h>
using n... |
//
// Copyright © 2019 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "GatordMockService.hpp"
#include <common/include/Assert.hpp>
#include <common/include/CommandHandlerRegistry.hpp>
#include <common/include/CommonProfilingUtils.hpp>
#include <common/include/PacketVersion... |
//
// Copyright © 2019 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
// local includes
#include "PeriodicCounterCaptureCommandHandler.hpp"
#include "StreamMetadataCommandHandler.hpp"
#include "StubCommandHandler.hpp"
#include <common/include/CommandHandlerRegistry.hp... |
//
// Copyright © 2019 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "PeriodicCounterCaptureCommandHandler.hpp"
#include <common/include/CommonProfilingUtils.hpp>
#include <armnn/utility/NumericCast.hpp>
#include <iostream>
namespace armnn
{
namespace gatordmock
{
vo... |
//
// Copyright © 2019 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <common/include/CommandHandlerFunctor.hpp>
#include <common/include/Packet.hpp>
#include <vector>
namespace armnn
{
namespace gatordmock
{
struct CounterCaptureValues
{
uint64_t m_Ti... |
//
// Copyright © 2019 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "PeriodicCounterSelectionResponseHandler.hpp"
#include <common/include/CommonProfilingUtils.hpp>
#include <iostream>
namespace armnn
{
namespace gatordmock
{
void PeriodicCounterSelectionResponseHand... |
//
// Copyright © 2019 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <common/include/CommandHandlerFunctor.hpp>
#include <common/include/Packet.hpp>
#include <vector>
namespace armnn
{
namespace gatordmock
{
class PeriodicCounterSelectionResponseHandler : ... |
//
// Copyright © 2019 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "StreamMetadataCommandHandler.hpp"
#include <common/include/CommonProfilingUtils.hpp>
#include <iostream>
#include <sstream>
namespace armnn
{
namespace gatordmock
{
void StreamMetadataCommandHandler... |
//
// Copyright © 2019 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <common/include/CommandHandlerFunctor.hpp>
#include <common/include/Packet.hpp>
#include <vector>
namespace armnn
{
namespace gatordmock
{
struct PacketVersion
{
uint16_t m_PacketFam... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <common/include/CommandHandlerFunctor.hpp>
#include <common/include/IgnoreUnused.hpp>
#include <vector>
namespace armnn
{
namespace gatordmock
{
class StubCommandHandler : public arm::pip... |
//
// Copyright © 2017, 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <ArmNNProfilingServiceInitialiser.hpp>
#include <GatordMockService.hpp>
#include <Runtime.hpp>
#include <armnnTestUtils/MockBackend.hpp>
#include <client/src/ProfilingService.hpp>
#include <client/... |
//
// Copyright © 2020 STMicroelectronics and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <algorithm>
#include <getopt.h>
#include <numeric>
#include <signal.h>
#include <string>
#include <sys/time.h>
#include <vector>
#include <armnn/BackendId.hpp>
#include <armnn/BackendRegistry.... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "../InferenceTest.hpp"
#include "../ImagePreprocessor.hpp"
#include "armnnTfLiteParser/ITfLiteParser.hpp"
using namespace armnnTfLiteParser;
int main(int argc, char* argv[])
{
int retVal = EXIT_FAILURE;
try
{... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "../InferenceTest.hpp"
#include "../ImagePreprocessor.hpp"
#include "armnnTfLiteParser/ITfLiteParser.hpp"
using namespace armnnTfLiteParser;
int main(int argc, char* argv[])
{
int retVal = EXIT_FAILURE;
try
{... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "../InferenceTest.hpp"
#include "../ImagePreprocessor.hpp"
#include "armnnTfLiteParser/ITfLiteParser.hpp"
using namespace armnnTfLiteParser;
int main(int argc, char* argv[])
{
int retVal = EXIT_FAILURE;
try
{... |
//
// Copyright © 2017, 2023, 2025 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "../InferenceTest.hpp"
#include "../ImagePreprocessor.hpp"
#include "armnnTfLiteParser/ITfLiteParser.hpp"
#include <cstdint>
#include <cxxopts/cxxopts.hpp>
#include <fstream>
using namespace ... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "../InferenceTest.hpp"
#include "../ImagePreprocessor.hpp"
#include "armnnTfLiteParser/ITfLiteParser.hpp"
using namespace armnnTfLiteParser;
int main(int argc, char* argv[])
{
int retVal = EXIT_FAILURE;
try
{... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "../MobileNetSsdInferenceTest.hpp"
#include "armnnTfLiteParser/ITfLiteParser.hpp"
#include <algorithm>
#include <iterator>
using namespace armnnTfLiteParser;
int main(int argc, char* argv[])
{
int retVal = EXIT_FAI... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "../InferenceTest.hpp"
#include "../ImagePreprocessor.hpp"
#include "armnnTfLiteParser/ITfLiteParser.hpp"
using namespace armnnTfLiteParser;
int main(int argc, char* argv[])
{
int retVal = EXIT_FAILURE;
try
{... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "../InferenceTest.hpp"
#include "../ImagePreprocessor.hpp"
#include "armnnTfLiteParser/ITfLiteParser.hpp"
using namespace armnnTfLiteParser;
int main(int argc, char* argv[])
{
int retVal = EXIT_FAILURE;
try
{... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "../InferenceTest.hpp"
#include "../ImagePreprocessor.hpp"
#include "armnnTfLiteParser/ITfLiteParser.hpp"
using namespace armnnTfLiteParser;
int main(int argc, char* argv[])
{
int retVal = EXIT_FAILURE;
try
{... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "../InferenceTest.hpp"
#include "../ImagePreprocessor.hpp"
#include "armnnTfLiteParser/ITfLiteParser.hpp"
using namespace armnnTfLiteParser;
int main(int argc, char* argv[])
{
int retVal = EXIT_FAILURE;
try
{... |
//
// Copyright © 2020 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "NMS.hpp"
#include <cmath>
#include <algorithm>
#include <cstddef>
#include <numeric>
#include <ostream>
namespace yolov3 {
namespace {
/** Number of elements needed to represent a box */
constexpr int box_elements = 4... |
//
// Copyright © 2020 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <ostream>
#include <vector>
namespace yolov3 {
/** Non Maxima Suprresion configuration meta-data */
struct NMSConfig {
unsigned int num_classes{0}; /**< Number of classes in the detected boxes */
... |
//
// Copyright © 2020, 2023-2025 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "armnnTfLiteParser/ITfLiteParser.hpp"
#include "NMS.hpp"
#include <stb/stb_image.h>
#include <armnn/INetwork.hpp>
#include <armnn/IRuntime.hpp>
#include <armnn/Logging.hpp>
#include <cstdin... |
/*
Copyright (c) 2014-2022 Jarryd Beck
SPDX-License-Identifier: MIT
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modi... |
// ====================================================================== lgtm [cpp/missing-header-guard]
// == DO NOT MODIFY THIS FILE BY HAND - IT IS AUTO GENERATED BY CMAKE! ==
// ======================================================================
//
// doctest.h - the lightest feature-rich C++ single-header test... |
// Formatting library for C++ - the core API
//
// Copyright (c) 2012 - present, Victor Zverovich
// All rights reserved.
// SPDX-License-Identifier: MIT
//
// For the license information refer to format.h.
#ifndef FMT_CORE_H_
#define FMT_CORE_H_
#include <cstdio> // std::FILE
#include <cstring>
#include <functional... |
// Formatting library for C++ - implementation
//
// Copyright (c) 2012 - 2016, Victor Zverovich
// All rights reserved.
// SPDX-License-Identifier: MIT
//
// For the license information refer to format.h.
#ifndef FMT_FORMAT_INL_H_
#define FMT_FORMAT_INL_H_
#include <cassert>
#include <cctype>
#include <climits>
#inc... |
/*
Formatting library for C++
Copyright (c) 2012 - present, Victor Zverovich
SPDX-License-Identifier: MIT
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
wi... |
// Formatting library for C++
//
// Copyright (c) 2012 - 2016, Victor Zverovich
// All rights reserved.
// SPDX-License-Identifier: MIT
//
// For the license information refer to format.h.
#include "fmt/format-inl.h"
FMT_BEGIN_NAMESPACE
namespace detail {
template <typename T>
int format_float(char* buf, std::size_t... |
// Copyright 2015 The Gemmlowp Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by ... |
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distribut... |
// Copyright 2018 The Gemmlowp Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by ... |
// Copyright 2015 The Gemmlowp Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by ... |
// Copyright 2015 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable... |
// Copyright 2020 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable... |
// Copyright 2018 The Gemmlowp Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by ... |
//---------------------------------------------------------------------------------------
//
// ghc::filesystem - A C++17-like filesystem implementation for C++11/C++14/C++17
//
//---------------------------------------------------------------------------------------
//
// Copyright (c) 2018, Steffen Schümann <s.schue... |
// half - IEEE 754-based half-precision floating point library.
//
// Copyright (c) 2012-2017 Christian Rau <rauy@users.sourceforge.net>
//
// SPDX-License-Identifier: MIT
//
// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation
// files (the "Soft... |
//
// Copyright (c) MapBox All rights reserved.
// SPDX-License-Identifier: BSD-3-Clause
//
#ifndef MAPBOX_UTIL_OPTIONAL_HPP
#define MAPBOX_UTIL_OPTIONAL_HPP
#pragma message("This implementation of optional is deprecated. See https://github.com/mapbox/variant/issues/64.")
#include <type_traits>
#include <utility>
#... |
//
// Copyright (c) MapBox All rights reserved.
// SPDX-License-Identifier: BSD-3-Clause
//
#ifndef MAPBOX_UTIL_RECURSIVE_WRAPPER_HPP
#define MAPBOX_UTIL_RECURSIVE_WRAPPER_HPP
// Based on variant/recursive_wrapper.hpp from boost.
//
// Original license:
//
// Copyright (c) 2002-2003
// Eric Friedman, Itay Maman
//
//... |
//
// Copyright (c) MapBox All rights reserved.
// SPDX-License-Identifier: BSD-3-Clause
//
#ifndef MAPBOX_UTIL_VARIANT_HPP
#define MAPBOX_UTIL_VARIANT_HPP
#include <cassert>
#include <cstddef> // size_t
#include <new> // operator new
#include <stdexcept> // runtime_error
#include <string>
#include <tuple>
#i... |
//
// Copyright (c) MapBox All rights reserved.
// SPDX-License-Identifier: BSD-3-Clause
//
#ifndef VARIANT_CAST_HPP
#define VARIANT_CAST_HPP
#include <type_traits>
namespace mapbox {
namespace util {
namespace detail {
template <class T>
class static_caster
{
public:
template <class V>
T& operator()(V& v)... |
//
// Copyright (c) MapBox All rights reserved.
// SPDX-License-Identifier: BSD-3-Clause
//
#ifndef MAPBOX_UTIL_VARIANT_IO_HPP
#define MAPBOX_UTIL_VARIANT_IO_HPP
#include <iosfwd>
#include <mapbox/variant.hpp>
namespace mapbox {
namespace util {
namespace detail {
// operator<< helper
template <typename Out>
class... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.