NetworkExecutionUtils.cpp File Reference

#include "NetworkExecutionUtils.hpp"
#include <armnnUtils/Filesystem.hpp>
#include <InferenceTest.hpp>
#include <ResolveType.hpp>

Go to the source code of this file.

Typedefs
using	TContainer = mapbox::util::variant< std::vector< float >, std::vector< int >, std::vector< unsigned char >, std::vector< int8_t > >
using	QuantizationParams = std::pair< float, int32_t >

Functions
template<armnn::DataType NonQuantizedType>
auto	ParseDataArray (std::istream &stream)
template<armnn::DataType QuantizedType>
auto	ParseDataArray (std::istream &stream, const float &quantizationScale, const int32_t &quantizationOffset)
template<>
auto	ParseDataArray< armnn::DataType::Float32 > (std::istream &stream)
template<>
auto	ParseDataArray< armnn::DataType::Signed32 > (std::istream &stream)
template<>
auto	ParseDataArray< armnn::DataType::QAsymmS8 > (std::istream &stream)
template<>
auto	ParseDataArray< armnn::DataType::QAsymmU8 > (std::istream &stream)
template<>
auto	ParseDataArray< armnn::DataType::QSymmS8 > (std::istream &stream)
template<>
auto	ParseDataArray< armnn::DataType::QAsymmS8 > (std::istream &stream, const float &quantizationScale, const int32_t &quantizationOffset)
template<>
auto	ParseDataArray< armnn::DataType::QAsymmU8 > (std::istream &stream, const float &quantizationScale, const int32_t &quantizationOffset)
template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
std::vector< T >	GenerateDummyTensorData (unsigned int numElements)
std::vector< unsigned int >	ParseArray (std::istream &stream)
std::vector< std::string >	ParseStringList (const std::string &inputString, const char *delimiter)
	Splits a given string at every accurance of delimiter into a vector of string. More...
void	PopulateTensorWithData (TContainer &tensorData, unsigned int numElements, const std::string &dataTypeStr, const armnn::Optional< QuantizationParams > &qParams, const armnn::Optional< std::string > &dataFile)
bool	ValidatePath (const std::string &file, const bool expectFile)
	Verifies if the given string is a valid path. More...
bool	ValidatePaths (const std::vector< std::string > &fileVec, const bool expectFile)
	Verifies if a given vector of strings are valid paths. More...

Typedef Documentation

QuantizationParams

using QuantizationParams = std::pair<float, int32_t>

Definition at line 208 of file NetworkExecutionUtils.cpp.

TContainer

using TContainer = mapbox::util::variant<std::vector<float>, std::vector<int>, std::vector<unsigned char>, std::vector<int8_t> >

Definition at line 207 of file NetworkExecutionUtils.cpp.

Function Documentation

GenerateDummyTensorData()

std::vector<T> GenerateDummyTensorData

(

unsigned int

numElements

)

Definition at line 95 of file NetworkExecutionUtils.cpp.

{
    return std::vector<T>(numElements, static_cast<T>(0));
}

ParseArray()

std::vector<unsigned int> ParseArray

(

std::istream &

stream

)

Definition at line 101 of file NetworkExecutionUtils.cpp.

References armnn::numeric_cast().

Referenced by ProgramOptions::ParseOptions().

{
    return ParseArrayImpl<unsigned int>(
            stream,
            [](const std::string& s) { return armnn::numeric_cast<unsigned int>(std::stoi(s)); });
}

ParseDataArray() [1/2]

auto ParseDataArray

(

std::istream &

stream

)

ParseDataArray() [2/2]

auto ParseDataArray	(	std::istream &	stream,
		const float &	quantizationScale,
		const int32_t &	quantizationOffset
	)

ParseDataArray< armnn::DataType::Float32 >()

auto ParseDataArray< armnn::DataType::Float32 >

(

std::istream &

stream

)

Definition at line 31 of file NetworkExecutionUtils.cpp.

{
    return ParseArrayImpl<float>(stream, [](const std::string& s) { return std::stof(s); });
}

ParseDataArray< armnn::DataType::QAsymmS8 >() [1/2]

auto ParseDataArray< armnn::DataType::QAsymmS8 >

(

std::istream &

stream

)

Definition at line 43 of file NetworkExecutionUtils.cpp.

References armnn::numeric_cast().

{
    return ParseArrayImpl<int8_t>(stream,
                                  [](const std::string& s) { return armnn::numeric_cast<int8_t>(std::stoi(s)); });
}

ParseDataArray< armnn::DataType::QAsymmS8 >() [2/2]

auto ParseDataArray< armnn::DataType::QAsymmS8 >	(	std::istream &	stream,
		const float &	quantizationScale,
		const int32_t &	quantizationOffset
	)

Definition at line 65 of file NetworkExecutionUtils.cpp.

References armnn::numeric_cast().

{
    return ParseArrayImpl<int8_t>(stream,
                                  [&quantizationScale, &quantizationOffset](const std::string& s)
                                  {
                                      return armnn::numeric_cast<int8_t>(
                                              armnn::Quantize<int8_t>(std::stof(s),
                                                                      quantizationScale,
                                                                      quantizationOffset));
                                  });
}

ParseDataArray< armnn::DataType::QAsymmU8 >() [1/2]

auto ParseDataArray< armnn::DataType::QAsymmU8 >

(

std::istream &

stream

)

Definition at line 50 of file NetworkExecutionUtils.cpp.

References armnn::numeric_cast().

{
    return ParseArrayImpl<uint8_t>(stream,
                                   [](const std::string& s) { return armnn::numeric_cast<uint8_t>(std::stoi(s)); });
}

ParseDataArray< armnn::DataType::QAsymmU8 >() [2/2]

auto ParseDataArray< armnn::DataType::QAsymmU8 >	(	std::istream &	stream,
		const float &	quantizationScale,
		const int32_t &	quantizationOffset
	)

Definition at line 80 of file NetworkExecutionUtils.cpp.

References armnn::numeric_cast().

{
    return ParseArrayImpl<uint8_t>(stream,
                                   [&quantizationScale, &quantizationOffset](const std::string& s)
                                   {
                                       return armnn::numeric_cast<uint8_t>(
                                               armnn::Quantize<uint8_t>(std::stof(s),
                                                                        quantizationScale,
                                                                        quantizationOffset));
                                   });
}

ParseDataArray< armnn::DataType::QSymmS8 >()

auto ParseDataArray< armnn::DataType::QSymmS8 >

(

std::istream &

stream

)

Definition at line 58 of file NetworkExecutionUtils.cpp.

References armnn::numeric_cast().

{
    return ParseArrayImpl<int8_t>(stream,
                                   [](const std::string& s) { return armnn::numeric_cast<int8_t>(std::stoi(s)); });
}

ParseDataArray< armnn::DataType::Signed32 >()

auto ParseDataArray< armnn::DataType::Signed32 >

(

std::istream &

stream

)

Definition at line 37 of file NetworkExecutionUtils.cpp.

{
    return ParseArrayImpl<int>(stream, [](const std::string& s) { return std::stoi(s); });
}

ParseStringList()

std::vector<std::string> ParseStringList	(	const std::string &	inputString,
		const char *	delimiter
	)

Splits a given string at every accurance of delimiter into a vector of string.

Definition at line 108 of file NetworkExecutionUtils.cpp.

References armnn::stringUtils::StringTrimCopy().

Referenced by GetBackendIDs(), and ProgramOptions::ParseOptions().

{
    std::stringstream stream(inputString);
    return ParseArrayImpl<std::string>(stream, [](const std::string& s) {
        return armnn::stringUtils::StringTrimCopy(s); }, delimiter);
}

PopulateTensorWithData()

void PopulateTensorWithData	(	TContainer &	tensorData,
		unsigned int	numElements,
		const std::string &	dataTypeStr,
		const armnn::Optional< QuantizationParams > &	qParams,
		const armnn::Optional< std::string > &	dataFile
	)

Definition at line 210 of file NetworkExecutionUtils.cpp.

References ARMNN_LOG, OptionalBase::has_value(), OptionalReferenceSwitch< std::is_reference< T >::value, T >::value(), and OptionalReferenceSwitch< IsReference, T >::value().

Referenced by MainImpl().

{
    const bool readFromFile = dataFile.has_value() && !dataFile.value().empty();
    const bool quantizeData = qParams.has_value();

    std::ifstream inputTensorFile;
    if (readFromFile)
    {
        inputTensorFile = std::ifstream(dataFile.value());
    }

    if (dataTypeStr.compare("float") == 0)
    {
        if (quantizeData)
        {
            const float qScale  = qParams.value().first;
            const int   qOffset = qParams.value().second;

            tensorData = readFromFile ?
                         ParseDataArray<armnn::DataType::QAsymmU8>(inputTensorFile, qScale, qOffset) :
                         GenerateDummyTensorData<armnn::DataType::QAsymmU8>(numElements);
        }
        else
        {
            tensorData = readFromFile ?
                         ParseDataArray<armnn::DataType::Float32>(inputTensorFile) :
                         GenerateDummyTensorData<armnn::DataType::Float32>(numElements);
        }
    }
    else if (dataTypeStr.compare("int") == 0)
    {
        tensorData = readFromFile ?
                     ParseDataArray<armnn::DataType::Signed32>(inputTensorFile) :
                     GenerateDummyTensorData<armnn::DataType::Signed32>(numElements);
    }
    else if (dataTypeStr.compare("qsymms8") == 0)
    {
        tensorData = readFromFile ?
                     ParseDataArray<armnn::DataType::QSymmS8>(inputTensorFile) :
                     GenerateDummyTensorData<armnn::DataType::QSymmS8>(numElements);
    }
    else if (dataTypeStr.compare("qasymm8") == 0 || dataTypeStr.compare("qasymmu8") == 0)
    {
        tensorData = readFromFile ?
                     ParseDataArray<armnn::DataType::QAsymmU8>(inputTensorFile) :
                     GenerateDummyTensorData<armnn::DataType::QAsymmU8>(numElements);
    }
    else if (dataTypeStr.compare("qasymms8") == 0)
    {
        tensorData = readFromFile ?
                     ParseDataArray<armnn::DataType::QAsymmS8>(inputTensorFile) :
                     GenerateDummyTensorData<armnn::DataType::QAsymmS8>(numElements);
    }
    else
    {
        std::string errorMessage = "Unsupported tensor data type " + dataTypeStr;
        ARMNN_LOG(fatal) << errorMessage;

        inputTensorFile.close();
        throw armnn::Exception(errorMessage);
    }

    inputTensorFile.close();
}

ValidatePath()

bool ValidatePath	(	const std::string &	file,
		const bool	expectFile
	)

Verifies if the given string is a valid path.

Reports invalid paths to std::err.

Parameters

file	string - A string containing the path to check
expectFile	bool - If true, checks for a regular file.

Returns

bool - True if given string is a valid path., false otherwise.

Definition at line 279 of file NetworkExecutionUtils.cpp.

Referenced by CheckClTuningParameter(), and ValidatePaths().

{
    if (!fs::exists(file))
    {
        std::cerr << "Given file path '" << file << "' does not exist" << std::endl;
        return false;
    }
    if (!fs::is_regular_file(file) && expectFile)
    {
        std::cerr << "Given file path '" << file << "' is not a regular file" << std::endl;
        return false;
    }
    return true;
}

ValidatePaths()

bool ValidatePaths	(	const std::vector< std::string > &	fileVec,
		const bool	expectFile
	)

Verifies if a given vector of strings are valid paths.

Reports invalid paths to std::err.

Parameters

fileVec	vector of string - A vector of string containing the paths to check
expectFile	bool - If true, checks for a regular file.

Returns

bool - True if all given strings are valid paths., false otherwise.

Definition at line 294 of file NetworkExecutionUtils.cpp.

References ValidatePath().

Referenced by ExecuteNetworkParams::ValidateParams().

{
    bool allPathsValid = true;
    for (auto const& file : fileVec)
    {
        if(!ValidatePath(file, expectFile))
        {
            allPathsValid = false;
        }
    }
    return allPathsValid;
}