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 > &backendStrings)
	Takes a vector of backend strings and returns a vector of backendIDs. Removes duplicate entries. 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)

Function Documentation

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 110 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 > &

backendStrings

)

Takes a vector of backend strings and returns a vector of backendIDs. Removes duplicate entries.

Definition at line 79 of file ExecuteNetworkProgramOptions.cpp.

References RemoveDuplicateDevices().

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

{
    std::vector<armnn::BackendId> backendIDs;
    for (const auto& b : backendStrings)
    {
        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 95 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 105 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());
}