arm_compute::utils Namespace Reference

Namespaces
	cast
	detail
	info_helpers
	iterable
	math
	memory
	mmap_io
	random
	rounding
	traits

Data Structures
class	CommandLineParser
	Class to parse command line arguments. More...
class	CommonGraphOptions
	Common command line options used to configure the graph examples. More...
struct	CommonGraphParams
	Structure holding all the common graph parameters. More...
class	CommonGraphValidateOptions
	CommonGraphValidateOptions command line options used to configure the graph examples. More...
struct	CommonParams
	Structure holding all the graph Example parameters. More...
struct	ConvolutionParams
	Structure holding all the Convolution layer graph parameters. More...
class	EnumListOption
	Implementation of an option that accepts any number of values from a fixed set. More...
class	EnumOption
	Implementation of a simple option that accepts a value from a fixed set. More...
class	Example
	Abstract Example class. More...
struct	ExampleParams
	Structure holding all the graph Example parameters. More...
class	FileImageFeeder
	File Image feeder concrete implementation. More...
struct	FrameworkParams
	Structure holding all the common graph parameters. More...
struct	FullyConnectedParams
	Structure holding all the fully_connected layer graph parameters. More...
class	GraphValidateExample
class	IImageDataFeeder
	Image feeder interface. More...
class	IImageLoader
	Image loader interface. More...
class	ImageLoaderFactory
	Factory for generating appropriate image loader. More...
class	JPEGLoader
	Class to load the content of a JPEG file into an Image. More...
class	ListOption
	Implementation of an option that accepts any number of values. More...
class	MemoryImageFeeder
	Memory Image feeder concrete implementation. More...
class	NPYLoader
	Numpy data loader. More...
class	Option
	Abstract base class for a command line option. More...
class	PPMLoader
	PPM Image loader concrete implementation. More...
class	SimpleOption
	Implementation of an option that accepts a single value. More...
struct	TensorParams
	Structure holding all the input tensor graph parameters. More...
class	ToggleOption
	Implementation of an option that can be either true or false. More...
class	uniform_real_distribution_16bit
	Specialized class to generate random non-zero FP16 values. More...
class	ValidateExample
	Abstract ValidateExample class. More...
struct	VerificationParams
	Structure holding all the verification graph parameters. More...
class	VerifyAccessor
	Graph example validation accessor class. More...

Enumerations
enum	ConvolutionPaddingMode { Valid, Same, Manual }
enum	ImageType { UNKNOWN, PPM, JPEG }
	Supported image types. More...

Functions
template<typename E , typename SE >
constexpr E	as_cenum (const SE v) noexcept
	Convert a strongly typed enum to an old plain c enum. More...
template<typename SE , typename E >
constexpr SE	as_enum (const E val) noexcept
	Convert plain old enumeration to a strongly typed enum. More...
template<typename E >
bool	is_in (E check, std::initializer_list< E > list)
	Check if the given value is in the given enum value list. More...
const std::string &	string_from_scheduler_type (Scheduler::Type t)
	Convert a Scheduler::Type into a string. More...
void	schedule_kernel_on_ctx (IRuntimeContext *ctx, ICPPKernel *kernel, const IScheduler::Hints &hints)
	Schedules a kernel using the context if not nullptr else uses the legacy scheduling flow. More...
unsigned int	calculate_number_of_stages_only_x_axis (size_t input_x_dimension, unsigned int axis)
	Calculate number of stages for parallel implementations. More...
int	run_example (int argc, char **argv, std::unique_ptr< Example > example)
	Run an example and handle the potential exceptions it throws. More...
inline ::std::istream &	operator>> (::std::istream &stream, ConvolutionPaddingMode &Mode)
	Stream Input operator for the ConvolutionPaddingMode type. More...
inline ::std::ostream &	operator<< (::std::ostream &os, ConvolutionPaddingMode Mode)
	Formatted output of the ConvolutionPaddingMode type. More...
PadStrideInfo	calculate_convolution_padding (ExampleParams params)
	Calculate stride information. More...
void	consume_common_graph_parameters (CommonGraphValidateOptions &options, CommonParams &common_params)
	Consumes the consume_common_graph_parameters graph options and creates a structure containing any information. More...
std::unique_ptr< graph::ITensorAccessor >	get_accessor (const TensorParams &tensor, PixelValue lower, PixelValue upper, const std::random_device::result_type seed=0)
	Generates appropriate accessor according to the specified graph parameters. More...
template<template< typename D > class VerifyAccessorT>
std::unique_ptr< graph::ITensorAccessor >	get_verify_accessor (ExampleParams params)
	Generates appropriate convolution verify accessor. More...
int	run_example (int argc, char **argv, std::unique_ptr< ValidateExample > example)
	Run an example and handle the potential exceptions it throws. More...
::std::ostream &	operator<< (::std::ostream &os, const CommonGraphParams &common_params)
	Formatted output of the CommonGraphParams type. More...
CommonGraphParams	consume_common_graph_parameters (CommonGraphOptions &options)
	Consumes the common graph options and creates a structure containing any information. More...
void	draw_detection_rectangle (arm_compute::ITensor *tensor, const arm_compute::DetectionWindow &rect, uint8_t r, uint8_t g, uint8_t b)
	Draw a RGB rectangular window for the detected object. More...
ImageType	get_image_type_from_file (const std::string &filename)
	Gets image type given a file. More...
std::tuple< unsigned int, unsigned int, int >	parse_ppm_header (std::ifstream &fs)
	Parse the ppm header from an input file stream. More...
npy::header_t	parse_npy_header (std::ifstream &fs)
	Parse the npy header from an input file stream. More...
uint64_t	get_mem_free_from_meminfo ()
	This function returns the amount of memory free reading from /proc/meminfo. More...
template<typename T >
int	run_example (int argc, char **argv)
std::string	get_typestring (DataType data_type)
	Obtain numpy type string from DataType. More...
template<typename T >
void	map (T &tensor, bool blocking)
	Maps a tensor if needed. More...
template<typename T >
void	unmap (T &tensor)
	Unmaps a tensor if needed. More...
template<typename T >
void	save_to_ppm (T &tensor, const std::string &ppm_filename)
	Template helper function to save a tensor image to a PPM file. More...
template<typename T , typename U = float>
void	save_to_npy (T &tensor, const std::string &npy_filename, bool fortran_order)
	Template helper function to save a tensor image to a NPY file. More...
template<typename T >
void	load_trained_data (T &tensor, const std::string &filename)
	Load the tensor with pre-trained data from a binary file. More...
template<typename T , typename TensorType >
void	fill_tensor_value (TensorType &tensor, T value)
template<typename T , typename TensorType >
void	fill_tensor_zero (TensorType &tensor)
template<typename T , typename TensorType >
void	fill_tensor_vector (TensorType &tensor, std::vector< T > vec)
template<typename T , typename TensorType >
void	fill_random_tensor (TensorType &tensor, std::random_device::result_type seed, T lower_bound=std::numeric_limits< T >::lowest(), T upper_bound=std::numeric_limits< T >::max())
template<typename T , typename TensorType >
void	fill_random_tensor (TensorType &tensor, T lower_bound=std::numeric_limits< T >::lowest(), T upper_bound=std::numeric_limits< T >::max())
template<typename T >
void	init_sgemm_output (T &dst, T &src0, T &src1, arm_compute::DataType dt)
template<typename T >
int	compare_tensor (ITensor &tensor1, ITensor &tensor2, T tolerance)
	Compare two tensors. More...

Enumeration Type Documentation

ConvolutionPaddingMode

enum ConvolutionPaddingMode

strong

Enumerator
Valid
Same
Manual

Definition at line 38 of file graph_validate_utils.h.

{
    Valid,
    Same,
    Manual
};

ImageType

enum ImageType

strong

Supported image types.

Enumerator
UNKNOWN
PPM
JPEG

Definition at line 63 of file Utils.h.

{
    UNKNOWN,
    PPM,
    JPEG
};

Function Documentation

as_cenum()

constexpr E arm_compute::utils::as_cenum ( const SE  v )

constexprnoexcept

Convert a strongly typed enum to an old plain c enum.

Template Parameters

E	Plain old C enum
SE	Strongly typed resulting enum

Parameters

[in]

v

Value to convert

Returns

A corresponding plain old C enumeration

Definition at line 45 of file Utils.h.

{
    return static_cast<E>(static_cast<std::underlying_type_t<SE>>(v));
}

as_enum()

constexpr SE arm_compute::utils::as_enum ( const E  val )

constexprnoexcept

Convert plain old enumeration to a strongly typed enum.

Template Parameters

SE	Strongly typed resulting enum
E	Plain old C enum

Parameters

[in]

val

Value to convert

Returns

A corresponding strongly typed enumeration

Definition at line 60 of file Utils.h.

{
    return static_cast<SE>(val);
}

calculate_convolution_padding()

PadStrideInfo arm_compute::utils::calculate_convolution_padding ( ExampleParams  params )

inline

Calculate stride information.

Depending on the selected padding mode create the desired PadStrideInfo

Parameters

[in]

params

Convolution parameters supplied by the user.

Returns

PadStrideInfo with the correct padding mode.

Definition at line 194 of file graph_validate_utils.h.

{
    switch(params.convolution.padding_mode)
    {
        case ConvolutionPaddingMode::Manual:
        {
            return PadStrideInfo(params.convolution.padding_stride_x, params.convolution.padding_stride_y, params.convolution.padding_left, params.convolution.padding_right, params.convolution.padding_top,
                                 params.convolution.padding_bottom, DimensionRoundingType::FLOOR);
        }
        case ConvolutionPaddingMode::Valid:
        {
            return PadStrideInfo();
        }
        case ConvolutionPaddingMode::Same:
        {
            return arm_compute::calculate_same_pad(TensorShape(params.input.width, params.input.height), TensorShape(params.weights.width, params.weights.height),
                                                   PadStrideInfo(params.convolution.padding_stride_x,
                                                                 params.convolution.padding_stride_y));
        }
        default:
            ARM_COMPUTE_ERROR("NOT SUPPORTED!");
    }
}

References ARM_COMPUTE_ERROR, arm_compute::calculate_same_pad(), ExampleParams::convolution, arm_compute::FLOOR, TensorParams::height, CommonParams::input, Manual, ConvolutionParams::padding_bottom, ConvolutionParams::padding_left, ConvolutionParams::padding_mode, ConvolutionParams::padding_right, ConvolutionParams::padding_stride_x, ConvolutionParams::padding_stride_y, ConvolutionParams::padding_top, Same, Valid, CommonParams::weights, and TensorParams::width.

calculate_number_of_stages_only_x_axis()

unsigned int calculate_number_of_stages_only_x_axis	(	size_t	input_x_dimension,
		unsigned int	axis
	)

Calculate number of stages for parallel implementations.

Parameters

[in]	input_x_dimension	input tensor x dimension
[in]	axis	axis to be used

Definition at line 68 of file Utils.cpp.

{
    // We need only 1 stage for all axis except x-axis
    if(axis != 0)
    {
        return 1;
    }
    // Calculate number of WGs. 16 elements per thread, 8 threads per WG
    const auto num_of_wg = static_cast<unsigned int>(ceil(input_x_dimension / 128.f));
 
    // Calculate number of stages. First stage performs op and the rest reduction sum
    // depending on the size of the input. Last stage should have only 1 WG.
    const unsigned int num_of_stages = num_of_wg / 128 + 2;
    return num_of_stages;
}

compare_tensor()

int arm_compute::utils::compare_tensor	(	ITensor &	tensor1,
		ITensor &	tensor2,
		T	tolerance
	)

Compare two tensors.

Parameters

[in]	tensor1	First tensor to be compared.
[in]	tensor2	Second tensor to be compared.
[in]	tolerance	Tolerance used for the comparison.

Returns

The number of mismatches

Definition at line 811 of file Utils.h.

{
    ARM_COMPUTE_ERROR_ON_MISMATCHING_DATA_TYPES(&tensor1, &tensor2);
    ARM_COMPUTE_ERROR_ON_MISMATCHING_SHAPES(&tensor1, &tensor2);
 
    int    num_mismatches = 0;
    Window window;
    window.use_tensor_dimensions(tensor1.info()->tensor_shape());
 
    map(tensor1, true);
    map(tensor2, true);
 
    Iterator itensor1(&tensor1, window);
    Iterator itensor2(&tensor2, window);
 
    execute_window_loop(window, [&](const Coordinates &)
    {
        if(std::abs(*reinterpret_cast<T *>(itensor1.ptr()) - *reinterpret_cast<T *>(itensor2.ptr())) > tolerance)
        {
            ++num_mismatches;
        }
    },
    itensor1, itensor2);
 
    unmap(itensor1);
    unmap(itensor2);
 
    return num_mismatches;
}

References ARM_COMPUTE_ERROR_ON_MISMATCHING_DATA_TYPES, ARM_COMPUTE_ERROR_ON_MISMATCHING_SHAPES, arm_compute::execute_window_loop(), ITensor::info(), map(), Iterator::ptr(), ITensorInfo::tensor_shape(), unmap(), and Window::use_tensor_dimensions().

consume_common_graph_parameters() [1/2]

CommonGraphParams consume_common_graph_parameters

(

CommonGraphOptions &

options

)

Consumes the common graph options and creates a structure containing any information.

Parameters

[in]

options

Options to consume

Returns

Structure containing the common graph parameters

Definition at line 194 of file CommonGraphOptions.cpp.

{
    FastMathHint fast_math_hint_value = options.fast_math_hint->value() ? FastMathHint::Enabled : FastMathHint::Disabled;
    auto         validation_range     = parse_validation_range(options.validation_range->value());
 
    CommonGraphParams common_params;
    common_params.help      = options.help->is_set() ? options.help->value() : false;
    common_params.threads   = options.threads->value();
    common_params.batches   = options.batches->value();
    common_params.target    = options.target->value();
    common_params.data_type = options.data_type->value();
    if(options.data_layout->is_set())
    {
        common_params.data_layout = options.data_layout->value();
    }
    common_params.enable_tuner           = options.enable_tuner->is_set() ? options.enable_tuner->value() : false;
    common_params.enable_cl_cache        = common_params.target == arm_compute::graph::Target::NEON ? false : (options.enable_cl_cache->is_set() ? options.enable_cl_cache->value() : true);
    common_params.tuner_mode             = options.tuner_mode->value();
    common_params.fast_math_hint         = options.fast_math_hint->is_set() ? fast_math_hint_value : FastMathHint::Disabled;
    common_params.data_path              = options.data_path->value();
    common_params.image                  = options.image->value();
    common_params.labels                 = options.labels->value();
    common_params.validation_file        = options.validation_file->value();
    common_params.validation_path        = options.validation_path->value();
    common_params.validation_range_start = validation_range.first;
    common_params.validation_range_end   = validation_range.second;
    common_params.tuner_file             = options.tuner_file->value();
    common_params.mlgo_file              = options.mlgo_file->value();
 
    return common_params;
}

References CommonGraphParams::batches, CommonGraphOptions::batches, CommonGraphParams::data_layout, CommonGraphOptions::data_layout, CommonGraphParams::data_path, CommonGraphOptions::data_path, CommonGraphParams::data_type, CommonGraphOptions::data_type, CommonGraphParams::enable_cl_cache, CommonGraphOptions::enable_cl_cache, CommonGraphParams::enable_tuner, CommonGraphOptions::enable_tuner, CommonGraphParams::fast_math_hint, CommonGraphOptions::fast_math_hint, CommonGraphParams::help, CommonGraphOptions::help, CommonGraphParams::image, CommonGraphOptions::image, Option::is_set(), CommonGraphParams::labels, CommonGraphOptions::labels, CommonGraphParams::mlgo_file, CommonGraphOptions::mlgo_file, arm_compute::graph::NEON, CommonGraphParams::target, CommonGraphOptions::target, CommonGraphParams::threads, CommonGraphOptions::threads, CommonGraphParams::tuner_file, CommonGraphOptions::tuner_file, CommonGraphParams::tuner_mode, CommonGraphOptions::tuner_mode, CommonGraphParams::validation_file, CommonGraphOptions::validation_file, CommonGraphParams::validation_path, CommonGraphOptions::validation_path, CommonGraphOptions::validation_range, CommonGraphParams::validation_range_end, CommonGraphParams::validation_range_start, EnumOption< T >::value(), and SimpleOption< T >::value().

consume_common_graph_parameters() [2/2]

void arm_compute::utils::consume_common_graph_parameters	(	CommonGraphValidateOptions &	options,
		CommonParams &	common_params
	)

Consumes the consume_common_graph_parameters graph options and creates a structure containing any information.

Parameters

[in]	options	Options to consume
[out]	common_params	params structure to consume.

Definition at line 313 of file graph_validate_utils.h.

{
    common_params.common_params.help    = options.help->is_set() ? options.help->value() : false;
    common_params.common_params.threads = options.threads->value();
    common_params.common_params.target  = options.target->value();
 
    common_params.verification.absolute_tolerance = options.absolute_tolerance->value();
    common_params.verification.relative_tolerance = options.relative_tolerance->value();
    common_params.verification.tolerance_number   = options.tolerance_number->value();
}

References VerificationParams::absolute_tolerance, CommonGraphValidateOptions::absolute_tolerance, CommonParams::common_params, FrameworkParams::help, CommonGraphValidateOptions::help, Option::is_set(), VerificationParams::relative_tolerance, CommonGraphValidateOptions::relative_tolerance, FrameworkParams::target, CommonGraphValidateOptions::target, FrameworkParams::threads, CommonGraphValidateOptions::threads, VerificationParams::tolerance_number, CommonGraphValidateOptions::tolerance_number, EnumOption< T >::value(), SimpleOption< T >::value(), and CommonParams::verification.

draw_detection_rectangle()

void draw_detection_rectangle	(	arm_compute::ITensor *	tensor,
		const arm_compute::DetectionWindow &	rect,
		uint8_t	r,
		uint8_t	g,
		uint8_t	b
	)

Draw a RGB rectangular window for the detected object.

Parameters

[in,out]	tensor	Input tensor where the rectangle will be drawn on. Format supported: RGB888
[in]	rect	Geometry of the rectangular window
[in]	r	Red colour to use
[in]	g	Green colour to use
[in]	b	Blue colour to use

Definition at line 130 of file Utils.cpp.

{
    ARM_COMPUTE_ERROR_ON_FORMAT_NOT_IN(tensor, Format::RGB888);
 
    uint8_t *top    = tensor->info()->offset_element_in_bytes(Coordinates(rect.x, rect.y)) + tensor->buffer();
    uint8_t *bottom = tensor->info()->offset_element_in_bytes(Coordinates(rect.x, rect.y + rect.height)) + tensor->buffer();
    uint8_t *left   = top;
    uint8_t *right  = tensor->info()->offset_element_in_bytes(Coordinates(rect.x + rect.width, rect.y)) + tensor->buffer();
    size_t   stride = tensor->info()->strides_in_bytes()[Window::DimY];
 
    for(size_t x = 0; x < rect.width; ++x)
    {
        top[0]    = r;
        top[1]    = g;
        top[2]    = b;
        bottom[0] = r;
        bottom[1] = g;
        bottom[2] = b;
 
        top += 3;
        bottom += 3;
    }
 
    for(size_t y = 0; y < rect.height; ++y)
    {
        left[0]  = r;
        left[1]  = g;
        left[2]  = b;
        right[0] = r;
        right[1] = g;
        right[2] = b;
 
        left += stride;
        right += stride;
    }
}

References ARM_COMPUTE_ERROR_ON_FORMAT_NOT_IN, arm_compute::test::validation::b, Window::DimY, DetectionWindow::height, arm_compute::RGB888, tensor, DetectionWindow::width, DetectionWindow::x, and DetectionWindow::y.

fill_random_tensor() [1/2]

void arm_compute::utils::fill_random_tensor	(	TensorType &	tensor,
		std::random_device::result_type	seed,
		T	lower_bound = std::numeric_limits<T>::lowest(),
		T	upper_bound = std::numeric_limits<T>::max()
	)

Definition at line 758 of file Utils.h.

{
    constexpr bool is_fp_16bit = std::is_same<T, half>::value || std::is_same<T, bfloat16>::value;
    constexpr bool is_integral = std::is_integral<T>::value && !is_fp_16bit;
 
    using fp_dist_type = typename std::conditional<is_fp_16bit, arm_compute::utils::uniform_real_distribution_16bit<T>, std::uniform_real_distribution<T>>::type;
    using dist_type    = typename std::conditional<is_integral, std::uniform_int_distribution<T>, fp_dist_type>::type;
 
    std::mt19937 gen(seed);
    dist_type    dist(lower_bound, upper_bound);
 
    map(tensor, true);
 
    Window window;
    window.use_tensor_dimensions(tensor.info()->tensor_shape());
 
    Iterator it(&tensor, window);
    execute_window_loop(window, [&](const Coordinates &)
    {
        *reinterpret_cast<T *>(it.ptr()) = dist(gen);
    },
    it);
 
    unmap(tensor);
}

References arm_compute::execute_window_loop(), map(), Iterator::ptr(), tensor, type, unmap(), and Window::use_tensor_dimensions().

Referenced by fill_random_tensor(), and main().

fill_random_tensor() [2/2]

void arm_compute::utils::fill_random_tensor	(	TensorType &	tensor,
		T	lower_bound = std::numeric_limits<T>::lowest(),
		T	upper_bound = std::numeric_limits<T>::max()
	)

Definition at line 785 of file Utils.h.

{
    std::random_device rd;
    fill_random_tensor(tensor, rd(), lower_bound, upper_bound);
}

References fill_random_tensor(), and tensor.

fill_tensor_value()

void arm_compute::utils::fill_tensor_value	(	TensorType &	tensor,
		T	value
	)

Definition at line 713 of file Utils.h.

{
    map(tensor, true);
 
    Window window;
    window.use_tensor_dimensions(tensor.info()->tensor_shape());
 
    Iterator it_tensor(&tensor, window);
    execute_window_loop(window, [&](const Coordinates &)
    {
        *reinterpret_cast<T *>(it_tensor.ptr()) = value;
    },
    it_tensor);
 
    unmap(tensor);
}

References arm_compute::execute_window_loop(), map(), Iterator::ptr(), tensor, unmap(), and Window::use_tensor_dimensions().

Referenced by fill_tensor_zero().

fill_tensor_vector()

void arm_compute::utils::fill_tensor_vector	(	TensorType &	tensor,
		std::vector< T >	vec
	)

Definition at line 737 of file Utils.h.

{
    ARM_COMPUTE_ERROR_ON(tensor.info()->tensor_shape().total_size() != vec.size());
 
    map(tensor, true);
 
    Window window;
    window.use_tensor_dimensions(tensor.info()->tensor_shape());
 
    int      i = 0;
    Iterator it_tensor(&tensor, window);
    execute_window_loop(window, [&](const Coordinates &)
    {
        *reinterpret_cast<T *>(it_tensor.ptr()) = vec.at(i++);
    },
    it_tensor);
 
    unmap(tensor);
}

References ARM_COMPUTE_ERROR_ON, arm_compute::execute_window_loop(), map(), Iterator::ptr(), tensor, unmap(), and Window::use_tensor_dimensions().

fill_tensor_zero()

void arm_compute::utils::fill_tensor_zero

(

TensorType &

tensor

)

Definition at line 731 of file Utils.h.

{
    fill_tensor_value(tensor, T(0));
}

References fill_tensor_value(), and tensor.

get_accessor()

std::unique_ptr<graph::ITensorAccessor> arm_compute::utils::get_accessor ( const TensorParams &  tensor, PixelValue  lower, PixelValue  upper, const std::random_device::result_type  seed = 0  )

inline

Generates appropriate accessor according to the specified graph parameters.

Parameters

[in]	tensor	Tensor parameters
[in]	lower	Lower random values bound
[in]	upper	Upper random values bound
[in]	seed	Random generator seed

Returns

An appropriate tensor accessor

Definition at line 333 of file graph_validate_utils.h.

{
    if(!tensor.npy.empty())
    {
        return std::make_unique<arm_compute::graph_utils::NumPyBinLoader>(tensor.npy);
    }
    else
    {
        return std::make_unique<arm_compute::graph_utils::RandomAccessor>(lower, upper, seed);
    }
}

References tensor.

Referenced by GraphValidateExample< DepthwiseConvolutionLayer, DepthConvolutionOptions, DepthConvolutionVerifyAccessor >::do_setup().

get_image_type_from_file()

ImageType get_image_type_from_file

(

const std::string &

filename

)

Gets image type given a file.

Parameters

[in]

filename

File to identify its image type

Returns

Image type

Definition at line 167 of file Utils.cpp.

{
    ImageType type = ImageType::UNKNOWN;
 
    try
    {
        // Open file
        std::ifstream fs;
        fs.exceptions(std::ifstream::failbit | std::ifstream::badbit);
        fs.open(filename, std::ios::in | std::ios::binary);
 
        // Identify type from magic number
        std::array<unsigned char, 2> magic_number{ { 0 } };
        fs >> magic_number[0] >> magic_number[1];
 
        // PPM check
        if(static_cast<char>(magic_number[0]) == 'P' && static_cast<char>(magic_number[1]) == '6')
        {
            type = ImageType::PPM;
        }
        else if(magic_number[0] == 0xFF && magic_number[1] == 0xD8)
        {
            type = ImageType::JPEG;
        }
 
        fs.close();
    }
    catch(std::runtime_error &e)
    {
        ARM_COMPUTE_ERROR_VAR("Accessing %s: %s", filename.c_str(), e.what());
    }
 
    return type;
}

References ARM_COMPUTE_ERROR_VAR, JPEG, PPM, type, and UNKNOWN.

Referenced by ImageLoaderFactory::create().

get_mem_free_from_meminfo()

uint64_t get_mem_free_from_meminfo

(

)

This function returns the amount of memory free reading from /proc/meminfo.

Returns

The free memory in kB

Definition at line 253 of file Utils.cpp.

{
    std::string   line_attribute;
    std::ifstream file_meminfo("/proc/meminfo");
 
    if(file_meminfo.is_open())
    {
        while(!(file_meminfo >> line_attribute).fail())
        {
            //Test if is the line containing MemFree
            if(line_attribute == "MemFree:")
            {
                uint64_t mem_available;
                if(!(file_meminfo >> mem_available).fail())
                {
                    return mem_available;
                }
                else
                {
                    return 0;
                }
            }
            // if it's not MemFree ignore rest of the line
            file_meminfo.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
        }
    }
    // Nothing found or an error during opening the file
    return 0;
}

get_typestring()

std::string arm_compute::utils::get_typestring ( DataType  data_type )

inline

Obtain numpy type string from DataType.

Parameters

[in]

data_type

Data type.

Returns

numpy type string.

Definition at line 154 of file Utils.h.

{
    // Check endianness
    const unsigned int i = 1;
    const char        *c = reinterpret_cast<const char *>(&i);
    std::string        endianness;
    if(*c == 1)
    {
        endianness = std::string("<");
    }
    else
    {
        endianness = std::string(">");
    }
    const std::string no_endianness("|");
 
    switch(data_type)
    {
        case DataType::U8:
        case DataType::QASYMM8:
            return no_endianness + "u" + support::cpp11::to_string(sizeof(uint8_t));
        case DataType::S8:
        case DataType::QSYMM8:
        case DataType::QSYMM8_PER_CHANNEL:
            return no_endianness + "i" + support::cpp11::to_string(sizeof(int8_t));
        case DataType::U16:
        case DataType::QASYMM16:
            return endianness + "u" + support::cpp11::to_string(sizeof(uint16_t));
        case DataType::S16:
        case DataType::QSYMM16:
            return endianness + "i" + support::cpp11::to_string(sizeof(int16_t));
        case DataType::U32:
            return endianness + "u" + support::cpp11::to_string(sizeof(uint32_t));
        case DataType::S32:
            return endianness + "i" + support::cpp11::to_string(sizeof(int32_t));
        case DataType::U64:
            return endianness + "u" + support::cpp11::to_string(sizeof(uint64_t));
        case DataType::S64:
            return endianness + "i" + support::cpp11::to_string(sizeof(int64_t));
        case DataType::F16:
            return endianness + "f" + support::cpp11::to_string(sizeof(half));
        case DataType::F32:
            return endianness + "f" + support::cpp11::to_string(sizeof(float));
        case DataType::F64:
            return endianness + "f" + support::cpp11::to_string(sizeof(double));
        case DataType::SIZET:
            return endianness + "u" + support::cpp11::to_string(sizeof(size_t));
        default:
            ARM_COMPUTE_ERROR("Data type not supported");
    }
}

References ARM_COMPUTE_ERROR, arm_compute::test::validation::data_type, arm_compute::F16, arm_compute::F32, arm_compute::F64, arm_compute::QASYMM16, arm_compute::QASYMM8, arm_compute::QSYMM16, arm_compute::QSYMM8, arm_compute::QSYMM8_PER_CHANNEL, arm_compute::S16, arm_compute::S32, arm_compute::S64, arm_compute::S8, arm_compute::SIZET, arm_compute::support::cpp11::to_string(), arm_compute::U16, arm_compute::U32, arm_compute::U64, and arm_compute::U8.

Referenced by NPYLoader::fill_tensor().

get_verify_accessor()

std::unique_ptr<graph::ITensorAccessor> arm_compute::utils::get_verify_accessor ( ExampleParams  params )

inline

Generates appropriate convolution verify accessor.

Parameters

[in]

params

User supplied parameters for convolution.

Returns

A convolution verify accessor for the requested datatype.

Definition at line 591 of file graph_validate_utils.h.

{
    switch(params.data_type)
    {
        case DataType::QASYMM8:
        {
            return std::make_unique<VerifyAccessorT<uint8_t>>(
                       params);
        }
        case DataType::F16:
        {
            return std::make_unique<VerifyAccessorT<half>>(
                       params);
        }
        case DataType::F32:
        {
            return std::make_unique<VerifyAccessorT<float>>(
                       params);
        }
        default:
            ARM_COMPUTE_ERROR("NOT SUPPORTED!");
    }
}

References ARM_COMPUTE_ERROR, CommonParams::data_type, arm_compute::F16, arm_compute::F32, and arm_compute::QASYMM8.

init_sgemm_output()

void arm_compute::utils::init_sgemm_output	(	T &	dst,
		T &	src0,
		T &	src1,
		arm_compute::DataType	dt
	)

Definition at line 792 of file Utils.h.

{
    dst.allocator()->init(TensorInfo(TensorShape(src1.info()->dimension(0), src0.info()->dimension(1), src0.info()->dimension(2)), 1, dt));
}

References arm_compute::test::validation::dst, and dt.

is_in()

bool arm_compute::utils::is_in	(	E	check,
		std::initializer_list< E >	list
	)

Check if the given value is in the given enum value list.

Template Parameters

E	The type of the enum

Parameters

[in]	check	Value to check
[in]	list	List of enum values to check against

Returns

True if the given value is found in the list

Definition at line 75 of file Utils.h.

{
    return std::any_of(list.begin(), list.end(), [&check](E e)
    {
        return check == e;
    });
}

load_trained_data()

void arm_compute::utils::load_trained_data	(	T &	tensor,
		const std::string &	filename
	)

Load the tensor with pre-trained data from a binary file.

Parameters

[in]	tensor	The tensor to be filled. Data type supported: F32.
[in]	filename	Filename of the binary file to load from.

Definition at line 666 of file Utils.h.

{
    ARM_COMPUTE_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(&tensor, 1, DataType::F32);
 
    std::ifstream fs;
 
    try
    {
        fs.exceptions(std::ofstream::failbit | std::ofstream::badbit | std::ofstream::eofbit);
        // Open file
        fs.open(filename, std::ios::in | std::ios::binary);
 
        if(!fs.good())
        {
            throw std::runtime_error("Could not load binary data: " + filename);
        }
 
        // Map buffer if creating a CLTensor
        map(tensor, true);
 
        Window window;
 
        window.set(arm_compute::Window::DimX, arm_compute::Window::Dimension(0, 1, 1));
 
        for(unsigned int d = 1; d < tensor.info()->num_dimensions(); ++d)
        {
            window.set(d, Window::Dimension(0, tensor.info()->tensor_shape()[d], 1));
        }
 
        arm_compute::Iterator in(&tensor, window);
 
        execute_window_loop(window, [&](const Coordinates &)
        {
            fs.read(reinterpret_cast<std::fstream::char_type *>(in.ptr()), tensor.info()->tensor_shape()[0] * tensor.info()->element_size());
        },
        in);
 
        // Unmap buffer if creating a CLTensor
        unmap(tensor);
    }
    catch(const std::ofstream::failure &e)
    {
        ARM_COMPUTE_ERROR_VAR("Writing %s: (%s)", filename.c_str(), e.what());
    }
}

References ARM_COMPUTE_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN, ARM_COMPUTE_ERROR_VAR, Window::DimX, arm_compute::execute_window_loop(), arm_compute::F32, map(), Iterator::ptr(), Window::set(), tensor, and unmap().

map()

void arm_compute::utils::map ( T &  tensor, bool  blocking  )

inline

Maps a tensor if needed.

Parameters

[in]	tensor	Tensor to be mapped
[in]	blocking	Specified if map is blocking or not

Definition at line 212 of file Utils.h.

{
    ARM_COMPUTE_UNUSED(tensor);
    ARM_COMPUTE_UNUSED(blocking);
}

References ARM_COMPUTE_UNUSED, and tensor.

Referenced by GEMMParam::__str__(), NativeGEMMConfig::__str__(), ReshapedOnlyRHSGEMMConfig::__str__(), ReshapedGEMMConfig::__str__(), Measurement::__str__(), compare_tensor(), IImageLoader::fill_image(), IImageLoader::fill_planar_tensor(), fill_random_tensor(), NPYLoader::fill_tensor(), fill_tensor_value(), fill_tensor_vector(), load_trained_data(), GemmTuner::parse_benchmark_commandline(), GEMMParam::parse_from_strs(), NativeGEMMConfig::parse_from_strs(), ReshapedOnlyRHSGEMMConfig::parse_from_strs(), ReshapedGEMMConfig::parse_from_strs(), save_to_npy(), and save_to_ppm().

operator<<() [1/2]

std::ostream & operator<<	(	::std::ostream &	os,
		const CommonGraphParams &	common_params
	)

Formatted output of the CommonGraphParams type.

Parameters

[out]	os	Output stream.
[in]	common_params	Common parameters to output

Returns

Modified output stream.

Definition at line 77 of file CommonGraphOptions.cpp.

{
    std::string false_str = std::string("false");
    std::string true_str  = std::string("true");
 
    os << "Threads : " << common_params.threads << std::endl;
    os << "Target : " << common_params.target << std::endl;
    os << "Data type : " << common_params.data_type << std::endl;
    os << "Data layout : " << common_params.data_layout << std::endl;
    os << "Tuner enabled? : " << (common_params.enable_tuner ? true_str : false_str) << std::endl;
    os << "Cache enabled? : " << (common_params.enable_cl_cache ? true_str : false_str) << std::endl;
    os << "Tuner mode : " << common_params.tuner_mode << std::endl;
    os << "Tuner file : " << common_params.tuner_file << std::endl;
    os << "MLGO file : " << common_params.mlgo_file << std::endl;
    os << "Fast math enabled? : " << (common_params.fast_math_hint == FastMathHint::Enabled ? true_str : false_str) << std::endl;
    if(!common_params.data_path.empty())
    {
        os << "Data path : " << common_params.data_path << std::endl;
    }
    if(!common_params.image.empty())
    {
        os << "Image file : " << common_params.image << std::endl;
    }
    if(!common_params.labels.empty())
    {
        os << "Labels file : " << common_params.labels << std::endl;
    }
    if(!common_params.validation_file.empty())
    {
        os << "Validation range : " << common_params.validation_range_start << "-" << common_params.validation_range_end << std::endl;
        os << "Validation file : " << common_params.validation_file << std::endl;
        if(!common_params.validation_path.empty())
        {
            os << "Validation path : " << common_params.validation_path << std::endl;
        }
    }
 
    return os;
}

References CommonGraphParams::data_layout, CommonGraphParams::data_path, CommonGraphParams::data_type, CommonGraphParams::enable_cl_cache, CommonGraphParams::enable_tuner, arm_compute::graph::Enabled, CommonGraphParams::fast_math_hint, CommonGraphParams::image, CommonGraphParams::labels, CommonGraphParams::mlgo_file, CommonGraphParams::target, CommonGraphParams::threads, CommonGraphParams::tuner_file, CommonGraphParams::tuner_mode, CommonGraphParams::validation_file, CommonGraphParams::validation_path, CommonGraphParams::validation_range_end, and CommonGraphParams::validation_range_start.

operator<<() [2/2]

inline ::std::ostream& arm_compute::utils::operator<<	(	::std::ostream &	os,
		ConvolutionPaddingMode	Mode
	)

Formatted output of the ConvolutionPaddingMode type.

Parameters

[out]	os	Output stream.
[in]	Mode	ConvolutionPaddingMode to output

Returns

Modified output stream.

Definition at line 85 of file graph_validate_utils.h.

{
    switch(Mode)
    {
        case ConvolutionPaddingMode::Valid:
            os << "Valid";
            break;
        case ConvolutionPaddingMode::Same:
            os << "Same";
            break;
        case ConvolutionPaddingMode::Manual:
            os << "Manual";
            break;
        default:
            throw std::invalid_argument("Unsupported padding mode format");
    }
 
    return os;
}

References Manual, Same, and Valid.

operator>>()

inline ::std::istream& arm_compute::utils::operator>>	(	::std::istream &	stream,
		ConvolutionPaddingMode &	Mode
	)

Stream Input operator for the ConvolutionPaddingMode type.

Parameters

[in]	stream	Input stream.
[out]	Mode	Convolution parameters to output

Returns

input stream.

Definition at line 52 of file graph_validate_utils.h.

{
    static const std::map<std::string, ConvolutionPaddingMode> modes =
    {
        { "valid", ConvolutionPaddingMode::Valid },
        { "same", ConvolutionPaddingMode::Same },
        { "manual", ConvolutionPaddingMode::Manual }
    };
    std::string value;
    stream >> value;
#ifndef ARM_COMPUTE_EXCEPTIONS_DISABLED
    try
    {
#endif /* ARM_COMPUTE_EXCEPTIONS_DISABLED */
        Mode = modes.at(arm_compute::utility::tolower(value));
#ifndef ARM_COMPUTE_EXCEPTIONS_DISABLED
    }
    catch(const std::out_of_range &)
    {
        throw std::invalid_argument(value);
    }
#endif /* ARM_COMPUTE_EXCEPTIONS_DISABLED */
 
    return stream;
}

References Manual, Same, arm_compute::utility::tolower(), and Valid.

parse_npy_header()

npy::header_t parse_npy_header

(

std::ifstream &

fs

)

Parse the npy header from an input file stream.

At the end of the execution, the file position pointer will be located at the first pixel stored in the npy file //TODO

Parameters

[in]

fs

Input file stream to parse

Returns

The width and height stored in the header of the NPY file

Definition at line 233 of file Utils.cpp.

{
    // Read header
    std::string header_s = npy::read_header(fs);
 
    // Parse header
    npy::header_t header = npy::parse_header(header_s);
 
    bool fortran_order = false;
    std::vector<unsigned long> shape = header.shape;
 
    std::reverse(shape.begin(), shape.end());
 
    return npy::header_t{ header.dtype, fortran_order, shape };
}

References arm_compute::mlgo::parser::header(), arm_compute::test::validation::reference::reverse(), and arm_compute::test::validation::shape.

Referenced by NPYLoader::open().

parse_ppm_header()

std::tuple< unsigned int, unsigned int, int > parse_ppm_header

(

std::ifstream &

fs

)

Parse the ppm header from an input file stream.

At the end of the execution, the file position pointer will be located at the first pixel stored in the ppm file

Parameters

[in]

fs

Input file stream to parse

Returns

The width, height and max value stored in the header of the PPM file

Definition at line 202 of file Utils.cpp.

{
    // Check the PPM magic number is valid
    std::array<char, 2> magic_number{ { 0 } };
    fs >> magic_number[0] >> magic_number[1];
    ARM_COMPUTE_ERROR_ON_MSG(magic_number[0] != 'P' || magic_number[1] != '6', "Invalid file type");
    ARM_COMPUTE_UNUSED(magic_number);
 
    discard_comments_and_spaces(fs);
 
    unsigned int width = 0;
    fs >> width;
 
    discard_comments_and_spaces(fs);
 
    unsigned int height = 0;
    fs >> height;
 
    discard_comments_and_spaces(fs);
 
    int max_val = 0;
    fs >> max_val;
 
    discard_comments(fs);
 
    ARM_COMPUTE_ERROR_ON_MSG(isspace(fs.peek()) == 0, "Invalid PPM header");
    fs.ignore(1);
 
    return std::make_tuple(width, height, max_val);
}

References ARM_COMPUTE_ERROR_ON_MSG, and ARM_COMPUTE_UNUSED.

Referenced by PPMLoader::open().

run_example() [1/3]

int arm_compute::utils::run_example	(	int	argc,
		char **	argv
	)

Definition at line 107 of file Utils.h.

{
    return run_example(argc, argv, std::make_unique<T>());
}

References run_example().

run_example() [2/3]

int run_example	(	int	argc,
		char **	argv,
		std::unique_ptr< Example >	example
	)

Run an example and handle the potential exceptions it throws.

Parameters

[in]	argc	Number of command line arguments
[in]	argv	Command line arguments
[in]	example	Example to run

Definition at line 95 of file RunExample.cpp.

{
    utils::CommandLineParser parser;
    framework::CommonOptions options(parser);
    auto                     example_args = parser.add_option<utils::ListOption<std::string>>("example_args");
    example_args->set_help("Arguments to pass to the example separated by commas (e.g: arg0,arg1,arg2)");
    framework::Framework &framework = framework::Framework::get();
 
    parser.parse(argc, argv);
 
    if(options.help->is_set() && options.help->value())
    {
        parser.print_help(argv[0]);
        return 0;
    }
 
    std::vector<std::unique_ptr<framework::Printer>> printers = options.create_printers();
    g_example                                                 = std::move(example);
    g_example_argv.clear();
    g_example_argv.emplace_back(argv[0]);
    for(auto &arg : example_args->value())
    {
        g_example_argv.emplace_back(const_cast<char *>(arg.c_str())); // NOLINT
    }
 
    if(options.log_level->value() > framework::LogLevel::NONE)
    {
        for(auto &p : printers)
        {
            p->print_global_header();
        }
    }
 
#ifdef ARM_COMPUTE_CL
    CLGEMMHeuristicsHandle gemm_h;
    if(opencl_is_available())
    {
        CLBackendType backend_type = CLBackendType::Native;
        for(auto &arg : example_args->value())
        {
            if(arg.find("--target=clvk") != std::string::npos)
            {
                backend_type = CLBackendType::Clvk;
                break;
            }
        }
 
        auto ctx_dev_err = create_opencl_context_and_device(backend_type);
        ARM_COMPUTE_ERROR_ON_MSG(std::get<2>(ctx_dev_err) != CL_SUCCESS, "Failed to create OpenCL context");
        CLScheduler::get()
        .default_init_with_context(std::get<1>(ctx_dev_err), std::get<0>(ctx_dev_err), nullptr, &gemm_h);
    }
#endif /* ARM_COMPUTE_CL */
 
    if(options.log_level->value() >= framework::LogLevel::CONFIG)
    {
        for(auto &p : printers)
        {
            p->print_entry("Version", build_information());
            p->print_entry("CommandLine", command_line(argc, argv));
#ifdef ARM_COMPUTE_CL
            if(opencl_is_available())
            {
                p->print_entry("CL_DEVICE_VERSION", CLKernelLibrary::get().get_device_version());
            }
            else
            {
                p->print_entry("CL_DEVICE_VERSION", "Unavailable");
            }
#endif /* ARM_COMPUTE_CL */
            p->print_entry("Iterations", support::cpp11::to_string(options.iterations->value()));
        }
    }
 
    // Initialize framework
    framework::FrameworkConfig fconfig;
    fconfig.instruments    = options.instruments->value();
    fconfig.num_iterations = options.iterations->value();
    fconfig.log_level      = options.log_level->value();
    framework.init(fconfig);
 
    for(auto &p : printers)
    {
        framework.add_printer(p.get());
    }
    framework.set_throw_errors(options.throw_errors->value());
    arm_compute::test::framework::detail::TestSuiteRegistrar suite{ "Examples" };
 
#ifdef BARE_METAL
    framework.add_test_case<ExampleTest>(argv[0], framework::DatasetMode::ALL, arm_compute::test::framework::TestCaseFactory::Status::ACTIVE);
#else  /* BARE_METAL */
    framework.add_test_case<ExampleTest>(basename(argv[0]), framework::DatasetMode::ALL, arm_compute::test::framework::TestCaseFactory::Status::ACTIVE);
#endif /* BARE_METAL */
    //func(argc, argv);
    bool success = framework.run();
    if(options.log_level->value() > framework::LogLevel::NONE)
    {
        for(auto &p : printers)
        {
            p->print_global_footer();
        }
    }
 
    return (success ? 0 : 1);
}

References CommonOptions::create_printers(), Framework::get(), CommonOptions::help, Option::is_set(), GemmTuner::parser, Option::set_help(), and SimpleOption< T >::value().

Referenced by run_example().

run_example() [3/3]

int run_example	(	int	argc,
		char **	argv,
		std::unique_ptr< ValidateExample >	example
	)

Run an example and handle the potential exceptions it throws.

Parameters

[in]	argc	Number of command line arguments
[in]	argv	Command line arguments
[in]	example	Example to run

Definition at line 109 of file RunExample.cpp.

{
    utils::CommandLineParser parser;
    framework::CommonOptions options(parser);
    auto                     example_args = parser.add_option<utils::ListOption<std::string>>("example_args");
    example_args->set_help("Arguments to pass to the example separated by commas (e.g: arg0,arg1,arg2)");
    auto seed = parser.add_option<utils::SimpleOption<std::random_device::result_type>>("seed", std::random_device()());
    seed->set_help("Global seed for random number generation");
    auto validate = parser.add_option<utils::SimpleOption<int>>("validate", 1);
    validate->set_help("Enable / disable output validation (0/1)");
 
    framework::Framework &framework = framework::Framework::get();
 
    parser.parse(argc, argv);
 
    if(options.help->is_set() && options.help->value())
    {
        parser.print_help(argv[0]);
        return 0;
    }
 
    std::vector<std::unique_ptr<framework::Printer>> printers = options.create_printers();
    g_example                                                 = std::move(example);
    g_example_argv.clear();
    g_example_argv.emplace_back(argv[0]);
    for(auto &arg : example_args->value())
    {
        g_example_argv.emplace_back(const_cast<char *>(arg.c_str())); // NOLINT
    }
 
    library       = std::make_unique<AssetsLibrary>("." /* Only using random values */, seed->value());
    fixed_library = std::make_unique<AssetsLibrary>(".", fixed_seed);
 
    if(options.log_level->value() > framework::LogLevel::NONE)
    {
        for(auto &p : printers)
        {
            p->print_global_header();
        }
    }
 
#ifdef ARM_COMPUTE_CL
    if(opencl_is_available())
    {
        CLBackendType backend_type = CLBackendType::Native;
        for(auto &arg : example_args->value())
        {
            if(arg.find("--target=clvk") != std::string::npos)
            {
                backend_type = CLBackendType::Clvk;
                break;
            }
        }
        auto ctx_dev_err = create_opencl_context_and_device(backend_type);
        ARM_COMPUTE_ERROR_ON_MSG(std::get<2>(ctx_dev_err) != CL_SUCCESS, "Failed to create OpenCL context");
        CLScheduler::get().default_init_with_context(std::get<1>(ctx_dev_err), std::get<0>(ctx_dev_err), nullptr);
    }
#endif /* ARM_COMPUTE_CL */
 
    if(options.log_level->value() >= framework::LogLevel::CONFIG)
    {
        for(auto &p : printers)
        {
            p->print_entry("Version", build_information());
            p->print_entry("CommandLine", command_line(argc, argv));
            p->print_entry("Seed", support::cpp11::to_string(seed->value()));
#ifdef ARM_COMPUTE_CL
            if(opencl_is_available())
            {
                p->print_entry("CL_DEVICE_VERSION", CLKernelLibrary::get().get_device_version());
            }
            else
            {
                p->print_entry("CL_DEVICE_VERSION", "Unavailable");
            }
#endif /* ARM_COMPUTE_CL */
            p->print_entry("Iterations", support::cpp11::to_string(options.iterations->value()));
            g_example->print_parameters(*p);
        }
    }
 
    // Initialize framework
    framework::FrameworkConfig fconfig;
    fconfig.instruments    = options.instruments->value();
    fconfig.num_iterations = options.iterations->value();
    fconfig.log_level      = options.log_level->value();
    framework.init(fconfig);
 
    for(auto &p : printers)
    {
        framework.add_printer(p.get());
    }
 
    framework.set_throw_errors(options.throw_errors->value());
    arm_compute::test::framework::detail::TestSuiteRegistrar suite{ "Examples" };
    if(validate->value() != 0)
    {
        framework.add_test_case<ExampleTest<true>>(basename(argv[0]), framework::DatasetMode::ALL, arm_compute::test::framework::TestCaseFactory::Status::ACTIVE);
    }
    else
    {
        framework.add_test_case<ExampleTest<false>>(basename(argv[0]), framework::DatasetMode::ALL, arm_compute::test::framework::TestCaseFactory::Status::ACTIVE);
    }
 
    //func(argc, argv);
    bool success = framework.run();
    if(options.log_level->value() > framework::LogLevel::NONE)
    {
        for(auto &p : printers)
        {
            p->print_global_footer();
        }
    }
 
    return (success ? 0 : 1);
}

References CommonOptions::create_printers(), Framework::get(), CommonOptions::help, Option::is_set(), GemmTuner::parser, Option::set_help(), arm_compute::validate(), and SimpleOption< T >::value().

save_to_npy()

void arm_compute::utils::save_to_npy	(	T &	tensor,
		const std::string &	npy_filename,
		bool	fortran_order
	)

Template helper function to save a tensor image to a NPY file.

Note

Only F32 data type supported.

If the input tensor is a CLTensor, the function maps and unmaps the image

Parameters

[in]	tensor	The tensor to save as NPY file
[in]	npy_filename	Filename of the file to create.
[in]	fortran_order	If true, save matrix in fortran order.

Definition at line 611 of file Utils.h.

{
    ARM_COMPUTE_ERROR_ON_DATA_TYPE_NOT_IN(&tensor, arm_compute::DataType::F32, arm_compute::DataType::QASYMM8);
 
    std::ofstream fs;
    try
    {
        fs.exceptions(std::ofstream::failbit | std::ofstream::badbit | std::ofstream::eofbit);
        fs.open(npy_filename, std::ios::out | std::ios::binary);
 
        std::vector<npy::ndarray_len_t> shape(tensor.info()->num_dimensions());
 
        for(unsigned int i = 0, j = tensor.info()->num_dimensions() - 1; i < tensor.info()->num_dimensions(); ++i, --j)
        {
            shape[i] = tensor.info()->tensor_shape()[!fortran_order ? j : i];
        }
 
        // Map buffer if creating a CLTensor
        map(tensor, true);
 
        using typestring_type = typename std::conditional<std::is_floating_point<U>::value, float, qasymm8_t>::type;
 
        std::vector<typestring_type> tmp; /* Used only to get the typestring */
        const npy::dtype_t           dtype = npy::dtype_map.at(std::type_index(typeid(tmp)));
 
        std::ofstream stream(npy_filename, std::ofstream::binary);
        npy::header_t header{ dtype, fortran_order, shape };
        npy::write_header(stream, header);
 
        arm_compute::Window window;
        window.use_tensor_dimensions(tensor.info()->tensor_shape());
 
        arm_compute::Iterator in(&tensor, window);
 
        arm_compute::execute_window_loop(window, [&](const arm_compute::Coordinates &)
        {
            stream.write(reinterpret_cast<const char *>(in.ptr()), sizeof(typestring_type));
        },
        in);
 
        // Unmap buffer if creating a CLTensor
        unmap(tensor);
    }
    catch(const std::ofstream::failure &e)
    {
        ARM_COMPUTE_ERROR_VAR("Writing %s: (%s)", npy_filename.c_str(), e.what());
    }
}

References ARM_COMPUTE_ERROR_ON_DATA_TYPE_NOT_IN, ARM_COMPUTE_ERROR_VAR, arm_compute::execute_window_loop(), arm_compute::F32, arm_compute::mlgo::parser::header(), map(), Iterator::ptr(), arm_compute::QASYMM8, arm_compute::test::validation::shape, tensor, type, unmap(), and Window::use_tensor_dimensions().

Referenced by SaveNumPyAccessor::access_tensor().

save_to_ppm()

void arm_compute::utils::save_to_ppm	(	T &	tensor,
		const std::string &	ppm_filename
	)

Template helper function to save a tensor image to a PPM file.

Note

Only U8 and RGB888 formats supported.

Only works with 2D tensors.

If the input tensor is a CLTensor, the function maps and unmaps the image

Parameters

[in]	tensor	The tensor to save as PPM file
[in]	ppm_filename	Filename of the file to create.

Definition at line 531 of file Utils.h.

{
    ARM_COMPUTE_ERROR_ON_FORMAT_NOT_IN(&tensor, arm_compute::Format::RGB888, arm_compute::Format::U8);
    ARM_COMPUTE_ERROR_ON(tensor.info()->num_dimensions() > 2);
 
    std::ofstream fs;
 
    try
    {
        fs.exceptions(std::ofstream::failbit | std::ofstream::badbit | std::ofstream::eofbit);
        fs.open(ppm_filename, std::ios::out | std::ios::binary);
 
        const unsigned int width  = tensor.info()->tensor_shape()[0];
        const unsigned int height = tensor.info()->tensor_shape()[1];
 
        fs << "P6\n"
           << width << " " << height << " 255\n";
 
        // Map buffer if creating a CLTensor
        map(tensor, true);
 
        switch(tensor.info()->format())
        {
            case arm_compute::Format::U8:
            {
                arm_compute::Window window;
                window.set(arm_compute::Window::DimX, arm_compute::Window::Dimension(0, width, 1));
                window.set(arm_compute::Window::DimY, arm_compute::Window::Dimension(0, height, 1));
 
                arm_compute::Iterator in(&tensor, window);
 
                arm_compute::execute_window_loop(window, [&](const arm_compute::Coordinates &)
                {
                    const unsigned char value = *in.ptr();
 
                    fs << value << value << value;
                },
                in);
 
                break;
            }
            case arm_compute::Format::RGB888:
            {
                arm_compute::Window window;
                window.set(arm_compute::Window::DimX, arm_compute::Window::Dimension(0, width, width));
                window.set(arm_compute::Window::DimY, arm_compute::Window::Dimension(0, height, 1));
 
                arm_compute::Iterator in(&tensor, window);
 
                arm_compute::execute_window_loop(window, [&](const arm_compute::Coordinates &)
                {
                    fs.write(reinterpret_cast<std::fstream::char_type *>(in.ptr()), width * tensor.info()->element_size());
                },
                in);
 
                break;
            }
            default:
                ARM_COMPUTE_ERROR("Unsupported format");
        }
 
        // Unmap buffer if creating a CLTensor
        unmap(tensor);
    }
    catch(const std::ofstream::failure &e)
    {
        ARM_COMPUTE_ERROR_VAR("Writing %s: (%s)", ppm_filename.c_str(), e.what());
    }
}

References ARM_COMPUTE_ERROR, ARM_COMPUTE_ERROR_ON, ARM_COMPUTE_ERROR_ON_FORMAT_NOT_IN, ARM_COMPUTE_ERROR_VAR, Window::DimX, Window::DimY, arm_compute::execute_window_loop(), map(), Iterator::ptr(), arm_compute::RGB888, Window::set(), tensor, arm_compute::U8, and unmap().

Referenced by PPMWriter::access_tensor().

schedule_kernel_on_ctx()

void schedule_kernel_on_ctx	(	IRuntimeContext *	ctx,
		ICPPKernel *	kernel,
		const IScheduler::Hints &	hints
	)

Schedules a kernel using the context if not nullptr else uses the legacy scheduling flow.

Parameters

[in]	ctx	Context to use.
[in]	kernel	Kernel to schedule.
[in]	hints	Hints to use.

Definition at line 55 of file Utils.cpp.

{
    if(ctx)
    {
        ARM_COMPUTE_ERROR_ON(ctx->scheduler() == nullptr);
        ctx->scheduler()->schedule(kernel, hints);
    }
    else
    {
        NEScheduler::get().schedule(kernel, hints);
    }
}

References ARM_COMPUTE_ERROR_ON, Scheduler::get(), IScheduler::schedule(), and IRuntimeContext::scheduler().

Referenced by INESimpleFunctionNoBorder::run().

string_from_scheduler_type()

const std::string & string_from_scheduler_type

(

Scheduler::Type

t

)

Convert a Scheduler::Type into a string.

Parameters

[in]

t

Scheduler::Type to be translated to string.

Returns

The string describing the scheduler type.

Definition at line 42 of file Utils.cpp.

{
    static std::map<Scheduler::Type, const std::string> scheduler_type_map =
    {
        { Scheduler::Type::ST, "Single Thread" },
        { Scheduler::Type::CPP, "C++11 Threads" },
        { Scheduler::Type::OMP, "OpenMP Threads" },
        { Scheduler::Type::CUSTOM, "Custom" }
    };
 
    return scheduler_type_map[t];
}

References Scheduler::CPP, Scheduler::CUSTOM, Scheduler::OMP, Scheduler::ST, and tf_frozen_model_extractor::t.

unmap()

void arm_compute::utils::unmap ( T &  tensor )

inline

Unmaps a tensor if needed.

Parameters

tensor

Tensor to be unmapped

Definition at line 223 of file Utils.h.

{
    ARM_COMPUTE_UNUSED(tensor);
}

References ARM_COMPUTE_UNUSED, and tensor.

Referenced by compare_tensor(), IImageLoader::fill_image(), IImageLoader::fill_planar_tensor(), fill_random_tensor(), NPYLoader::fill_tensor(), fill_tensor_value(), fill_tensor_vector(), load_trained_data(), save_to_npy(), and save_to_ppm().