Holds all parameters necessary to execute a network Check ExecuteNetworkProgramOptions.cpp for a description of each parameter. More...

#include <ExecuteNetworkParams.hpp>

Public Types
enum	TfLiteExecutor { ArmNNTfLiteParser, ArmNNTfLiteDelegate, TfliteInterpreter }

Public Member Functions
void	ValidateParams ()

Public Attributes
bool	m_AllowExpandedDims

std::string	m_CachedNetworkFilePath

std::vector< armnn::BackendId >	m_ComputeDevices

bool	m_Concurrent

bool	m_DequantizeOutput

std::string	m_DynamicBackendsPath

bool	m_EnableBf16TurboMode

bool	m_EnableFastMath = false

bool	m_EnableFp16TurboMode

bool	m_EnableLayerDetails = false

bool	m_EnableProfiling

bool	m_GenerateTensorData

bool	m_InferOutputShape = false

bool	m_EnableDelegate = false

bool	m_IsModelBinary

std::vector< std::string >	m_InputNames

std::vector< std::string >	m_InputTensorDataFilePaths

std::vector< armnn::TensorShape >	m_InputTensorShapes

size_t	m_Iterations

std::string	m_ModelPath

unsigned int	m_NumberOfThreads

bool	m_OutputDetailsToStdOut

bool	m_OutputDetailsOnlyToStdOut

std::vector< std::string >	m_OutputNames

std::vector< std::string >	m_OutputTensorFiles

bool	m_ParseUnsupported = false

bool	m_PrintIntermediate

bool	m_DontPrintOutputs

bool	m_QuantizeInput

bool	m_SaveCachedNetwork

size_t	m_SubgraphId

double	m_ThresholdTime

int	m_TuningLevel

std::string	m_TuningPath

std::string	m_MLGOTuningFilePath

TfLiteExecutor	m_TfLiteExecutor

size_t	m_ThreadPoolSize

bool	m_ImportInputsIfAligned

bool	m_ReuseBuffers

std::string	m_ComparisonFile

std::vector< armnn::BackendId >	m_ComparisonComputeDevices

bool	m_CompareWithTflite

Detailed Description

Holds all parameters necessary to execute a network Check ExecuteNetworkProgramOptions.cpp for a description of each parameter.

Definition at line 17 of file ExecuteNetworkParams.hpp.

Member Enumeration Documentation

◆ TfLiteExecutor

enum TfLiteExecutor

strong

Enumerator
ArmNNTfLiteParser
ArmNNTfLiteDelegate
TfliteInterpreter

Definition at line 19 of file ExecuteNetworkParams.hpp.

     {
         ArmNNTfLiteParser,
         ArmNNTfLiteDelegate,
         TfliteInterpreter
     };

Member Function Documentation

◆ ValidateParams()

void ValidateParams ( )

Definition at line 49 of file ExecuteNetworkParams.cpp.

References ARMNN_LOG, CheckClTuningParameter(), CheckRequestedBackendsAreValid(), armnn::DetailsWithEvents, armnn::InferAndValidate, m_AllowExpandedDims, m_CachedNetworkFilePath, m_ComputeDevices, OptimizerOptions::m_Debug, m_DynamicBackendsPath, m_EnableBf16TurboMode, m_EnableFastMath, m_EnableFp16TurboMode, m_EnableProfiling, m_GenerateTensorData, m_InferOutputShape, m_InputNames, m_InputTensorDataFilePaths, m_InputTensorShapes, m_MLGOTuningFilePath, OptimizerOptions::m_ModelOptions, m_NumberOfThreads, m_PrintIntermediate, OptimizerOptions::m_ProfilingEnabled, OptimizerOptions::m_ReduceFp32ToBf16, OptimizerOptions::m_ReduceFp32ToFp16, m_SaveCachedNetwork, OptimizerOptions::m_shapeInferenceMethod, m_ThresholdTime, m_TuningLevel, m_TuningPath, DelegateOptions::SetDynamicBackendsPath(), DelegateOptions::SetGpuProfilingState(), DelegateOptions::SetInternalProfilingParams(), DelegateOptions::SetOptimizerOptions(), armnn::ValidateOnly, and ValidatePaths().

Referenced by ProgramOptions::ValidateExecuteNetworkParams().

 {
     if (m_DynamicBackendsPath == "")
     {
         // Check compute devices are valid unless they are dynamically loaded at runtime
         std::string invalidBackends;
         if (!CheckRequestedBackendsAreValid(m_ComputeDevices, armnn::Optional<std::string&>(invalidBackends)))
         {
             ARMNN_LOG(fatal) << "The list of preferred devices contains invalid backend IDs: "
                              << invalidBackends;
         }
     }
     CheckClTuningParameter(m_TuningLevel, m_TuningPath, m_ComputeDevices);
 
     if (m_EnableBf16TurboMode && m_EnableFp16TurboMode)
     {
         throw armnn::InvalidArgumentException("BFloat16 and Float16 turbo mode cannot be "
                                               "enabled at the same time.");
     }
 
     // Check input tensor shapes
     if ((m_InputTensorShapes.size() != 0) &&
         (m_InputTensorShapes.size() != m_InputNames.size()))
     {
         throw armnn::InvalidArgumentException("input-name and input-tensor-shape must have "
                                               "the same amount of elements. ");
     }
 
     if (m_InputTensorDataFilePaths.size() != 0)
     {
         if (!ValidatePaths(m_InputTensorDataFilePaths, true))
         {
             throw armnn::InvalidArgumentException("One or more input data file paths are not valid.");
         }
 
         if (m_InputTensorDataFilePaths.size() < m_InputNames.size())
         {
             throw armnn::InvalidArgumentException(
                     fmt::format("According to the number of input names the user provided the network has {} "
                                 "inputs. But only {} input-tensor-data file paths were provided. Each input of the "
                                 "model is expected to be stored in it's own file.",
                                 m_InputNames.size(),
                                 m_InputTensorDataFilePaths.size()));
         }
     }
 
     // Check that threshold time is not less than zero
     if (m_ThresholdTime < 0)
     {
         throw armnn::InvalidArgumentException("Threshold time supplied as a command line argument is less than zero.");
     }
 
     // Warn if ExecuteNetwork will generate dummy input data
     if (m_GenerateTensorData)
     {
         ARMNN_LOG(warning) << "No input files provided, input tensors will be filled with 0s.";
     }
 
     if (m_AllowExpandedDims && m_InferOutputShape)
     {
         throw armnn::InvalidArgumentException("infer-output-shape and allow-expanded-dims cannot be used together.");
     }
 }