NetworkExecutionUtils.hpp File Reference

#include <armnn/IRuntime.hpp>
#include <armnn/Types.hpp>
#include <armnn/Logging.hpp>
#include <armnn/utility/StringUtils.hpp>
#include <mapbox/variant.hpp>
#include <iostream>
#include <fstream>

Go to the source code of this file.

Classes
struct	TensorPrinter

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
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...
template<typename T , typename TParseElementFunc >
std::vector< T >	ParseArrayImpl (std::istream &stream, TParseElementFunc parseElementFunc, const char *chars="\,:")
template<typename T , typename TParseElementFunc >
void	PopulateTensorWithDataGeneric (std::vector< T > &tensorData, unsigned int numElements, const armnn::Optional< std::string > &dataFile, TParseElementFunc parseFunction)

Typedef Documentation

QuantizationParams

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

Definition at line 55 of file NetworkExecutionUtils.hpp.

TContainer

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

Definition at line 54 of file NetworkExecutionUtils.hpp.

Function Documentation

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)); });
}

ParseArrayImpl()

std::vector<T> ParseArrayImpl	(	std::istream &	stream,
		TParseElementFunc	parseElementFunc,
		const char *	chars = "\t ,:"
	)

Definition at line 80 of file NetworkExecutionUtils.hpp.

References ARMNN_LOG, and armnn::stringUtils::StringTokenizer().

                                                                                                             :")
{
    std::vector<T> result;
    // Processes line-by-line.
    std::string line;
    while (std::getline(stream, line))
    {
        std::vector<std::string> tokens = armnn::stringUtils::StringTokenizer(line, chars);
        for (const std::string& token : tokens)
        {
            if (!token.empty()) // See https://stackoverflow.com/questions/10437406/
            {
                try
                {
                    result.push_back(parseElementFunc(token));
                }
                catch (const std::exception&)
                {
                    ARMNN_LOG(error) << "'" << token << "' is not a valid number. It has been ignored.";
                }
            }
        }
    }

    return result;
}

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();
}

PopulateTensorWithDataGeneric()

void PopulateTensorWithDataGeneric	(	std::vector< T > &	tensorData,
		unsigned int	numElements,
		const armnn::Optional< std::string > &	dataFile,
		TParseElementFunc	parseFunction
	)

Definition at line 108 of file NetworkExecutionUtils.hpp.

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

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

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

    tensorData = readFromFile ?
                 ParseArrayImpl<T>(inputTensorFile, parseFunction) :
                 std::vector<T>(numElements, static_cast<T>(0));
}

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;
}