arm_compute::test::framework Namespace Reference

Namespaces
	dataset
	detail

Data Structures
class	CommonOptions
	Common command line options used to configure the framework. More...
class	DataTestCase
	Data test case class. More...
class	DataTestCaseFactory
	Implementation of a test case factory to create data test cases. More...
class	FileNotFound
	Error class for when some external assets are missing. More...
class	Fixture
	Abstract fixture class. More...
class	Framework
	Main framework class. More...
struct	FrameworkConfig
	Framework configuration structure. More...
class	Instrument
	Interface for classes that can be used to measure performance. More...
struct	InstrumentsInfo
class	InstrumentsStats
	Generate common statistics for a set of measurements. More...
class	ISchedulerUser
	Scheduler user interface. More...
class	JSONPrinter
	Implementation of a Printer that produces JSON output. More...
class	MaliCounter
	Instrument implementation for mali hw counters. More...
struct	Measurement
	Generic measurement that stores values as either double or long long int. More...
class	OpenCLClock
	Instrument creating measurements based on the information returned by clGetEventProfilingInfo for each OpenCL kernel executed. More...
class	OpenCLMemoryUsage
	Instrument collecting memory usage information for OpenCL. More...
class	PMU
	Class provides access to CPU hardware counters. More...
class	PMUCounter
	Implementation of an instrument to count CPU cycles. More...
class	PrettyPrinter
	Implementation of a Printer that produces human readable output. More...
class	Printer
	Abstract printer class used by the Framework to present output. More...
class	Profiler
	Profiler class to collect benchmark numbers. More...
class	SchedulerClock
	Instrument creating measurements based on the information returned by clGetEventProfilingInfo for each OpenCL kernel executed. More...
class	SimpleTestCaseFactory
	Implementation of a test case factory to create non-data test cases. More...
class	TestCase
	Abstract test case class. More...
class	TestCaseFactory
	Abstract factory class to create test cases. More...
class	TestError
	Error class for failures during test execution. More...
class	TestFilter
	Test filter class. More...
struct	TestInfo
	Information about a test case. More...
struct	TestResult
	Class to store results of a test. More...
class	WallClock
	Implementation of an instrument to measure elapsed wall-clock time in milliseconds. More...

Typedefs
using	InstrumentsDescription = std::pair< InstrumentType, ScaleFactor >
using	OpenCLTimer = OpenCLClock< false >
using	OpenCLTimestamps = OpenCLClock< true >
using	SchedulerTimer = SchedulerClock< false >
using	SchedulerTimestamps = SchedulerClock< true >
using	WallClockTimer = WallClock< false >
using	WallClockTimestamps = WallClock< true >

Enumerations
enum	DatasetMode : unsigned int { ALL = ~0U, DISABLED = 0, PRECOMMIT = 1, NIGHTLY = 2 }
	Possible dataset modes. More...
enum	LogLevel {   NONE, CONFIG, TESTS, ERRORS,   DEBUG, MEASUREMENTS, ALL }
	Severity of the information. More...
enum	ScaleFactor : unsigned int {   NONE, SCALE_1K, SCALE_1M, TIME_US,   TIME_MS, TIME_S }
enum	InstrumentType : unsigned int {   ALL = ~0U, NONE = 0, WALL_CLOCK_TIMER = 0x0100, PMU = 0x0200,   PMU_CYCLE_COUNTER = 0x0201, PMU_INSTRUCTION_COUNTER = 0x0202, MALI = 0x0300, OPENCL_TIMER = 0x0400,   SCHEDULER_TIMER = 0x0500, OPENCL_MEMORY_USAGE = 0x0600, WALL_CLOCK_TIMESTAMPS = 0x0700, OPENCL_TIMESTAMPS = 0x0800,   SCHEDULER_TIMESTAMPS = 0x0900 }
enum	LogFormat { NONE, JSON, PRETTY }

Functions
int	make_printable (int8_t value)
std::string	make_printable (const arm_compute::WeightFormat wf)
unsigned int	make_printable (uint8_t value)
template<typename T >
T	make_printable (T &&value)
void	ARM_COMPUTE_PRINT_INFO ()
DatasetMode	dataset_mode_from_name (const std::string &name)
DatasetMode	operator & (DatasetMode t1, DatasetMode t2)
DatasetMode	operator| (DatasetMode t1, DatasetMode t2)
DatasetMode &	operator|= (DatasetMode &t1, DatasetMode t2)
inline ::std::istream &	operator>> (::std::istream &stream, DatasetMode &mode)
inline ::std::ostream &	operator<< (::std::ostream &stream, DatasetMode mode)
std::string	to_string (DatasetMode mode)
LogLevel	log_level_from_name (const std::string &name)
::std::istream &	operator>> (::std::istream &stream, LogLevel &level)
::std::ostream &	operator<< (::std::ostream &stream, LogLevel level)
std::string	to_string (LogLevel level)
bool	operator< (const TestInfo &lhs, const TestInfo &rhs)
InstrumentsDescription	instrument_type_from_name (const std::string &name)
inline ::std::stringstream &	operator>> (::std::stringstream &stream, InstrumentsDescription &instrument)
inline ::std::stringstream &	operator<< (::std::stringstream &stream, InstrumentsDescription instrument)
LogFormat	log_format_from_name (const std::string &name)
inline ::std::stringstream &	operator>> (::std::stringstream &stream, LogFormat &format)
inline ::std::stringstream &	operator<< (::std::stringstream &stream, LogFormat format)
inline ::std::ostream &	operator<< (::std::ostream &stream, TestCaseFactory::Status status)
void	sleep_in_seconds (float seconds)
	Makes the calling thread to sleep for a specified number of seconds. More...
template<typename O , typename F , typename... As, int... S>
void	apply_impl (O *obj, F &&func, const std::tuple< As... > &args, detail::sequence< S... >)

Variables
std::unique_ptr< InstrumentsInfo >	instruments_info

Typedef Documentation

InstrumentsDescription

using InstrumentsDescription = std::pair<InstrumentType, ScaleFactor>

Definition at line 69 of file Instruments.h.

OpenCLTimer

using OpenCLTimer = OpenCLClock<false>

Definition at line 81 of file OpenCLTimer.h.

OpenCLTimestamps

using OpenCLTimestamps = OpenCLClock<true>

Definition at line 82 of file OpenCLTimer.h.

SchedulerTimer

using SchedulerTimer = SchedulerClock<false>

Definition at line 112 of file SchedulerTimer.h.

SchedulerTimestamps

using SchedulerTimestamps = SchedulerClock<true>

Definition at line 113 of file SchedulerTimer.h.

WallClockTimer

using WallClockTimer = WallClock<false>

Definition at line 83 of file WallClockTimer.h.

WallClockTimestamps

using WallClockTimestamps = WallClock<true>

Definition at line 84 of file WallClockTimer.h.

Enumeration Type Documentation

DatasetMode

enum DatasetMode : unsigned int

strong

Possible dataset modes.

Enumerator
ALL
DISABLED
PRECOMMIT
NIGHTLY

Definition at line 40 of file DatasetModes.h.

                       : unsigned int
{
    ALL       = ~0U,
    DISABLED  = 0,
    PRECOMMIT = 1,
    NIGHTLY   = 2
};

InstrumentType

enum InstrumentType : unsigned int

strong

Enumerator
ALL
NONE
WALL_CLOCK_TIMER
PMU
PMU_CYCLE_COUNTER
PMU_INSTRUCTION_COUNTER
MALI
OPENCL_TIMER
SCHEDULER_TIMER
OPENCL_MEMORY_USAGE
WALL_CLOCK_TIMESTAMPS
OPENCL_TIMESTAMPS
SCHEDULER_TIMESTAMPS

Definition at line 46 of file Instruments.h.

                          : unsigned int
{
    ALL                     = ~0U,
    NONE                    = 0,
    WALL_CLOCK_TIMER        = 0x0100,
    PMU                     = 0x0200,
    PMU_CYCLE_COUNTER       = 0x0201,
    PMU_INSTRUCTION_COUNTER = 0x0202,
    MALI                    = 0x0300,
    OPENCL_TIMER            = 0x0400,
    SCHEDULER_TIMER         = 0x0500,
    OPENCL_MEMORY_USAGE     = 0x0600,
    WALL_CLOCK_TIMESTAMPS   = 0x0700,
    OPENCL_TIMESTAMPS       = 0x0800,
    SCHEDULER_TIMESTAMPS    = 0x0900,
};

LogFormat

enum LogFormat

strong

Enumerator
NONE
JSON
PRETTY

Definition at line 36 of file Printers.h.

{
    NONE,
    JSON,
    PRETTY
};

LogLevel

enum LogLevel

strong

Severity of the information.

Each category includes the ones above it.

NONE == Only for filtering. Not used to tag information. CONFIG == Configuration info. TESTS == Information about the tests. ERRORS == Violated assertions/expectations. DEBUG == More violated assertions/expectations. MEASUREMENTS == Information about measurements. ALL == Only for filtering. Not used to tag information.

Enumerator
NONE
CONFIG
TESTS
ERRORS
DEBUG
MEASUREMENTS
ALL

Definition at line 50 of file Exceptions.h.

{
    NONE,
    CONFIG,
    TESTS,
    ERRORS,
    DEBUG,
    MEASUREMENTS,
    ALL,
};

ScaleFactor

enum ScaleFactor : unsigned int

strong

Enumerator
NONE
SCALE_1K
SCALE_1M
TIME_US
TIME_MS
TIME_S

Definition at line 40 of file Instrument.h.

                       : unsigned int
{
    NONE,     /* Default scale */
    SCALE_1K, /* 1000          */
    SCALE_1M, /* 1 000 000     */
    TIME_US,  /* Microseconds  */
    TIME_MS,  /* Milliseconds  */
    TIME_S,   /* Seconds       */
};

Function Documentation

apply_impl()

void arm_compute::test::framework::apply_impl	(	O *	obj,
		F &&	func,
		const std::tuple< As... > &	args,
		detail::sequence< S... >
	)

Definition at line 72 of file Utils.h.

Referenced by arm_compute::test::apply().

{
    (obj->*func)(std::get<S>(args)...);
}

ARM_COMPUTE_PRINT_INFO()

void arm_compute::test::framework::ARM_COMPUTE_PRINT_INFO ( )

inline

Definition at line 64 of file Asserts.h.

References Framework::clear_test_info(), Framework::get(), Framework::log_info(), and Framework::print_test_info().

Referenced by arm_compute::test::validation::combine(), arm_compute::test::validation::FIXTURE_DATA_TEST_CASE(), arm_compute::test::validation::FIXTURE_DATA_TEST_CASE_NEW(), arm_compute::test::validation::validate(), and arm_compute::test::validation::validate_wrap().

{
    std::stringstream msg;
    arm_compute::test::framework::Framework::get().print_test_info(msg);
    arm_compute::test::framework::Framework::get().log_info(msg.str());
    arm_compute::test::framework::Framework::get().clear_test_info();
}

dataset_mode_from_name()

DatasetMode dataset_mode_from_name

(

const std::string &

name

)

Definition at line 36 of file DatasetModes.cpp.

References ALL, DISABLED, NIGHTLY, PRECOMMIT, and arm_compute::test::tolower().

Referenced by operator>>(), and operator|=().

{
    static const std::map<std::string, DatasetMode> modes =
    {
        { "all", DatasetMode::ALL },
        { "disabled", DatasetMode::DISABLED },
        { "precommit", DatasetMode::PRECOMMIT },
        { "nightly", DatasetMode::NIGHTLY },
    };

    try
    {
        return modes.at(tolower(name));
    }
    catch(const std::out_of_range &)
    {
        throw std::invalid_argument(name);
    }
}

instrument_type_from_name()

InstrumentsDescription instrument_type_from_name

(

const std::string &

name

)

Definition at line 37 of file Instruments.cpp.

References ALL, MALI, NONE, OPENCL_MEMORY_USAGE, OPENCL_TIMER, OPENCL_TIMESTAMPS, PMU, PMU_CYCLE_COUNTER, PMU_INSTRUCTION_COUNTER, SCALE_1K, SCALE_1M, SCHEDULER_TIMER, SCHEDULER_TIMESTAMPS, TIME_MS, TIME_S, TIME_US, arm_compute::test::tolower(), WALL_CLOCK_TIMER, and WALL_CLOCK_TIMESTAMPS.

Referenced by operator>>().

{
    static const std::map<std::string, framework::InstrumentsDescription> types =
    {
        { "all", std::pair<InstrumentType, ScaleFactor>(InstrumentType::ALL, ScaleFactor::NONE) },
        { "none", std::pair<InstrumentType, ScaleFactor>(InstrumentType::NONE, ScaleFactor::NONE) },
        { "wall_clock", std::pair<InstrumentType, ScaleFactor>(InstrumentType::WALL_CLOCK_TIMER, ScaleFactor::NONE) },
        { "wall_clock_timer", std::pair<InstrumentType, ScaleFactor>(InstrumentType::WALL_CLOCK_TIMER, ScaleFactor::NONE) },
        { "wall_clock_timer_ms", std::pair<InstrumentType, ScaleFactor>(InstrumentType::WALL_CLOCK_TIMER, ScaleFactor::TIME_MS) },
        { "wall_clock_timer_s", std::pair<InstrumentType, ScaleFactor>(InstrumentType::WALL_CLOCK_TIMER, ScaleFactor::TIME_S) },
        { "wall_clock_timestamps", std::pair<InstrumentType, ScaleFactor>(InstrumentType::WALL_CLOCK_TIMESTAMPS, ScaleFactor::NONE) },
        { "wall_clock_timestamps_ms", std::pair<InstrumentType, ScaleFactor>(InstrumentType::WALL_CLOCK_TIMESTAMPS, ScaleFactor::TIME_MS) },
        { "wall_clock_timestamps_s", std::pair<InstrumentType, ScaleFactor>(InstrumentType::WALL_CLOCK_TIMESTAMPS, ScaleFactor::TIME_S) },
        { "scheduler_timestamps", std::pair<InstrumentType, ScaleFactor>(InstrumentType::SCHEDULER_TIMESTAMPS, ScaleFactor::NONE) },
        { "scheduler_timestamps_ms", std::pair<InstrumentType, ScaleFactor>(InstrumentType::SCHEDULER_TIMESTAMPS, ScaleFactor::TIME_MS) },
        { "scheduler_timestamps_s", std::pair<InstrumentType, ScaleFactor>(InstrumentType::SCHEDULER_TIMESTAMPS, ScaleFactor::TIME_S) },
        { "scheduler_timer", std::pair<InstrumentType, ScaleFactor>(InstrumentType::SCHEDULER_TIMER, ScaleFactor::NONE) },
        { "scheduler_timer_ms", std::pair<InstrumentType, ScaleFactor>(InstrumentType::SCHEDULER_TIMER, ScaleFactor::TIME_MS) },
        { "scheduler_timer_s", std::pair<InstrumentType, ScaleFactor>(InstrumentType::SCHEDULER_TIMER, ScaleFactor::TIME_S) },
        { "pmu", std::pair<InstrumentType, ScaleFactor>(InstrumentType::PMU, ScaleFactor::NONE) },
        { "pmu_k", std::pair<InstrumentType, ScaleFactor>(InstrumentType::PMU, ScaleFactor::SCALE_1K) },
        { "pmu_m", std::pair<InstrumentType, ScaleFactor>(InstrumentType::PMU, ScaleFactor::SCALE_1M) },
        { "pmu_cycles", std::pair<InstrumentType, ScaleFactor>(InstrumentType::PMU_CYCLE_COUNTER, ScaleFactor::NONE) },
        { "pmu_instructions", std::pair<InstrumentType, ScaleFactor>(InstrumentType::PMU_INSTRUCTION_COUNTER, ScaleFactor::NONE) },
        { "mali", std::pair<InstrumentType, ScaleFactor>(InstrumentType::MALI, ScaleFactor::NONE) },
        { "mali_k", std::pair<InstrumentType, ScaleFactor>(InstrumentType::MALI, ScaleFactor::SCALE_1K) },
        { "mali_m", std::pair<InstrumentType, ScaleFactor>(InstrumentType::MALI, ScaleFactor::SCALE_1M) },
        { "opencl_timestamps", std::pair<InstrumentType, ScaleFactor>(InstrumentType::OPENCL_TIMESTAMPS, ScaleFactor::NONE) },
        { "opencl_timestamps_us", std::pair<InstrumentType, ScaleFactor>(InstrumentType::OPENCL_TIMESTAMPS, ScaleFactor::TIME_US) },
        { "opencl_timestamps_ms", std::pair<InstrumentType, ScaleFactor>(InstrumentType::OPENCL_TIMESTAMPS, ScaleFactor::TIME_MS) },
        { "opencl_timestamps_s", std::pair<InstrumentType, ScaleFactor>(InstrumentType::OPENCL_TIMESTAMPS, ScaleFactor::TIME_S) },
        { "opencl_timer", std::pair<InstrumentType, ScaleFactor>(InstrumentType::OPENCL_TIMER, ScaleFactor::NONE) },
        { "opencl_timer_us", std::pair<InstrumentType, ScaleFactor>(InstrumentType::OPENCL_TIMER, ScaleFactor::TIME_US) },
        { "opencl_timer_ms", std::pair<InstrumentType, ScaleFactor>(InstrumentType::OPENCL_TIMER, ScaleFactor::TIME_MS) },
        { "opencl_timer_s", std::pair<InstrumentType, ScaleFactor>(InstrumentType::OPENCL_TIMER, ScaleFactor::TIME_S) },
        { "opencl_memory_usage", std::pair<InstrumentType, ScaleFactor>(InstrumentType::OPENCL_MEMORY_USAGE, ScaleFactor::NONE) },
        { "opencl_memory_usage_k", std::pair<InstrumentType, ScaleFactor>(InstrumentType::OPENCL_MEMORY_USAGE, ScaleFactor::SCALE_1K) },
        { "opencl_memory_usage_m", std::pair<InstrumentType, ScaleFactor>(InstrumentType::OPENCL_MEMORY_USAGE, ScaleFactor::SCALE_1M) },
    };

    try
    {
        return types.at(tolower(name));
    }
    catch(const std::out_of_range &)
    {
        throw std::invalid_argument(name);
    }
}

log_format_from_name()

LogFormat log_format_from_name

(

const std::string &

name

)

Definition at line 37 of file Printers.cpp.

References JSON, NONE, PRETTY, and arm_compute::test::tolower().

Referenced by operator>>().

{
    static const std::map<std::string, LogFormat> formats =
    {
        { "pretty", LogFormat::PRETTY },
        { "none", LogFormat::NONE },
        { "json", LogFormat::JSON },
    };

    try
    {
        return formats.at(tolower(name));
    }
    catch(const std::out_of_range &)
    {
        throw std::invalid_argument(name);
    }
}

log_level_from_name()

LogLevel log_level_from_name

(

const std::string &

name

)

Definition at line 37 of file Exceptions.cpp.

References ALL, CONFIG, DEBUG, ERRORS, MEASUREMENTS, NONE, TESTS, and arm_compute::test::tolower().

Referenced by operator>>().

{
    static const std::map<std::string, LogLevel> levels =
    {
        { "none", LogLevel::NONE },
        { "config", LogLevel::CONFIG },
        { "tests", LogLevel::TESTS },
        { "errors", LogLevel::ERRORS },
        { "debug", LogLevel::DEBUG },
        { "measurements", LogLevel::MEASUREMENTS },
        { "all", LogLevel::ALL },
    };

    try
    {
        return levels.at(tolower(name));
    }
    catch(const std::out_of_range &)
    {
        throw std::invalid_argument(name);
    }
}

make_printable() [1/4]

int arm_compute::test::framework::make_printable ( int8_t  value )

inline

Definition at line 42 of file Asserts.h.

Referenced by arm_compute::test::validation::validate(), and arm_compute::test::validation::validate_wrap().

{
    return value;
}

make_printable() [2/4]

std::string arm_compute::test::framework::make_printable ( const arm_compute::WeightFormat  wf )

inline

Definition at line 47 of file Asserts.h.

References arm_compute::to_string().

{
    return arm_compute::to_string(wf);
}

make_printable() [3/4]

unsigned int arm_compute::test::framework::make_printable ( uint8_t  value )

inline

Definition at line 52 of file Asserts.h.

{
    return value;
}

make_printable() [4/4]

T arm_compute::test::framework::make_printable ( T &&  value )

inline

Definition at line 59 of file Asserts.h.

{
    return value;
}

operator &()

DatasetMode arm_compute::test::framework::operator& ( DatasetMode  t1, DatasetMode  t2  )

inline

Definition at line 48 of file DatasetModes.h.

References type.

{
    using type = std::underlying_type<DatasetMode>::type;
    return static_cast<DatasetMode>(static_cast<type>(t1) & static_cast<type>(t2));
}

operator<()

bool arm_compute::test::framework::operator< ( const TestInfo &  lhs, const TestInfo &  rhs  )

inline

Definition at line 86 of file Framework.h.

References TestInfo::id.

{
    return lhs.id < rhs.id;
}

operator<<() [1/5]

inline ::std::stringstream& arm_compute::test::framework::operator<<	(	::std::stringstream &	stream,
		LogFormat	format
	)

Definition at line 53 of file Printers.h.

References JSON, NONE, and PRETTY.

{
    switch(format)
    {
        case LogFormat::PRETTY:
            stream << "PRETTY";
            break;
        case LogFormat::NONE:
            stream << "NONE";
            break;
        case LogFormat::JSON:
            stream << "JSON";
            break;
        default:
            throw std::invalid_argument("Unsupported log format");
    }

    return stream;
}

operator<<() [2/5]

std::ostream & operator<<	(	::std::ostream &	stream,
		LogLevel	level
	)

Definition at line 68 of file Exceptions.cpp.

References ALL, CONFIG, DEBUG, ERRORS, MEASUREMENTS, NONE, and TESTS.

{
    switch(level)
    {
        case LogLevel::NONE:
            stream << "NONE";
            break;
        case LogLevel::CONFIG:
            stream << "CONFIG";
            break;
        case LogLevel::TESTS:
            stream << "TESTS";
            break;
        case LogLevel::ERRORS:
            stream << "ERRORS";
            break;
        case LogLevel::DEBUG:
            stream << "DEBUG";
            break;
        case LogLevel::MEASUREMENTS:
            stream << "MEASUREMENTS";
            break;
        case LogLevel::ALL:
            stream << "ALL";
            break;
        default:
            throw std::invalid_argument("Unsupported log level");
    }

    return stream;
}

operator<<() [3/5]

inline ::std::ostream& arm_compute::test::framework::operator<<	(	::std::ostream &	stream,
		DatasetMode	mode
	)

Definition at line 77 of file DatasetModes.h.

References ALL, DISABLED, NIGHTLY, and PRECOMMIT.

{
    switch(mode)
    {
        case DatasetMode::DISABLED:
            stream << "DISABLED";
            break;
        case DatasetMode::PRECOMMIT:
            stream << "PRECOMMIT";
            break;
        case DatasetMode::NIGHTLY:
            stream << "NIGHTLY";
            break;
        case DatasetMode::ALL:
            stream << "ALL";
            break;
        default:
            throw std::invalid_argument("Unsupported dataset mode");
    }

    return stream;
}

operator<<() [4/5]

inline ::std::stringstream& arm_compute::test::framework::operator<<	(	::std::stringstream &	stream,
		InstrumentsDescription	instrument
	)

Definition at line 81 of file Instruments.h.

References ALL, MALI, NONE, OPENCL_MEMORY_USAGE, OPENCL_TIMER, OPENCL_TIMESTAMPS, PMU, PMU_CYCLE_COUNTER, PMU_INSTRUCTION_COUNTER, SCALE_1K, SCALE_1M, SCHEDULER_TIMER, SCHEDULER_TIMESTAMPS, TIME_MS, TIME_S, TIME_US, WALL_CLOCK_TIMER, and WALL_CLOCK_TIMESTAMPS.

{
    switch(instrument.first)
    {
        case InstrumentType::WALL_CLOCK_TIMESTAMPS:
            switch(instrument.second)
            {
                case ScaleFactor::NONE:
                    stream << "WALL_CLOCK_TIMESTAMPS";
                    break;
                case ScaleFactor::TIME_MS:
                    stream << "WALL_CLOCK_TIMESTAMPS_MS";
                    break;
                case ScaleFactor::TIME_S:
                    stream << "WALL_CLOCK_TIMESTAMPS_S";
                    break;
                default:
                    throw std::invalid_argument("Unsupported instrument scale");
            }
            break;
        case InstrumentType::WALL_CLOCK_TIMER:
            switch(instrument.second)
            {
                case ScaleFactor::NONE:
                    stream << "WALL_CLOCK_TIMER";
                    break;
                case ScaleFactor::TIME_MS:
                    stream << "WALL_CLOCK_TIMER_MS";
                    break;
                case ScaleFactor::TIME_S:
                    stream << "WALL_CLOCK_TIMER_S";
                    break;
                default:
                    throw std::invalid_argument("Unsupported instrument scale");
            }
            break;
        case InstrumentType::SCHEDULER_TIMESTAMPS:
            switch(instrument.second)
            {
                case ScaleFactor::NONE:
                    stream << "SCHEDULER_TIMESTAMPS";
                    break;
                case ScaleFactor::TIME_MS:
                    stream << "SCHEDULER_TIMESTAMPS_MS";
                    break;
                case ScaleFactor::TIME_S:
                    stream << "SCHEDULER_TIMESTAMPS_S";
                    break;
                default:
                    throw std::invalid_argument("Unsupported instrument scale");
            }
            break;
        case InstrumentType::SCHEDULER_TIMER:
            switch(instrument.second)
            {
                case ScaleFactor::NONE:
                    stream << "SCHEDULER_TIMER";
                    break;
                case ScaleFactor::TIME_MS:
                    stream << "SCHEDULER_TIMER_MS";
                    break;
                case ScaleFactor::TIME_S:
                    stream << "SCHEDULER_TIMER_S";
                    break;
                default:
                    throw std::invalid_argument("Unsupported instrument scale");
            }
            break;
        case InstrumentType::PMU:
            switch(instrument.second)
            {
                case ScaleFactor::NONE:
                    stream << "PMU";
                    break;
                case ScaleFactor::SCALE_1K:
                    stream << "PMU_K";
                    break;
                case ScaleFactor::SCALE_1M:
                    stream << "PMU_M";
                    break;
                default:
                    throw std::invalid_argument("Unsupported instrument scale");
            }
            break;
        case InstrumentType::PMU_CYCLE_COUNTER:
            stream << "PMU_CYCLE_COUNTER";
            break;
        case InstrumentType::PMU_INSTRUCTION_COUNTER:
            stream << "PMU_INSTRUCTION_COUNTER";
            break;
        case InstrumentType::MALI:
            switch(instrument.second)
            {
                case ScaleFactor::NONE:
                    stream << "MALI";
                    break;
                case ScaleFactor::SCALE_1K:
                    stream << "MALI_K";
                    break;
                case ScaleFactor::SCALE_1M:
                    stream << "MALI_M";
                    break;
                default:
                    throw std::invalid_argument("Unsupported instrument scale");
            }
            break;
        case InstrumentType::OPENCL_TIMESTAMPS:
            switch(instrument.second)
            {
                case ScaleFactor::NONE:
                    stream << "OPENCL_TIMESTAMPS";
                    break;
                case ScaleFactor::TIME_US:
                    stream << "OPENCL_TIMESTAMPS_US";
                    break;
                case ScaleFactor::TIME_MS:
                    stream << "OPENCL_TIMESTAMPS_MS";
                    break;
                case ScaleFactor::TIME_S:
                    stream << "OPENCL_TIMESTAMPS_S";
                    break;
                default:
                    throw std::invalid_argument("Unsupported instrument scale");
            }
            break;
        case InstrumentType::OPENCL_TIMER:
            switch(instrument.second)
            {
                case ScaleFactor::NONE:
                    stream << "OPENCL_TIMER";
                    break;
                case ScaleFactor::TIME_US:
                    stream << "OPENCL_TIMER_US";
                    break;
                case ScaleFactor::TIME_MS:
                    stream << "OPENCL_TIMER_MS";
                    break;
                case ScaleFactor::TIME_S:
                    stream << "OPENCL_TIMER_S";
                    break;
                default:
                    throw std::invalid_argument("Unsupported instrument scale");
            }
            break;
        case InstrumentType::OPENCL_MEMORY_USAGE:
            switch(instrument.second)
            {
                case ScaleFactor::NONE:
                    stream << "OPENCL_MEMORY_USAGE";
                    break;
                case ScaleFactor::SCALE_1K:
                    stream << "OPENCL_MEMORY_USAGE_K";
                    break;
                case ScaleFactor::SCALE_1M:
                    stream << "OPENCL_MEMORY_USAGE_M";
                    break;
                default:
                    throw std::invalid_argument("Unsupported instrument scale");
            }
            break;
        case InstrumentType::ALL:
            stream << "ALL";
            break;
        case InstrumentType::NONE:
            stream << "NONE";
            break;
        default:
            throw std::invalid_argument("Unsupported instrument type");
    }

    return stream;
}

operator<<() [5/5]

inline ::std::ostream& arm_compute::test::framework::operator<<	(	::std::ostream &	stream,
		TestCaseFactory::Status	status
	)

Definition at line 162 of file TestCaseFactory.h.

References TestCaseFactory::ACTIVE, TestCaseFactory::DISABLED, and TestCaseFactory::EXPECTED_FAILURE.

{
    switch(status)
    {
        case TestCaseFactory::Status::ACTIVE:
            stream << "ACTIVE";
            break;
        case TestCaseFactory::Status::EXPECTED_FAILURE:
            stream << "EXPECTED_FAILURE";
            break;
        case TestCaseFactory::Status::DISABLED:
            stream << "DISABLED";
            break;
        default:
            throw std::invalid_argument("Unsupported test case factory status");
    }

    return stream;
}

operator>>() [1/4]

inline ::std::stringstream& arm_compute::test::framework::operator>>	(	::std::stringstream &	stream,
		LogFormat &	format
	)

Definition at line 45 of file Printers.h.

References log_format_from_name().

{
    std::string value;
    stream >> value;
    format = log_format_from_name(value);
    return stream;
}

operator>>() [2/4]

std::istream & operator>>	(	::std::istream &	stream,
		LogLevel &	level
	)

Definition at line 60 of file Exceptions.cpp.

References log_level_from_name().

{
    std::string value;
    stream >> value;
    level = log_level_from_name(value);
    return stream;
}

operator>>() [3/4]

inline ::std::istream& arm_compute::test::framework::operator>>	(	::std::istream &	stream,
		DatasetMode &	mode
	)

Definition at line 69 of file DatasetModes.h.

References dataset_mode_from_name().

{
    std::string value;
    stream >> value;
    mode = dataset_mode_from_name(value);
    return stream;
}

operator>>() [4/4]

inline ::std::stringstream& arm_compute::test::framework::operator>>	(	::std::stringstream &	stream,
		InstrumentsDescription &	instrument
	)

Definition at line 73 of file Instruments.h.

References instrument_type_from_name().

{
    std::string value;
    stream >> value;
    instrument = instrument_type_from_name(value);
    return stream;
}

operator|()

DatasetMode arm_compute::test::framework::operator| ( DatasetMode  t1, DatasetMode  t2  )

inline

Definition at line 54 of file DatasetModes.h.

References type.

{
    using type = std::underlying_type<DatasetMode>::type;
    return static_cast<DatasetMode>(static_cast<type>(t1) | static_cast<type>(t2));
}

operator|=()

DatasetMode& arm_compute::test::framework::operator|= ( DatasetMode &  t1, DatasetMode  t2  )

inline

Definition at line 60 of file DatasetModes.h.

References dataset_mode_from_name(), name, and type.

{
    using type = std::underlying_type<DatasetMode>::type;
    t1         = static_cast<DatasetMode>(static_cast<type>(t1) | static_cast<type>(t2));
    return t1;
}

sleep_in_seconds()

void arm_compute::test::framework::sleep_in_seconds

(

float

seconds

)

Makes the calling thread to sleep for a specified number of seconds.

Parameters

[in]

seconds

Amount of seconds to sleep. Will return immediately if less or equal to zero.

Definition at line 38 of file Utils.cpp.

Referenced by arm_compute::test::arithmetic_to_string(), and Framework::run().

{
    // Early return on non-positive input
    if(seconds <= 0.f)
    {
        return;
    }

#ifndef NO_MULTI_THREADING
    const int64_t us = static_cast<int64_t>(seconds * 1e6);
    std::this_thread::sleep_for(std::chrono::microseconds(us));
#endif /* NO_MULTI_THREADING */
}

to_string() [1/2]

std::string arm_compute::test::framework::to_string ( DatasetMode  mode )

inline

Definition at line 100 of file DatasetModes.h.

References clang_tidy_rules::mode.

Referenced by RangeDataset< T >::iterator::description(), SingletonDataset< T >::iterator::description(), and ContainerDataset< T >::iterator::description().

{
    std::stringstream stream;
    stream << mode;
    return stream.str();
}

to_string() [2/2]

std::string to_string

(

LogLevel

level

)

Definition at line 100 of file Exceptions.cpp.

References GemmTuner::level.

{
    std::stringstream stream;
    stream << level;
    return stream.str();
}

Variable Documentation

instruments_info

std::unique_ptr< InstrumentsInfo > instruments_info

Definition at line 50 of file Framework.cpp.

Referenced by main(), and SchedulerClock< output_timestamps >::SchedulerClock().