arm_compute::test Namespace Reference

Namespaces
	benchmark
	colorconvert_helper
	convolution_3d
	detail
	framework
	traits
	validation

Data Structures
class	Accessor
	Accessor implementation for Tensor objects. More...
class	ArrayAccessor
	ArrayAccessor implementation for Array objects. More...
class	AssetsLibrary
	Factory class to create and fill tensors. More...
class	CLAccessor
	Accessor implementation for CLTensor objects. More...
class	CLArrayAccessor
	Accessor implementation for CLArray objects. More...
class	CLSynthetizeFunction
	This template synthetizes an ICLSimpleFunction which runs the given kernel K. More...
class	CLSynthetizeFunctionInitOutputWithZeroAndWithZeroConstantBorder
	As above but this also initializes to zero the input tensor. More...
class	CLSynthetizeFunctionWithZeroConstantBorder
	As above but this also setups a Zero border on the input tensor of the specified bordersize. More...
class	CLSynthetizeOperator
	This template synthetizes a simple IOperator which runs the given kernel K. More...
class	CLSynthetizeOperatorInitOutputWithZeroAndWithZeroConstantBorder
	As above but this also initializes to zero the input tensor. More...
class	ClSynthetizeOperatorWithBorder
	As above but this also setups a Zero border on the input tensor of the kernel's bordersize. More...
struct	common_promoted_signed_type
	Find the signed promoted common type. More...
struct	common_promoted_unsigned_type
	Find the unsigned promoted common type. More...
class	ContextSchedulerUser
struct	ContextType
struct	ContextType< Tensor >
class	IAccessor
	Common interface to provide information and access to tensor like structures. More...
class	IArrayAccessor
	Common interface to provide information and access to array like structures. More...
class	NESynthetizeFunction
	This template synthetizes an INESimpleFunction which runs the given kernel K. More...
class	NESynthetizeFunctionWithZeroConstantBorder
	As above but this also setups a Zero border on the input tensor of the specified bordersize. More...
class	NESynthetizeFunctionWithZeroConstantKernelBorder
	As above but this also setups a Zero border on the input tensor of the kernel's bordersize. More...
class	PaddingCalculator
	Calculate required padding. More...
class	ParametersLibrary
	Class that contains all the global parameters used by the tests. More...
class	RawTensor
	Subclass of SimpleTensor using uint8_t as value type. More...
class	SimpleTensor
	Simple tensor object that stores elements in a consecutive chunk of memory. More...
class	SimpleTensorAccessor
	Accessor implementation for SimpleTensor objects. More...
class	TensorCache
	Stores RawTensor categorised by the image they are created from including name, format and channel. More...

Functions
template<typename O , typename F , typename... As>
void	apply (O *obj, F &&func, const std::tuple< As... > &args)
template<typename T , typename std::enable_if< std::is_same< typename T::value_type, std::string >::value, int >::type = 0>
std::string	join (T first, T last, const std::string &separator)
	Helper function to concatenate multiple strings. More...
template<typename T , typename UnaryOp >
std::string	join (T &&first, T &&last, const std::string &separator, UnaryOp &&op)
	Helper function to concatenate multiple values. More...
template<typename T , typename std::enable_if< std::is_arithmetic< typename T::value_type >::value, int >::type = 0>
std::string	join (T &&first, T &&last, const std::string &separator)
	Helper function to concatenate multiple values. More...
std::string	tolower (std::string string)
	Convert string to lower case. More...
template<typename T , typename std::enable_if< std::is_arithmetic< T >::value, int >::type = 0>
std::string	arithmetic_to_string (T val, int decimal_places=0)
	Create a string with the arithmetic value in full precision. More...
void	sleep_in_seconds (float seconds)
	Makes the calling thread to sleep for a specified number of seconds. More...
template<typename D , typename T , typename... Ts>
void	fill_tensors (D &&dist, std::initializer_list< int > seeds, T &&tensor, Ts &&... other_tensors)
template<typename T1 , typename T2 >
SimpleTensor< T1 >	copy_tensor (const SimpleTensor< T2 > &tensor)
template<typename T1 , typename T2 , typename std::enable_if< std::is_same< T1, T2 >::value, int >::type = 0>
SimpleTensor< T1 >	copy_tensor (const SimpleTensor< half > &tensor)
template<typename U >
void	swap (SimpleTensor< U > &tensor1, SimpleTensor< U > &tensor2)
template<typename T >
std::string	prettify_tensor (const SimpleTensor< T > &input, const IOFormatInfo &io_fmt=IOFormatInfo{ IOFormatInfo::PrintRegion::NoPadding })
template<typename T >
std::ostream &	operator<< (std::ostream &os, const SimpleTensor< T > &tensor)
template<typename T >
std::string	to_string (const SimpleTensor< T > &tensor)
template<typename T , typename = typename std::enable_if<std::is_floating_point<T>::value>::type>
T	round_half_up (T value)
	Round floating-point value with half value rounding to positive infinity. More...
template<typename T , typename = typename std::enable_if<std::is_floating_point<T>::value>::type>
T	round_half_even (T value, T epsilon=std::numeric_limits< T >::epsilon())
	Round floating-point value with half value rounding to nearest even. More...
Format	get_format_for_channel (Channel channel)
	Look up the format corresponding to a channel. More...
Format	get_channel_format (Channel channel)
	Return the format of a channel. More...
template<typename F , typename T >
T	foldl (F &&, const T &value)
	Base case of foldl. More...
template<typename F , typename T , typename U >
auto	foldl (F &&func, T &&value1, U &&value2) -> decltype(func(value1, value2))
	Base case of foldl. More...
template<typename F , typename I , typename T , typename... Vs>
I	foldl (F &&func, I &&initial, T &&value, Vs &&... values)
	Fold left. More...
ValidRegion	shape_to_valid_region (const TensorShape &a_shape, bool border_undefined=false, BorderSize border_size=BorderSize(0))
	Create a valid region based on tensor shape, border mode and border size. More...
template<typename T >
void	store_value_with_data_type (void *ptr, T value, DataType data_type)
	Write the value after casting the pointer according to data_type. More...
template<typename U , typename T >
T	saturate_cast (T val)
	Saturate a value of type T against the numeric limits of type U. More...
Coordinates	index2coord (const TensorShape &shape, int index)
	Convert a linear index into n-dimensional coordinates. More...
int	coord2index (const TensorShape &shape, const Coordinates &coord)
	Linearise the given coordinate. More...
bool	is_in_valid_region (const ValidRegion &valid_region, Coordinates coord)
	Check if a coordinate is within a valid region. More...
template<typename T >
T	create_tensor (const TensorInfo &info, IRuntimeContext *ctx=nullptr)
	Create and initialize a tensor of the given type. More...
template<typename T >
T	create_tensor (const TensorShape &shape, DataType data_type, int num_channels=1, QuantizationInfo quantization_info=QuantizationInfo(), DataLayout data_layout=DataLayout::NCHW, IRuntimeContext *ctx=nullptr)
	Create and initialize a tensor of the given type. More...
template<typename T >
T	create_tensor (const TensorShape &shape, Format format, IRuntimeContext *ctx=nullptr)
	Create and initialize a tensor of the given type. More...
template<typename T , typename = typename std::enable_if<std::is_floating_point<T>::value>::type>
std::vector< T >	generate_random_real (unsigned int num_values, T min, T max, std::random_device::result_type seed)
	Create a vector with a uniform distribution of floating point values across the specified range. More...
template<typename T , typename ArrayAccessor_T >
void	fill_array (ArrayAccessor_T &&array, const std::vector< T > &v)
std::string	get_typestring (DataType data_type)
	Obtain numpy type string from DataType. More...
template<typename TensorType >
void	sync_if_necessary ()
	Sync if necessary. More...
template<typename TensorType >
void	sync_tensor_if_necessary (TensorType &tensor)
	Sync tensor if necessary. More...
ITensorInfo::TensorDimsState	construct_dims_state (int32_t value)
	Construct and return object for dimensions' state filled with the given value. More...
ITensorInfo::TensorDimsState	construct_dynamic_dims_state ()
	Construct and return object for dimensions' state filled with the value for dynamic state. More...
ITensorInfo::TensorDimsState	construct_static_dims_state ()
	Construct and return object for dimensions' state filled with the value for non-dynamic state. More...
template<typename TensorType >
void	set_tensor_dynamic (TensorType &t)
	Set the dimension states of the given tensor to dynamic. More...
template<typename TensorType >
void	set_tensor_static (TensorType &t)
	Set the dimension states of the given tensor to state. More...
experimental::dynamic_fusion::Conv2dAttributes	convert_pad_stride_info_to_conv_attr (const PadStrideInfo &info, const Size2D &dialation)

Variables
std::unique_ptr< ParametersLibrary >	parameters
std::unique_ptr< AssetsLibrary >	library
std::unique_ptr< AssetsLibrary >	fixed_library

Function Documentation

apply()

void arm_compute::test::apply	(	O *	obj,
		F &&	func,
		const std::tuple< As... > &	args
	)

Definition at line 79 of file Utils.h.

{
    detail::apply_impl(obj, std::forward<F>(func), args, detail::sequence_t<sizeof...(As)>());
}

References arm_compute::test::framework::apply_impl(), and GemmTuner::args.

arithmetic_to_string()

std::string arm_compute::test::arithmetic_to_string ( T  val, int  decimal_places = 0  )

inline

Create a string with the arithmetic value in full precision.

Parameters

val	Arithmetic value
decimal_places	How many decimal places to show

Returns

String with the arithmetic value.

Definition at line 164 of file Utils.h.

{
    std::stringstream ss;
    ss << std::fixed;
    ss.precision((decimal_places) ? decimal_places : std::numeric_limits<T>::digits10 + 1);
    ss << val;
    return ss.str();
}

References arm_compute::test::validation::ss().

Referenced by PrettyPrinter::print_measurements().

construct_dims_state()

ITensorInfo::TensorDimsState arm_compute::test::construct_dims_state ( int32_t  value )

inline

Construct and return object for dimensions' state filled with the given value.

Parameters

[in]

value

The value to fill

Returns

Constructed class

Definition at line 586 of file Utils.h.

{
    auto states = ITensorInfo::TensorDimsState{};
    std::fill(states.begin(), states.end(), value);
    return states;
}

References arm_compute::test::validation::utils::fill().

Referenced by construct_dynamic_dims_state(), and construct_static_dims_state().

construct_dynamic_dims_state()

ITensorInfo::TensorDimsState arm_compute::test::construct_dynamic_dims_state ( )

inline

Construct and return object for dimensions' state filled with the value for dynamic state.

Returns

Constructed class filled with the value for dynamic state

Definition at line 597 of file Utils.h.

{
    return construct_dims_state(ITensorInfo::get_dynamic_state_value());
}

References construct_dims_state(), and ITensorInfo::get_dynamic_state_value().

Referenced by set_tensor_dynamic().

construct_static_dims_state()

ITensorInfo::TensorDimsState arm_compute::test::construct_static_dims_state ( )

inline

Construct and return object for dimensions' state filled with the value for non-dynamic state.

Returns

Constructed class filled with the value for non-dynamic state

Definition at line 606 of file Utils.h.

{
    return construct_dims_state(ITensorInfo::get_static_state_value());
}

References construct_dims_state(), and ITensorInfo::get_static_state_value().

Referenced by set_tensor_static().

convert_pad_stride_info_to_conv_attr()

experimental::dynamic_fusion::Conv2dAttributes arm_compute::test::convert_pad_stride_info_to_conv_attr ( const PadStrideInfo &  info, const Size2D &  dialation  )

inline

Definition at line 633 of file Utils.h.

{
    const Padding2D info_pad(info.pad_left(), info.pad_right(), info.pad_top(), info.pad_bottom());
    const Size2D    info_stride(info.stride().first, info.stride().second);
    return arm_compute::experimental::dynamic_fusion::Conv2dAttributes().pad(info_pad).stride(info_stride).dilation(dialation);
}

References Conv2dAttributes::dilation(), arm_compute::test::validation::info, Conv2dAttributes::pad(), and Conv2dAttributes::stride().

coord2index()

int arm_compute::test::coord2index ( const TensorShape &  shape, const Coordinates &  coord  )

inline

Linearise the given coordinate.

Transforms the given coordinate into a linear offset in terms of elements.

Parameters

[in]	shape	Shape of the n-dimensional tensor.
[in]	coord	The to be converted coordinate.

Returns

Linear offset to the element.

Definition at line 388 of file Utils.h.

{
    ARM_COMPUTE_ERROR_ON_MSG(shape.total_size() == 0, "Cannot get index from empty shape");
    ARM_COMPUTE_ERROR_ON_MSG(coord.num_dimensions() == 0, "Cannot get index of empty coordinate");
 
    int index    = 0;
    int dim_size = 1;
 
    for(unsigned int i = 0; i < coord.num_dimensions(); ++i)
    {
        index += coord[i] * dim_size;
        dim_size *= shape[i];
    }
 
    return index;
}

References ARM_COMPUTE_ERROR_ON_MSG, Dimensions< T >::num_dimensions(), and arm_compute::test::validation::shape.

Referenced by arm_compute::test::validation::apply_2d_spatial_filter(), arm_compute::test::validation::reference::col2im(), arm_compute::test::validation::reference::conv3d(), arm_compute::test::validation::reference::instance_normalization(), RawTensor::operator()(), SimpleTensor< uint8_t >::operator()(), arm_compute::test::validation::reference::pad_layer(), arm_compute::test::validation::reference::pooling_3d_layer_internal(), arm_compute::test::validation::reference::pooling_layer_internal(), arm_compute::test::validation::reference::reverse(), arm_compute::test::validation::reference::scale_core(), arm_compute::test::validation::tensor_elem_at(), arm_compute::test::validation::reference::tile(), arm_compute::test::validation::reference::transpose(), and arm_compute::test::validation::reference::weights_reshape().

copy_tensor() [1/2]

SimpleTensor< T1 > copy_tensor

(

const SimpleTensor< half > &

tensor

)

Definition at line 246 of file SimpleTensor.h.

{
    SimpleTensor<T1> st(tensor.shape(), tensor.data_type(),
                        tensor.num_channels(),
                        tensor.quantization_info(),
                        tensor.data_layout());
    memcpy((void *)st.data(), (const void *)tensor.data(), size_t(st.num_elements() * sizeof(T1)));
    return st;
}

References SimpleTensor< T >::data(), SimpleTensor< T >::num_elements(), and tensor.

copy_tensor() [2/2]

SimpleTensor<T1> arm_compute::test::copy_tensor

(

const SimpleTensor< T2 > &

tensor

)

Definition at line 232 of file SimpleTensor.h.

{
    SimpleTensor<T1> st(tensor.shape(), tensor.data_type(),
                        tensor.num_channels(),
                        tensor.quantization_info(),
                        tensor.data_layout());
    for(size_t n = 0; n < size_t(st.num_elements()); n++)
    {
        st.data()[n] = static_cast<T1>(tensor.data()[n]);
    }
    return st;
}

References SimpleTensor< T >::data(), SimpleTensor< T >::num_elements(), and tensor.

create_tensor() [1/3]

T arm_compute::test::create_tensor ( const TensorInfo &  info, IRuntimeContext *  ctx = nullptr  )

inline

Create and initialize a tensor of the given type.

Parameters

[in]	info	Tensor information to be used to create the tensor
[in]	ctx	(Optional) Pointer to the runtime context.

Returns

Initialized tensor of given type.

Definition at line 427 of file Utils.h.

{
    T tensor(ctx);
    tensor.allocator()->init(info);
    return tensor;
}

References arm_compute::test::validation::info, and tensor.

create_tensor() [2/3]

T arm_compute::test::create_tensor ( const TensorShape &  shape, DataType  data_type, int  num_channels = 1, QuantizationInfo  quantization_info = QuantizationInfo(), DataLayout  data_layout = DataLayout::NCHW, IRuntimeContext *  ctx = nullptr  )

inline

Create and initialize a tensor of the given type.

Parameters

[in]	shape	Tensor shape.
[in]	data_type	Data type.
[in]	num_channels	(Optional) Number of channels.
[in]	quantization_info	(Optional) Quantization info for asymmetric quantized types.
[in]	data_layout	(Optional) Data layout. Default is NCHW.
[in]	ctx	(Optional) Pointer to the runtime context.

Returns

Initialized tensor of given type.

Definition at line 446 of file Utils.h.

{
    T          tensor(ctx);
    TensorInfo info(shape, num_channels, data_type);
    info.set_quantization_info(quantization_info);
    info.set_data_layout(data_layout);
 
    return create_tensor<T>(info, ctx);
}

References arm_compute::cpu::data_layout, arm_compute::test::validation::data_type, arm_compute::test::validation::info, arm_compute::test::validation::shape, and tensor.

create_tensor() [3/3]

T arm_compute::test::create_tensor ( const TensorShape &  shape, Format  format, IRuntimeContext *  ctx = nullptr  )

inline

Create and initialize a tensor of the given type.

Parameters

[in]	shape	Tensor shape.
[in]	format	Format type.
[in]	ctx	(Optional) Pointer to the runtime context.

Returns

Initialized tensor of given type.

Definition at line 466 of file Utils.h.

{
    TensorInfo info(shape, format);
 
    return create_tensor<T>(info, ctx);
}

References arm_compute::test::validation::info, and arm_compute::test::validation::shape.

fill_array()

void arm_compute::test::fill_array ( ArrayAccessor_T &&  array, const std::vector< T > &  v  )

inline

Definition at line 498 of file Utils.h.

{
    array.resize(v.size());
    std::memcpy(array.buffer(), v.data(), v.size() * sizeof(T));
}

fill_tensors()

void arm_compute::test::fill_tensors	(	D &&	dist,
		std::initializer_list< int >	seeds,
		T &&	tensor,
		Ts &&...	other_tensors
	)

Definition at line 45 of file Helper.h.

{
    const std::array < T, 1 + sizeof...(Ts) > tensors{ { std::forward<T>(tensor), std::forward<Ts>(other_tensors)... } };
    std::vector<int> vs(seeds);
    ARM_COMPUTE_ERROR_ON(vs.size() != tensors.size());
    int k = 0;
    for(auto tp : tensors)
    {
        library->fill(Accessor(*tp), std::forward<D>(dist), vs[k++]);
    }
}

References ARM_COMPUTE_ERROR_ON, library, and tensor.

foldl() [1/3]

T arm_compute::test::foldl ( F &&  , const T &  value  )

inline

Base case of foldl.

Returns

value.

Definition at line 182 of file Utils.h.

{
    return value;
}

Referenced by foldl().

foldl() [2/3]

I arm_compute::test::foldl ( F &&  func, I &&  initial, T &&  value, Vs &&...  values  )

inline

Fold left.

Parameters

[in]	func	Binary function to be called.
[in]	initial	Initial value.
[in]	value	Argument passed to the function.
[in]	values	Remaining arguments.

Definition at line 205 of file Utils.h.

{
    return foldl(std::forward<F>(func), func(std::forward<I>(initial), std::forward<T>(value)), std::forward<Vs>(values)...);
}

References foldl().

foldl() [3/3]

auto arm_compute::test::foldl ( F &&  func, T &&  value1, U &&  value2  ) -> decltype(func(value1, value2))

inline

Base case of foldl.

Returns

func(value1, value2).

Definition at line 192 of file Utils.h.

{
    return func(value1, value2);
}

generate_random_real()

std::vector<T> arm_compute::test::generate_random_real ( unsigned int  num_values, T  min, T  max, std::random_device::result_type  seed  )

inline

Create a vector with a uniform distribution of floating point values across the specified range.

Parameters

[in]	num_values	The number of values to be created.
[in]	min	The minimum value in distribution (inclusive).
[in]	max	The maximum value in distribution (inclusive).
[in]	seed	The random seed to be used.

Returns

A vector that contains the requested number of random floating point values

Definition at line 483 of file Utils.h.

{
    std::vector<T>                    v(num_values);
    std::mt19937                      gen(seed);
    std::uniform_real_distribution<T> dist(min, max);
 
    for(unsigned int i = 0; i < num_values; ++i)
    {
        v.at(i) = dist(gen);
    }
 
    return v;
}

get_channel_format()

Format arm_compute::test::get_channel_format ( Channel  channel )

inline

Return the format of a channel.

Parameters

[in]

channel

Channel type.

Returns

Format of the given channel.

Definition at line 164 of file Utils.h.

{
    switch(channel)
    {
        case Channel::R:
        case Channel::G:
        case Channel::B:
            return Format::U8;
        default:
            throw std::runtime_error("Unsupported channel");
    }
}

References arm_compute::B, arm_compute::G, arm_compute::R, and arm_compute::U8.

get_format_for_channel()

Format arm_compute::test::get_format_for_channel ( Channel  channel )

inline

Look up the format corresponding to a channel.

Parameters

[in]

channel

Channel type.

Returns

Format that contains the given channel.

Definition at line 145 of file Utils.h.

{
    switch(channel)
    {
        case Channel::R:
        case Channel::G:
        case Channel::B:
            return Format::RGB888;
        default:
            throw std::runtime_error("Unsupported channel");
    }
}

References arm_compute::B, arm_compute::G, arm_compute::R, and arm_compute::RGB888.

Referenced by AssetsLibrary::fill(), and AssetsLibrary::get().

get_typestring()

std::string arm_compute::test::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 510 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:
            return no_endianness + "u" + support::cpp11::to_string(sizeof(uint8_t));
        case DataType::S8:
            return no_endianness + "i" + support::cpp11::to_string(sizeof(int8_t));
        case DataType::U16:
            return endianness + "u" + support::cpp11::to_string(sizeof(uint16_t));
        case DataType::S16:
            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::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("NOT SUPPORTED!");
    }
}

References ARM_COMPUTE_ERROR, arm_compute::test::validation::data_type, arm_compute::F32, arm_compute::F64, 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.

index2coord()

Coordinates arm_compute::test::index2coord ( const TensorShape &  shape, int  index  )

inline

Convert a linear index into n-dimensional coordinates.

Parameters

[in]	shape	Shape of the n-dimensional tensor.
[in]	index	Linear index specifying the i-th element.

Returns

n-dimensional coordinates.

Definition at line 359 of file Utils.h.

{
    int num_elements = shape.total_size();
 
    ARM_COMPUTE_ERROR_ON_MSG(index < 0 || index >= num_elements, "Index has to be in [0, num_elements]");
    ARM_COMPUTE_ERROR_ON_MSG(num_elements == 0, "Cannot create coordinate from empty shape");
 
    Coordinates coord{ 0 };
 
    for(int d = shape.num_dimensions() - 1; d >= 0; --d)
    {
        num_elements /= shape[d];
        coord.set(d, index / num_elements);
        index %= num_elements;
    }
 
    return coord;
}

References ARM_COMPUTE_ERROR_ON_MSG, and arm_compute::test::validation::shape.

Referenced by arm_compute::test::validation::reference::erode(), AssetsLibrary::fill(), AssetsLibrary::fill_boxes(), AssetsLibrary::fill_with_generator(), arm_compute::test::validation::reference::non_maxima_suppression(), arm_compute::test::validation::reference::pad_layer(), arm_compute::test::validation::reference::permute(), arm_compute::test::validation::reference::reverse(), arm_compute::test::validation::reference::scale_core(), arm_compute::test::validation::reference::tile(), arm_compute::test::validation::reference::transpose(), arm_compute::test::validation::transpose(), arm_compute::test::validation::validate(), and arm_compute::test::validation::validate_wrap().

is_in_valid_region()

bool arm_compute::test::is_in_valid_region ( const ValidRegion &  valid_region, Coordinates  coord  )

inline

Check if a coordinate is within a valid region.

Definition at line 406 of file Utils.h.

{
    for(size_t d = 0; d < Coordinates::num_max_dimensions; ++d)
    {
        if(coord[d] < valid_region.start(d) || coord[d] >= valid_region.end(d))
        {
            return false;
        }
    }
 
    return true;
}

References ValidRegion::end(), Dimensions< int >::num_max_dimensions, ValidRegion::start(), and arm_compute::test::validation::valid_region.

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

join() [1/3]

std::string arm_compute::test::join	(	T &&	first,
		T &&	last,
		const std::string &	separator
	)

Helper function to concatenate multiple values.

All values are converted to std::string using std::to_string before being joined.

Parameters

[in]	first	Iterator pointing to the first element to be concatenated.
[in]	last	Iterator pointing behind the last element to be concatenated.
[in]	separator	String used to join the elements.

Returns

String containing all elements joined by separator.

Definition at line 136 of file Utils.h.

{
    return join(std::forward<T>(first), std::forward<T>(last), separator, support::cpp11::to_string);
}

References join(), and arm_compute::support::cpp11::to_string().

join() [2/3]

std::string arm_compute::test::join	(	T &&	first,
		T &&	last,
		const std::string &	separator,
		UnaryOp &&	op
	)

Helper function to concatenate multiple values.

All values are converted to std::string using the provided operation before being joined.

The signature of op has to be equivalent to std::string op(const T::value_type &val).

Parameters

[in]	first	Iterator pointing to the first element to be concatenated.
[in]	last	Iterator pointing behind the last element to be concatenated.
[in]	separator	String used to join the elements.
[in]	op	Conversion function.

Returns

String containing all elements joined by separator.

Definition at line 117 of file Utils.h.

{
    return std::accumulate(std::next(first), last, op(*first), [&separator, &op](const std::string & base, const typename T::value_type & suffix)
    {
        return base + separator + op(suffix);
    });
}

References arm_compute::test::validation::reference::accumulate().

join() [3/3]

std::string arm_compute::test::join	(	T	first,
		T	last,
		const std::string &	separator
	)

Helper function to concatenate multiple strings.

Parameters

[in]	first	Iterator pointing to the first element to be concatenated.
[in]	last	Iterator pointing behind the last element to be concatenated.
[in]	separator	String used to join the elements.

Returns

String containing all elements joined by separator.

Definition at line 93 of file Utils.h.

{
    return std::accumulate(std::next(first), last, *first, [&separator](const std::string & base, const std::string & suffix)
    {
        return base + separator + suffix;
    });
}

References arm_compute::test::validation::reference::accumulate().

Referenced by join(), and JSONPrinter::print_measurements().

operator<<()

std::ostream& arm_compute::test::operator<< ( std::ostream &  os, const SimpleTensor< T > &  tensor  )

inline

Definition at line 131 of file SimpleTensorPrinter.h.

{
    os << prettify_tensor(tensor, IOFormatInfo{ IOFormatInfo::PrintRegion::NoPadding });
    return os;
}

References IOFormatInfo::NoPadding, prettify_tensor(), and tensor.

prettify_tensor()

std::string arm_compute::test::prettify_tensor ( const SimpleTensor< T > &  input, const IOFormatInfo &  io_fmt = IOFormatInfo{ IOFormatInfo::PrintRegion::NoPadding }  )

inline

Definition at line 41 of file SimpleTensorPrinter.h.

                                                                                                        { IOFormatInfo::PrintRegion::NoPadding })
{
    ARM_COMPUTE_ERROR_ON(input.data() == nullptr);
 
    RawTensor tensor(std::move(SimpleTensor<T>(input)));
 
    TensorInfo info(tensor.shape(), tensor.num_channels(), tensor.data_type());
 
    const DataType    dt           = info.data_type();
    const size_t      slices2D     = info.tensor_shape().total_size_upper(2);
    const Strides     strides      = info.strides_in_bytes();
    const PaddingSize padding      = info.padding();
    const size_t      num_channels = info.num_channels();
 
    std::ostringstream os;
 
    // Set precision
    if(is_data_type_float(dt) && (io_fmt.precision_type != IOFormatInfo::PrecisionType::Default))
    {
        int precision = io_fmt.precision;
        if(io_fmt.precision_type == IOFormatInfo::PrecisionType::Full)
        {
            precision = std::numeric_limits<float>().max_digits10;
        }
        os.precision(precision);
    }
 
    // Define region to print
    size_t print_width  = 0;
    size_t print_height = 0;
    int    start_offset = 0;
    switch(io_fmt.print_region)
    {
        case IOFormatInfo::PrintRegion::NoPadding:
            print_width  = info.dimension(0);
            print_height = info.dimension(1);
            start_offset = info.offset_first_element_in_bytes();
            break;
        case IOFormatInfo::PrintRegion::ValidRegion:
            print_width  = info.valid_region().shape.x();
            print_height = info.valid_region().shape.y();
            start_offset = info.offset_element_in_bytes(Coordinates(info.valid_region().anchor.x(),
                                                                    info.valid_region().anchor.y()));
            break;
        case IOFormatInfo::PrintRegion::Full:
            print_width  = padding.left + info.dimension(0) + padding.right;
            print_height = padding.top + info.dimension(1) + padding.bottom;
            start_offset = static_cast<int>(info.offset_first_element_in_bytes()) - padding.top * strides[1] - padding.left * strides[0];
            break;
        default:
            break;
    }
 
    print_width = print_width * num_channels;
 
    // Set pointer to start
    const uint8_t *ptr = tensor.data() + start_offset;
 
    // Start printing
    for(size_t i = 0; i < slices2D; ++i)
    {
        // Find max_width of elements in slice to align columns
        int max_element_width = 0;
        if(io_fmt.align_columns)
        {
            size_t offset = i * strides[2];
            for(size_t h = 0; h < print_height; ++h)
            {
                max_element_width = std::max<int>(max_element_width, max_consecutive_elements_display_width(os, dt, ptr + offset, print_width));
                offset += strides[1];
            }
        }
 
        // Print slice
        {
            size_t offset = i * strides[2];
            for(size_t h = 0; h < print_height; ++h)
            {
                print_consecutive_elements(os, dt, ptr + offset, print_width, max_element_width, io_fmt.element_delim);
                offset += strides[1];
                os << io_fmt.row_delim;
            }
            os << io_fmt.row_delim;
        }
    }
 
    return os.str();
}

References IOFormatInfo::NoPadding.

Referenced by operator<<().

round_half_even()

T arm_compute::test::round_half_even ( T  value, T  epsilon = std::numeric_limits<T>::epsilon()  )

inline

Round floating-point value with half value rounding to nearest even.

Parameters

[in]	value	floating-point value to be rounded.
[in]	epsilon	precision.

Returns

Floating-point value of rounded value.

Definition at line 82 of file Utils.h.

{
    T positive_value = std::abs(value);
    T ipart          = 0;
    std::modf(positive_value, &ipart);
    // If 'value' is exactly halfway between two integers
    if(std::abs(positive_value - (ipart + 0.5f)) < epsilon)
    {
        // If 'ipart' is even then return 'ipart'
        if(std::fmod(ipart, 2.f) < epsilon)
        {
            return support::cpp11::copysign(ipart, value);
        }
        // Else return the nearest even integer
        return support::cpp11::copysign(std::ceil(ipart + 0.5f), value);
    }
    // Otherwise use the usual round to closest
    return support::cpp11::copysign(support::cpp11::round(positive_value), value);
}

References arm_compute::support::cpp11::copysign(), arm_compute::quantization::epsilon, and arm_compute::support::cpp11::round().

round_half_up()

T arm_compute::test::round_half_up ( T  value )

inline

Round floating-point value with half value rounding to positive infinity.

Parameters

[in]

value

floating-point value to be rounded.

Returns

Floating-point value of rounded value.

Definition at line 69 of file Utils.h.

{
    return std::floor(value + 0.5f);
}

saturate_cast()

T arm_compute::test::saturate_cast

(

T

val

)

Saturate a value of type T against the numeric limits of type U.

Parameters

[in]

val

Value to be saturated.

Returns

saturated value.

Definition at line 313 of file Utils.h.

{
    if(val > static_cast<T>(std::numeric_limits<U>::max()))
    {
        val = static_cast<T>(std::numeric_limits<U>::max());
    }
    if(val < static_cast<T>(std::numeric_limits<U>::lowest()))
    {
        val = static_cast<T>(std::numeric_limits<U>::lowest());
    }
    return val;
}

References arm_compute::support::cpp11::lowest().

set_tensor_dynamic()

void arm_compute::test::set_tensor_dynamic

(

TensorType &

t

)

Set the dimension states of the given tensor to dynamic.

Parameters

[in]

t

The tensor to set to dynamic state

Definition at line 617 of file Utils.h.

{
    t.info()->set_tensor_dims_state(construct_dynamic_dims_state());
}

References construct_dynamic_dims_state(), and tf_frozen_model_extractor::t.

set_tensor_static()

void arm_compute::test::set_tensor_static

(

TensorType &

t

)

Set the dimension states of the given tensor to state.

Parameters

[in]

t

The tensor to set to static state

Definition at line 628 of file Utils.h.

{
    t.info()->set_tensor_dims_state(construct_static_dims_state());
}

References construct_static_dims_state(), and tf_frozen_model_extractor::t.

shape_to_valid_region()

ValidRegion arm_compute::test::shape_to_valid_region ( const TensorShape &  a_shape, bool  border_undefined = false, BorderSize  border_size = BorderSize(0)  )

inline

Create a valid region based on tensor shape, border mode and border size.

Parameters

[in]	a_shape	Shape used as size of the valid region.
[in]	border_undefined	(Optional) Boolean indicating if the border mode is undefined.
[in]	border_size	(Optional) Border size used to specify the region to exclude.

Returns

A valid region starting at (0, 0, ...) with size of shape if border_undefined is false; otherwise return A valid region starting at (border_size.left, border_size.top, ...) with reduced size of shape.

Definition at line 219 of file Utils.h.

{
    ValidRegion valid_region{ Coordinates(), a_shape };
 
    Coordinates &anchor = valid_region.anchor;
    TensorShape &shape  = valid_region.shape;
 
    if(border_undefined)
    {
        ARM_COMPUTE_ERROR_ON(shape.num_dimensions() < 2);
 
        anchor.set(0, border_size.left);
        anchor.set(1, border_size.top);
 
        const int valid_shape_x = std::max(0, static_cast<int>(shape.x()) - static_cast<int>(border_size.left) - static_cast<int>(border_size.right));
        const int valid_shape_y = std::max(0, static_cast<int>(shape.y()) - static_cast<int>(border_size.top) - static_cast<int>(border_size.bottom));
 
        shape.set(0, valid_shape_x);
        shape.set(1, valid_shape_y);
    }
 
    return valid_region;
}

References ValidRegion::anchor, ARM_COMPUTE_ERROR_ON, Dimensions< T >::set(), arm_compute::test::validation::shape, ValidRegion::shape, and arm_compute::test::validation::valid_region.

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

sleep_in_seconds()

void arm_compute::test::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.

{
    // 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 */
}

Referenced by Framework::run().

store_value_with_data_type()

void arm_compute::test::store_value_with_data_type	(	void *	ptr,
		T	value,
		DataType	data_type
	)

Write the value after casting the pointer according to data_type.

Warning

The type of the value must match the specified data type.

Parameters

[out]	ptr	Pointer to memory where the value will be written.
[in]	value	Value that will be written.
[in]	data_type	Data type that will be written.

Definition at line 252 of file Utils.h.

{
    switch(data_type)
    {
        case DataType::U8:
        case DataType::QASYMM8:
            *reinterpret_cast<uint8_t *>(ptr) = value;
            break;
        case DataType::S8:
        case DataType::QASYMM8_SIGNED:
        case DataType::QSYMM8:
        case DataType::QSYMM8_PER_CHANNEL:
            *reinterpret_cast<int8_t *>(ptr) = value;
            break;
        case DataType::U16:
        case DataType::QASYMM16:
            *reinterpret_cast<uint16_t *>(ptr) = value;
            break;
        case DataType::S16:
        case DataType::QSYMM16:
            *reinterpret_cast<int16_t *>(ptr) = value;
            break;
        case DataType::U32:
            *reinterpret_cast<uint32_t *>(ptr) = value;
            break;
        case DataType::S32:
            *reinterpret_cast<int32_t *>(ptr) = value;
            break;
        case DataType::U64:
            *reinterpret_cast<uint64_t *>(ptr) = value;
            break;
        case DataType::S64:
            *reinterpret_cast<int64_t *>(ptr) = value;
            break;
        case DataType::BFLOAT16:
            *reinterpret_cast<bfloat16 *>(ptr) = bfloat16(value);
            break;
        case DataType::F16:
            *reinterpret_cast<half *>(ptr) = value;
            break;
        case DataType::F32:
            *reinterpret_cast<float *>(ptr) = value;
            break;
        case DataType::F64:
            *reinterpret_cast<double *>(ptr) = value;
            break;
        case DataType::SIZET:
            *reinterpret_cast<size_t *>(ptr) = value;
            break;
        default:
            ARM_COMPUTE_ERROR("NOT SUPPORTED!");
    }
}

References ARM_COMPUTE_ERROR, arm_compute::BFLOAT16, arm_compute::test::validation::data_type, arm_compute::F16, arm_compute::F32, arm_compute::F64, arm_compute::QASYMM16, arm_compute::QASYMM8, arm_compute::QASYMM8_SIGNED, 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::U16, arm_compute::U32, arm_compute::U64, and arm_compute::U8.

Referenced by AssetsLibrary::fill(), AssetsLibrary::fill_boxes(), and AssetsLibrary::fill_with_generator().

swap()

void arm_compute::test::swap	(	SimpleTensor< U > &	tensor1,
		SimpleTensor< U > &	tensor2
	)

Parameters

[in,out]	tensor1	Tensor to be swapped.
[in,out]	tensor2	Tensor to be swapped.

Definition at line 460 of file SimpleTensor.h.

{
    // Use unqualified call to swap to enable ADL. But make std::swap available
    // as backup.
    using std::swap;
    swap(tensor1._shape, tensor2._shape);
    swap(tensor1._format, tensor2._format);
    swap(tensor1._data_type, tensor2._data_type);
    swap(tensor1._num_channels, tensor2._num_channels);
    swap(tensor1._quantization_info, tensor2._quantization_info);
    swap(tensor1._buffer, tensor2._buffer);
}

Referenced by SimpleTensor< uint8_t >::operator=().

sync_if_necessary()

void arm_compute::test::sync_if_necessary ( )

inline

Sync if necessary.

Definition at line 558 of file Utils.h.

{
#ifdef ARM_COMPUTE_CL
    if(opencl_is_available() && std::is_same<typename std::decay<TensorType>::type, arm_compute::CLTensor>::value)
    {
        CLScheduler::get().sync();
    }
#endif /* ARM_COMPUTE_CL */
}

References CLScheduler::get(), arm_compute::opencl_is_available(), CLScheduler::sync(), and type.

sync_tensor_if_necessary()

void arm_compute::test::sync_tensor_if_necessary ( TensorType &  tensor )

inline

Sync tensor if necessary.

Note

: If the destination tensor not being used on OpenGL ES, GPU will optimize out the operation.

Parameters

[in]

tensor

Tensor to be sync.

Definition at line 575 of file Utils.h.

{
    ARM_COMPUTE_UNUSED(tensor);
}

References ARM_COMPUTE_UNUSED, and tensor.

to_string()

std::string arm_compute::test::to_string ( const SimpleTensor< T > &  tensor )

inline

Definition at line 138 of file SimpleTensorPrinter.h.

{
    std::stringstream ss;
    ss << tensor;
    return ss.str();
}

References arm_compute::test::validation::ss(), and tensor.

Referenced by main().

tolower()

std::string arm_compute::test::tolower ( std::string  string )

inline

Convert string to lower case.

Parameters

[in]

string

To be converted string.

Returns

Lower case string.

Definition at line 147 of file Utils.h.

{
    std::transform(string.begin(), string.end(), string.begin(), [](unsigned char c)
    {
        return std::tolower(c);
    });
    return string;
}

References arm_compute::mlgo::parser::end().

Referenced by arm_compute::test::framework::dataset_mode_from_name(), arm_compute::test::framework::instrument_type_from_name(), arm_compute::test::framework::log_format_from_name(), and arm_compute::test::framework::log_level_from_name().

Variable Documentation

fixed_library

std::unique_ptr< AssetsLibrary > fixed_library

Definition at line 80 of file main.cpp.

Referenced by main().

library

std::unique_ptr< AssetsLibrary > library

Definition at line 77 of file main.cpp.

Referenced by arm_compute::test::validation::reference::accumulate(), arm_compute::test::validation::reference::accumulate_squared(), arm_compute::test::validation::reference::accumulate_weighted(), arm_compute::test::validation::add_padding_x(), arm_compute::test::validation::compute_float_reference(), arm_compute::test::validation::compute_float_target_in_place(), arm_compute::test::validation::DATA_TEST_CASE(), arm_compute::test::validation::utils::fill(), fill_tensors(), main(), and arm_compute::test::validation::TEST_CASE().

parameters

std::unique_ptr< ParametersLibrary > parameters

Definition at line 46 of file Framework.cpp.

Referenced by DepthwiseDepthfirstMultiplier< TInput, TWeight, TOutput, TAccum, is_generic, OutputStage >::compute_tile_padded(), StrategyType< IsGeneric, TInput, TWeight, TOutput, TAccum, OutputStage >::execute(), StrategyType< true, TInput, TWeight, TOutput, TAccum, OutputStage >::execute(), StrategyType< false, TInput, TWeight, TOutput, int32_t, arm_gemm::Requantize32 >::execute(), StrategyType< true, TInput, TWeight, TOutput, int32_t, arm_gemm::Requantize32 >::execute(), main(), and arm_compute::test::validation::TEST_CASE().