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 }

using	TensorShapePtr = std::unique_ptr< armnn::TensorShape >

Public Member Functions
void	ValidateParams ()

Public Attributes
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

std::vector< std::string >	m_InputNames

std::vector< std::string >	m_InputTensorDataFilePaths

std::vector< TensorShapePtr >	m_InputTensorShapes

std::vector< std::string >	m_InputTypes

bool	m_IsModelBinary

size_t	m_Iterations

std::string	m_ModelFormat

std::string	m_ModelPath

unsigned int	m_NumberOfThreads

std::vector< std::string >	m_OutputNames

std::vector< std::string >	m_OutputTensorFiles

std::vector< std::string >	m_OutputTypes

bool	m_ParseUnsupported = false

bool	m_PrintIntermediate

bool	m_QuantizeInput

bool	m_SaveCachedNetwork

size_t	m_SimultaneousIterations

size_t	m_SubgraphId

double	m_ThresholdTime

int	m_TuningLevel

std::string	m_TuningPath

std::string	m_MLGOTuningFilePath

TfLiteExecutor	m_TfLiteExecutor

Detailed Description

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

Definition at line 13 of file ExecuteNetworkParams.hpp.

Member Typedef Documentation

◆ TensorShapePtr

using TensorShapePtr = std::unique_ptr<armnn::TensorShape>

Definition at line 15 of file ExecuteNetworkParams.hpp.

Member Enumeration Documentation

◆ TfLiteExecutor

enum TfLiteExecutor

strong

Enumerator
ArmNNTfLiteParser
ArmNNTfLiteDelegate
TfliteInterpreter

Definition at line 17 of file ExecuteNetworkParams.hpp.

     {
         ArmNNTfLiteParser,
         ArmNNTfLiteDelegate,
         TfliteInterpreter
     };

Member Function Documentation

◆ ValidateParams()

void ValidateParams ( )

Definition at line 111 of file ExecuteNetworkParams.cpp.

References ARMNN_LOG, CheckClTuningParameter(), CheckModelFormat(), IsModelBinary(), m_ComputeDevices, m_Concurrent, m_DynamicBackendsPath, m_EnableBf16TurboMode, m_EnableFp16TurboMode, m_GenerateTensorData, m_InputNames, m_InputTensorDataFilePaths, m_InputTensorShapes, m_InputTypes, m_IsModelBinary, m_ModelFormat, m_OutputNames, m_OutputTensorFiles, m_OutputTypes, m_SimultaneousIterations, m_ThresholdTime, m_TuningLevel, m_TuningPath, and ValidatePaths().

Referenced by ProgramOptions::ValidateExecuteNetworkParams().

 {
     // Set to true if it is preferred to throw an exception rather than use ARMNN_LOG
     bool throwExc = false;
 
     try
     {
         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)
         {
             ARMNN_LOG(fatal) << "BFloat16 and Float16 turbo mode cannot be enabled at the same time.";
         }
 
         m_IsModelBinary = IsModelBinary(m_ModelFormat);
 
         CheckModelFormat(m_ModelFormat);
 
         // Check number of simultaneous iterations
         if ((m_SimultaneousIterations < 1))
         {
             ARMNN_LOG(fatal) << "simultaneous-iterations cannot be less than 1. ";
         }
 
         // Check input tensor shapes
         if ((m_InputTensorShapes.size() != 0) &&
             (m_InputTensorShapes.size() != m_InputNames.size()))
         {
             ARMNN_LOG(fatal) << "input-name and input-tensor-shape must have the same amount of elements. ";
         }
 
         if (m_InputTensorDataFilePaths.size() != 0)
         {
             if (!ValidatePaths(m_InputTensorDataFilePaths, true))
             {
                 ARMNN_LOG(fatal) << "One or more input data file paths are not valid. ";
             }
 
             if (!m_Concurrent && m_InputTensorDataFilePaths.size() != m_InputNames.size())
             {
                 ARMNN_LOG(fatal) << "input-name and input-tensor-data must have the same amount of elements. ";
             }
 
             if (m_InputTensorDataFilePaths.size() < m_SimultaneousIterations * m_InputNames.size())
             {
                 ARMNN_LOG(fatal) << "There is not enough input data for " << m_SimultaneousIterations << " execution.";
             }
             if (m_InputTensorDataFilePaths.size() > m_SimultaneousIterations * m_InputNames.size())
             {
                 ARMNN_LOG(fatal) << "There is more input data for " << m_SimultaneousIterations << " execution.";
             }
         }
 
         if ((m_OutputTensorFiles.size() != 0) &&
             (m_OutputTensorFiles.size() != m_OutputNames.size()))
         {
             ARMNN_LOG(fatal) << "output-name and write-outputs-to-file must have the same amount of elements. ";
         }
 
         if ((m_OutputTensorFiles.size() != 0)
             && m_OutputTensorFiles.size() != m_SimultaneousIterations * m_OutputNames.size())
         {
             ARMNN_LOG(fatal) << "There is not enough output data for " << m_SimultaneousIterations << " execution.";
         }
 
         if (m_InputTypes.size() == 0)
         {
             //Defaults the value of all inputs to "float"
             m_InputTypes.assign(m_InputNames.size(), "float");
         }
         else if ((m_InputTypes.size() != 0) &&
                  (m_InputTypes.size() != m_InputNames.size()))
         {
             ARMNN_LOG(fatal) << "input-name and input-type must have the same amount of elements.";
         }
 
         if (m_OutputTypes.size() == 0)
         {
             //Defaults the value of all outputs to "float"
             m_OutputTypes.assign(m_OutputNames.size(), "float");
         }
         else if ((m_OutputTypes.size() != 0) &&
                  (m_OutputTypes.size() != m_OutputNames.size()))
         {
             ARMNN_LOG(fatal) << "output-name and output-type must have the same amount of elements.";
         }
 
         // Check that threshold time is not less than zero
         if (m_ThresholdTime < 0)
         {
             ARMNN_LOG(fatal) << "Threshold time supplied as a command line argument is less than zero.";
         }
     }
     catch (std::string& exc)
     {
         if (throwExc)
         {
             throw armnn::InvalidArgumentException(exc);
         }
         else
         {
             std::cout << exc;
             exit(EXIT_FAILURE);
         }
     }
     // Check turbo modes
 
     // 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.";
     }
 }