ArmNNExecutor Class Reference

#include <ArmNNExecutor.hpp>

Inheritance diagram for ArmNNExecutor:

Public Member Functions
	ArmNNExecutor (const ExecuteNetworkParams &params, armnn::IRuntime::CreationOptions runtimeOptions)
std::vector< const void *>	Execute () override
	Execute the given network. More...
void	PrintNetworkInfo () override
	Print available information about the network. More...
void	CompareAndPrintResult (std::vector< const void *> otherOutput) override
	Compare the output with the result of another IExecutor. More...
Public Member Functions inherited from IExecutor
virtual	~IExecutor ()

Detailed Description

Definition at line 37 of file ArmNNExecutor.hpp.

Constructor & Destructor Documentation

ArmNNExecutor()

ArmNNExecutor	(	const ExecuteNetworkParams &	params,
		armnn::IRuntime::CreationOptions	runtimeOptions
	)

Definition at line 17 of file ArmNNExecutor.cpp.

References ARMNN_LOG, CheckInferenceTimeThreshold(), IRuntime::Create(), armnn::DetailsOnly, armnn::DetailsWithEvents, armnn::Failure, AsyncCallbackManager::GetNewCallback(), AsyncCallbackManager::GetNotifiedCallback(), armnn::GetTimeDuration(), armnn::GetTimeNow(), armnn::info, ExecuteNetworkParams::m_Concurrent, ExecuteNetworkParams::m_DontPrintOutputs, ExecuteNetworkParams::m_DynamicBackendsPath, IRuntime::CreationOptions::m_DynamicBackendsPath, IRuntime::CreationOptions::m_EnableGpuProfiling, ExecuteNetworkParams::m_EnableProfiling, ExecuteNetworkParams::m_GenerateTensorData, ExecuteNetworkParams::m_ImportInputsIfAligned, ExecuteNetworkParams::m_Iterations, ExecuteNetworkParams::m_OutputDetailsOnlyToStdOut, ExecuteNetworkParams::m_OutputDetailsToStdOut, ExecuteNetworkParams::m_ThreadPoolSize, ExecuteNetworkParams::m_ThresholdTime, armnn::Medium, and armnn::warning.

: m_Params(params)
{
    runtimeOptions.m_EnableGpuProfiling = params.m_EnableProfiling;
    runtimeOptions.m_DynamicBackendsPath = params.m_DynamicBackendsPath;
    m_Runtime = armnn::IRuntime::Create(runtimeOptions);

    auto parser = CreateParser();
    auto network = parser->CreateNetwork(m_Params);
    auto optNet = OptimizeNetwork(network.get());

    m_IOInfo = GetIOInfo(optNet.get());
    SetupInputsAndOutputs();

    std::string errorMsg;

    armnn::ProfilingDetailsMethod profilingDetailsMethod = ProfilingDetailsMethod::Undefined;
    if (params.m_OutputDetailsOnlyToStdOut)
    {
        profilingDetailsMethod = armnn::ProfilingDetailsMethod::DetailsOnly;
    }
    else if (params.m_OutputDetailsToStdOut)
    {
        profilingDetailsMethod = armnn::ProfilingDetailsMethod::DetailsWithEvents;
    }

    INetworkProperties networkProperties{m_Params.m_Concurrent,
                                         MemorySource::Undefined,
                                         MemorySource::Undefined,
                                         params.m_EnableProfiling,
                                         profilingDetailsMethod};

    m_Runtime->LoadNetwork(m_NetworkId, std::move(optNet), errorMsg, networkProperties);

    if (m_Params.m_Iterations > 1)
    {
        std::stringstream msg;
        msg << "Network will be executed " << m_Params.m_Iterations;
        if (m_Params.m_Concurrent)
        {
            msg << " times in an asynchronous manner. ";
        }
        else
        {
            msg << " times successively. ";
        }
        msg << "The input-tensor-data files will be reused recursively if the user didn't provide enough to "
               "cover each execution.";
        ARMNN_LOG(info) << msg.str();
    }

    if (m_Params.m_GenerateTensorData)
    {
        ARMNN_LOG(warning) << "The input data was generated, note that the output will not be useful";
    }

    if (m_Params.m_DontPrintOutputs)
    {
        ARMNN_LOG(info) << "Printing outputs to console is disabled.";
    }
}

Member Function Documentation

CompareAndPrintResult()

void CompareAndPrintResult ( std::vector< const void *>  otherOutput )

overridevirtual

Compare the output with the result of another IExecutor.

Implements IExecutor.

Definition at line 671 of file ArmNNExecutor.cpp.

References IOnnxParser::Create(), IDeserializer::Create(), ITfLiteParser::Create(), armnn::Float32, LogAndThrow(), BindingPointInfo::m_BindingId, ITfLiteParser::TfLiteParserOptions::m_InferAndValidate, ExecuteNetworkParams::m_InferOutputShape, ExecuteNetworkParams::m_InputNames, ExecuteNetworkParams::m_InputTensorShapes, ExecuteNetworkParams::m_IsModelBinary, ExecuteNetworkParams::m_ModelPath, ExecuteNetworkParams::m_ParseUnsupported, ITfLiteParser::TfLiteParserOptions::m_StandInLayerForUnsupported, BindingPointInfo::m_TensorInfo, armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, and armnn::QSymmS8.

{
    unsigned int index = 0;

    for (const auto& outputTensors: m_OutputTensorsVec)
    {
        for (const auto& outputTensor: outputTensors)
        {
            float result = 0;
            size_t size = outputTensor.second.GetNumBytes();

            switch (outputTensor.second.GetDataType())
            {
                case armnn::DataType::Float32:
                {
                    result = ComputeRMSE<float>(outputTensor.second.GetMemoryArea(), otherOutput[index++], size);
                    break;
                }
                case armnn::DataType::QSymmS16:
                {
                    result = ComputeRMSE<int16_t>(outputTensor.second.GetMemoryArea(), otherOutput[index++], size);
                    break;
                }
                case armnn::DataType::QSymmS8:
                case armnn::DataType::QAsymmS8:
                {
                    result = ComputeRMSE<int8_t>(outputTensor.second.GetMemoryArea(), otherOutput[index++], size);
                    break;
                }
                case armnn::DataType::QAsymmU8:
                {
                    result = ComputeRMSE<uint8_t>(outputTensor.second.GetMemoryArea(), otherOutput[index++], size);
                    break;
                }
                default:
                {
                    LogAndThrow("Unexpected DataType");
                }
            }
            std::cout << "RMSE: of " << result << "\n";
        }
    }
}

Execute()

std::vector< const void * > Execute ( )

overridevirtual

Execute the given network.

Returns

std::vector<const void*> A type erased vector of the outputs, that can be compared with the output of another IExecutor

Implements IExecutor.

Definition at line 198 of file ArmNNExecutor.cpp.

References ExecuteNetworkParams::m_ThreadPoolSize.

{
    if(m_Params.m_ThreadPoolSize == 0)
    {
        ExecuteSync();
    }
    else
    {
        ExecuteAsync();
    }
    std::vector<const void*> results;
    for (auto& output : m_OutputStorage)
    {
        results.push_back(output.m_Mem);
    }

    return results;
}

PrintNetworkInfo()

void PrintNetworkInfo ( )

overridevirtual

Print available information about the network.

Implements IExecutor.

Definition at line 217 of file ArmNNExecutor.cpp.

References ARMNN_LOG, armnn::BFloat16, armnn::Boolean, IOptimizedNetwork::ExecuteStrategy(), armnn::Float16, armnn::Float32, IInputSlot::GetConnection(), TensorInfo::GetDataType(), armnn::GetDataTypeName(), IConnectableLayer::GetInputSlot(), TensorInfo::GetNumBytes(), TensorInfo::GetNumElements(), IConnectableLayer::GetOutputSlot(), TensorInfo::GetQuantizationOffset(), TensorInfo::GetQuantizationScale(), TensorInfo::GetShape(), IOutputSlot::GetTensorInfo(), armnn::GetTimeDuration(), armnn::GetTimeNow(), IConnectableLayer::GetType(), armnn::IgnoreUnused(), armnn::InferAndValidate, armnn::info, armnn::Input, LogAndThrow(), OptimizerOptions::m_Debug, ExecuteNetworkParams::m_GenerateTensorData, ExecuteNetworkParams::m_ImportInputsIfAligned, ExecuteNetworkParams::m_InputNames, ExecuteNetworkParams::m_InputTensorDataFilePaths, ExecuteNetworkParams::m_Iterations, OptimizerOptions::m_ModelOptions, ExecuteNetworkParams::m_OutputTensorFiles, OptimizerOptions::m_ProfilingEnabled, OptimizerOptions::m_ReduceFp32ToBf16, OptimizerOptions::m_ReduceFp32ToFp16, ExecuteNetworkParams::m_ReuseBuffers, OptimizerOptions::m_shapeInferenceMethod, ExecuteNetworkParams::m_ThreadPoolSize, armnn::Malloc, armnn::Optimize(), armnn::Output, armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, armnn::QSymmS8, IOptimizedNetwork::SerializeToDot(), armnn::Signed32, armnn::Signed64, and armnn::ValidateOnly.

{
    const std::vector<std::string>& inputNames = m_Params.m_InputNames.size() != 0 ?
                                                 m_Params.m_InputNames :
                                                 m_IOInfo.m_InputNames;
    std::stringstream ss;
    ss << "===== Network Info =====\n";
    ss << "Inputs in order:\n";
    for (const auto& inputName : inputNames)
    {
        const auto inputInfo = m_IOInfo.m_InputInfoMap[inputName].second;
        ss <<  inputName << ", " << inputInfo.GetShape() << ", " << GetDataTypeName(inputInfo.GetDataType());
        if (inputInfo.IsQuantized())
        {
            ss << " Quantization Offset: " << inputInfo.GetQuantizationOffset();
            if (inputInfo.HasMultipleQuantizationScales())
            {
                ss << " Quantization scales: ";
                for (const auto scale: inputInfo.GetQuantizationScales())
                {
                    ss << scale << ", ";
                }
            }
            else
            {
                ss << " Quantization scale: " << inputInfo.GetQuantizationScale();
            }
        }
        ss  << "\n";
    }

    ss << "Outputs in order:\n";
    for (const auto& outputName : m_IOInfo.m_OutputNames)
    {
        const auto outputInfo = m_IOInfo.m_OutputInfoMap[outputName].second;
        ss <<  outputName << ", " << outputInfo.GetShape() << ", " << GetDataTypeName(outputInfo.GetDataType());
        if (outputInfo.IsQuantized())
        {
            ss << " Quantization Offset: " << outputInfo.GetQuantizationOffset();
            if (outputInfo.HasMultipleQuantizationScales())
            {
                ss << " Quantization scales: ";
                for (const auto scale: outputInfo.GetQuantizationScales())
                {
                    ss << scale << ", ";
                }
            }
            else
            {
                ss << " Quantization scale: " << outputInfo.GetQuantizationScale();
            }
        }
        ss  << "\n";
    }

    std::cout << ss.str() << std::endl;
}

---

The documentation for this class was generated from the following files:

• tests/ExecuteNetwork/ArmNNExecutor.hpp
• tests/ExecuteNetwork/ArmNNExecutor.cpp