ExecuteNetworkProgramOptions.cpp File Reference

#include "ExecuteNetworkProgramOptions.hpp"
#include "NetworkExecutionUtils/NetworkExecutionUtils.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 137 of file ExecuteNetworkProgramOptions.cpp.

References ARMNN_LOG.

Referenced by ProgramOptions::ParseOptions().

{
    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.";
    }
    if(result.count("concurrent") > 0)
    {
        ARMNN_LOG(warning) << "DEPRECATED: The program option 'concurrent' is deprecated and will be "
                              "removed soon. Please use the option '\"P, thread-pool-size\"' instead.";
    }
    if(result.count("input-type") > 0)
    {
        ARMNN_LOG(warning) << "DEPRECATED: The program option 'input-type' is deprecated and will be "
                              "removed soon. The input-types are now automatically set.";
    }
    if(result.count("input-name") > 0)
    {
        ARMNN_LOG(warning) << "DEPRECATED: The program option 'input-name' is deprecated and will be "
                              "removed soon. The input-names are now automatically set.";
    }
    if(result.count("output-type") > 0)
    {
        ARMNN_LOG(warning) << "DEPRECATED: The program option 'output-type' is deprecated and will be "
                              "removed soon. The output-types are now automatically set.";
    }
    if(result.count("output-name") > 0)
    {
        ARMNN_LOG(warning) << "DEPRECATED: The program option 'output-name' is deprecated and will be "
                              "removed soon. The output-names are now automatically set.";
    }
    if(result.count("model-format") > 0)
    {
        ARMNN_LOG(warning) << "DEPRECATED: The program option 'model-format' is deprecated and will be "
                              "removed soon. The model-format is now automatically set.";
    }

}

CheckOption()

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

Definition at line 17 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 51 of file ExecuteNetworkProgramOptions.cpp.

References CheckOptionDependency().

Referenced by ProgramOptions::ParseOptions().

{
    CheckOptionDependency(result, "tuning-level", "tuning-path");
}

CheckOptionDependency()

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

Definition at line 30 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 114 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-path"
                                             };

    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 78 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 99 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 109 of file ExecuteNetworkProgramOptions.cpp.

Referenced by ProgramOptions::ValidateRuntimeOptions().

{
    throw armnn::InvalidArgumentException (errorMessage);
}

RemoveDuplicateDevices()

void RemoveDuplicateDevices

(

std::vector< armnn::BackendId > &

computeDevices

)

Definition at line 56 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());
}