ExecuteNetworkProgramOptions.cpp File Reference

#include "ExecuteNetworkProgramOptions.hpp"
#include "NetworkExecutionUtils/NetworkExecutionUtils.hpp"
#include "InferenceTest.hpp"
#include <armnn/BackendRegistry.hpp>
#include <armnn/Exceptions.hpp>
#include <armnn/utility/Assert.hpp>
#include <armnn/utility/StringUtils.hpp>
#include <armnn/Logging.hpp>
#include <fmt/format.h>

Go to the source code of this file.

Functions
bool	CheckOption (const cxxopts::ParseResult &result, const char *option)
void	CheckOptionDependency (const cxxopts::ParseResult &result, const char *option, const char *required)
void	CheckOptionDependencies (const cxxopts::ParseResult &result)
void	RemoveDuplicateDevices (std::vector< armnn::BackendId > &computeDevices)
std::vector< armnn::BackendId >	GetBackendIDs (const std::vector< std::string > &backendStringsVec)
	Takes a vector of backend strings and returns a vector of backendIDs. More...
template<typename optionType >
optionType	GetOptionValue (std::string &&optionName, const cxxopts::ParseResult &result)
	Provides a segfault safe way to get cxxopts option values by checking if the option was defined. More...
void	LogAndThrowFatal (std::string errorMessage)
void	CheckRequiredOptions (const cxxopts::ParseResult &result)
void	CheckForDeprecatedOptions (const cxxopts::ParseResult &result)

Function Documentation

CheckForDeprecatedOptions()

void CheckForDeprecatedOptions

(

const cxxopts::ParseResult &

result

)

Definition at line 142 of file ExecuteNetworkProgramOptions.cpp.

References ARMNN_LOG.

Referenced by ProgramOptions::ParseOptions().

{
    if(result.count("simultaneous-iterations") > 0)
    {
        ARMNN_LOG(warning) << "DEPRECATED: The program option 'simultaneous-iterations' is deprecated and will be "
                              "removed soon. Please use the option 'iterations' combined with 'concurrent' instead.";
    }
    if(result.count("armnn-tflite-delegate") > 0)
    {
        ARMNN_LOG(warning) << "DEPRECATED: The program option 'armnn-tflite-delegate' is deprecated and will be "
                              "removed soon. Please use the option 'tflite-executor' instead.";
    }
}

CheckOption()

bool CheckOption	(	const cxxopts::ParseResult &	result,
		const char *	option
	)

Definition at line 18 of file ExecuteNetworkProgramOptions.cpp.

Referenced by CheckOptionDependency().

{
    // Check that the given option is valid.
    if (option == nullptr)
    {
        return false;
    }

    // Check whether 'option' is provided.
    return ((result.count(option)) ? true : false);
}

CheckOptionDependencies()

void CheckOptionDependencies

(

const cxxopts::ParseResult &

result

)

Definition at line 52 of file ExecuteNetworkProgramOptions.cpp.

References CheckOptionDependency().

Referenced by ProgramOptions::ParseOptions().

{
    CheckOptionDependency(result, "model-path", "model-format");
    CheckOptionDependency(result, "input-tensor-shape", "model-path");
    CheckOptionDependency(result, "tuning-level", "tuning-path");
}

CheckOptionDependency()

void CheckOptionDependency	(	const cxxopts::ParseResult &	result,
		const char *	option,
		const char *	required
	)

Definition at line 31 of file ExecuteNetworkProgramOptions.cpp.

References CheckOption().

Referenced by CheckOptionDependencies().

{
    // Check that the given options are valid.
    if (option == nullptr || required == nullptr)
    {
        throw cxxopts::OptionParseException("Invalid option to check dependency for");
    }

    // Check that if 'option' is provided, 'required' is also provided.
    if (CheckOption(result, option) && !result[option].has_default())
    {
        if (CheckOption(result, required) == 0 || result[required].has_default())
        {
            throw cxxopts::OptionParseException(
                    std::string("Option '") + option + "' requires option '" + required + "'.");
        }
    }
}

CheckRequiredOptions()

void CheckRequiredOptions

(

const cxxopts::ParseResult &

result

)

Definition at line 117 of file ExecuteNetworkProgramOptions.cpp.

References ARMNN_LOG.

Referenced by ProgramOptions::ParseOptions().

{

    // For each option in option-group "a) Required
    std::vector<std::string> requiredOptions{"compute",
                                             "model-format",
                                             "model-path",
                                             "input-name",
                                             "output-name"};

    bool requiredMissing = false;
    for(auto const&  str : requiredOptions)
    {
        if(!(result.count(str) > 0))
        {
            ARMNN_LOG(error) << fmt::format("The program option '{}' is mandatory but wasn't provided.", str);
            requiredMissing = true;
        }
    }
    if(requiredMissing)
    {
        throw armnn::InvalidArgumentException ("Some required arguments are missing");
    }
}

GetBackendIDs()

std::vector<armnn::BackendId> GetBackendIDs

(

const std::vector< std::string > &

backendStringsVec

)

Takes a vector of backend strings and returns a vector of backendIDs.

Removes duplicate entries. Can handle backend strings that contain multiple backends separated by comma e.g "CpuRef,CpuAcc"

Definition at line 81 of file ExecuteNetworkProgramOptions.cpp.

References ParseStringList(), and RemoveDuplicateDevices().

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

{
    std::vector<armnn::BackendId> backendIDs;
    for (const auto& backendStrings : backendStringsVec)
    {
        // Each backendStrings might contain multiple backends separated by comma e.g "CpuRef,CpuAcc"
        std::vector<std::string> backendStringVec = ParseStringList(backendStrings, ",");
        for (const auto& b : backendStringVec)
        {
            backendIDs.push_back(armnn::BackendId(b));
        }
    }

    RemoveDuplicateDevices(backendIDs);

    return backendIDs;
}

GetOptionValue()

optionType GetOptionValue	(	std::string &&	optionName,
		const cxxopts::ParseResult &	result
	)

Provides a segfault safe way to get cxxopts option values by checking if the option was defined.

If the option wasn't defined it returns an empty object.

Definition at line 102 of file ExecuteNetworkProgramOptions.cpp.

{
    optionType out;
    if(result.count(optionName))
    {
        out = result[optionName].as<optionType>();
    }
    return out;
}

LogAndThrowFatal()

void LogAndThrowFatal

(

std::string

errorMessage

)

Definition at line 112 of file ExecuteNetworkProgramOptions.cpp.

Referenced by ProgramOptions::ValidateRuntimeOptions().

{
    throw armnn::InvalidArgumentException (errorMessage);
}

RemoveDuplicateDevices()

void RemoveDuplicateDevices

(

std::vector< armnn::BackendId > &

computeDevices

)

Definition at line 59 of file ExecuteNetworkProgramOptions.cpp.

References armnn::Undefined.

Referenced by GetBackendIDs().

{
    // Mark the duplicate devices as 'Undefined'.
    for (auto i = computeDevices.begin(); i != computeDevices.end(); ++i)
    {
        for (auto j = std::next(i); j != computeDevices.end(); ++j)
        {
            if (*j == *i)
            {
                *j = armnn::Compute::Undefined;
            }
        }
    }

    // Remove 'Undefined' devices.
    computeDevices.erase(std::remove(computeDevices.begin(), computeDevices.end(), armnn::Compute::Undefined),
                         computeDevices.end());
}