SimdArray< T, N, V, Wt > Class Template Reference

Detailed Description

template<typename T, size_t N, typename V, size_t Wt>
class Vc::SimdArray< T, N, V, Wt >

Data-parallel arithmetic type with user-defined number of elements.

Template Parameters

T	The type of the vector's elements. The supported types currently are limited to the types supported by Vc::Vector<T>.
N	The number of elements to store and process concurrently. You can choose an arbitrary number, though not every number is a good idea. Generally, a power of two value or the sum of two power of two values might work efficiently, though this depends a lot on the target system.
V	Don't change the default value unless you really know what you are doing. This type is set to the underlying native Vc::Vector type used in the implementation of the type. Having it as part of the type name guards against some cases of ODR violations (i.e. linking incompatible translation units / libraries).
Wt	Don't ever change the default value. This parameter is an unfortunate implementation detail shining through.

Warning

Choosing N too large (what “too large” means depends on the target) will result in excessive compilation times and high (or too high) register pressure, thus potentially negating the improvement from concurrent execution. As a rule of thumb, keep N less or equal to 2 * float_v::size().

A special portability concern arises from a current limitation in the MIC implementation (Intel Knights Corner), where SimdArray types with T = (u)short require an N either less than short_v::size() or a multiple of short_v::size().

Definition at line 616 of file simdarray.h.

#include <Vc/SimdArray>

Public Types
using	value_type = T
	The type of the elements (i.e. T)
using	mask_type = fixed_size_simd_mask< T, N >
	The type of the mask used for masked operations and returned from comparisons.
using	index_type = fixed_size_simd< int, N >
	The type of the vector used for indexes in gather and scatter operations.
using	Mask = mask_type
	The type of the mask used for masked operations and returned from comparisons. More...
using	MaskType = Mask
	The type of the mask used for masked operations and returned from comparisons. More...
using	EntryType = value_type
	The type of the elements (i.e. T) More...
using	IndexType = index_type
	The type of the vector used for indexes in gather and scatter operations. More...

Public Member Functions
fixed_size_simd< T, N >	operator+ () const
	Returns a copy of itself.
Common::WriteMaskedVector< SimdArray, mask_type >	operator() (const mask_type &mask)
	Writemask the vector before an assignment. More...
value_type	min () const
	Returns the smallest entry in the vector.
value_type	min (const mask_type &mask) const
	Returns the smallest entry in the vector.
value_type	max () const
	Returns the largest entry in the vector.
value_type	max (const mask_type &mask) const
	Returns the largest entry in the vector.
value_type	product () const
	Returns the product of all entries in the vector.
value_type	product (const mask_type &mask) const
	Returns the product of all entries in the vector.
value_type	sum () const
	Returns the sum of all entries in the vector.
value_type	sum (const mask_type &mask) const
	Returns the sum of all entries in the vector.
fixed_size_simd< T, N >	partialSum () const
	Returns a vector containing the sum of all entries with smaller index.
template<typename F >
fixed_size_simd< T, N >	apply (F &&f) const
	Call f on every entry of the vector and return the results as a new vector.
template<typename F >
fixed_size_simd< T, N >	apply (F &&f, const mask_type &k) const
	As above, but skip the entries where mask is not set.
fixed_size_simd< T, N >	shifted (int amount) const
	Shift vector entries to the left by amount; shifting in zeros.
fixed_size_simd< T, N >	rotated (int amount) const
	Rotate vector entries to the left by amount.
fixed_size_simd< T, N >	reversed () const
	Returns a vector with all components reversed.
fixed_size_simd< T, N >	sorted () const
	Return a sorted copy of the vector. More...
Compile-Time Constant Initialization
	SimdArray ()=default
	Construct a zero-initialized vector object. More...
Conversion/Broadcast Constructors
	SimdArray (value_type a)
	Broadcast Constructor. More...
template<typename U , typename = enable_if<std::is_same<U, int>::value && !std::is_same<int, value_type>::value>>
	SimdArray (U a)
new/delete overloads for correct alignment
void *	operator new (size_t size)
	Allocates correctly aligned memory.
void *	operator new (size_t, void *p)
	Returns p.
void *	operator new[] (size_t size)
	Allocates correctly aligned memory.
void *	operator new[] (size_t, void *p)
	Returns p.
void	operator delete (void *ptr, size_t)
	Frees aligned memory.
void	operator delete (void *, void *)
	Does nothing.
void	operator delete[] (void *ptr, size_t)
	Frees aligned memory.
void	operator delete[] (void *, void *)
	Does nothing.

Static Public Member Functions
static constexpr std::size_t	size ()
	Returns N, the number of scalar components in an object of this type. More...

Static Public Attributes
static constexpr std::size_t	MemoryAlignment
	Specifies the alignment requirement for aligned load and store calls for objects of this vector type. More...

Deprecated Members
static constexpr std::size_t	Size = size()
	Returns N, the number of scalar components in an object of this type. More...
fixed_size_simd< T, N >	exponent () const
	Returns the exponents of the floating-point values in the vector. More...
MaskType	isNegative () const
	Returns whether a value is negative. More...
fixed_size_simd< T, N >	copySign (const SimdArray &x) const
	Copies the signs of the components of reference to the components of the current vector, returning the result. More...

Scalar Subscript Operators
reference	operator[] (size_t i) noexcept
	This operator can be used to modify scalar entries of the vector. More...
value_type	operator[] (size_t index) const noexcept
	This operator can be used to read scalar entries of the vector. More...

Generators
static fixed_size_simd< T, N >	Zero ()
	Returns a vector with the entries initialized to zero.
static fixed_size_simd< T, N >	One ()
	Returns a vector with the entries initialized to one.
static fixed_size_simd< T, N >	IndexesFromZero ()
	Returns a vector with the entries initialized to 0, 1, 2, 3, 4, 5, ...
static fixed_size_simd< T, N >	Random ()
	Returns a vector with pseudo-random entries. More...
template<typename G >
static fixed_size_simd< T, N >	generate (const G &gen)
	Generate a vector object from return values of gen (static variant of fill).
template<class G , class = decltype(std::declval<G>()(std::size_t())), class = enable_if<!Traits::is_simd_vector<G>::value>>
	SimdArray (const G &gen)

Member Typedef Documentation

Mask

using Mask = mask_type

The type of the mask used for masked operations and returned from comparisons.

Definition at line 678 of file simdarray.h.

MaskType

using MaskType = Mask

The type of the mask used for masked operations and returned from comparisons.

Definition at line 680 of file simdarray.h.

EntryType

using EntryType = value_type

The type of the elements (i.e. T)

Definition at line 684 of file simdarray.h.

IndexType

using IndexType = index_type

The type of the vector used for indexes in gather and scatter operations.

Definition at line 686 of file simdarray.h.

Constructor & Destructor Documentation

SimdArray() [1/2]

SimdArray ( )

default

Construct a zero-initialized vector object.

This constructor follows the behavior of the underlying arithmetic type T in that the expression T() zero-initializes the object. On the other hand the variable x in T x; is uninitialized. Since, for class types, both expressions call the default constructor Vector<T> x must zero-initialize x as well.

SimdArray() [2/2]

SimdArray ( value_type  a )

inline

Broadcast Constructor.

Constructs a vector with all entries of the vector filled with the given value.

Parameters

a	The scalar value to broadcast to all entries of the constructed vector.

Definition at line 755 of file simdarray.h.

Member Function Documentation

size()

static constexpr std::size_t size ( )

inlinestaticconstexpr

Returns N, the number of scalar components in an object of this type.

The size of the SimdArray, i.e. the number of scalar elements in the vector. In contrast to Vector::size() you have control over this value via the N template parameter of the SimdArray class template.

Returns

The number of scalar values stored and manipulated concurrently by objects of this type.

Definition at line 675 of file simdarray.h.

Random()

static fixed_size_simd<T, N> Random ( )

inlinestatic

Returns a vector with pseudo-random entries.

Currently the state of the random number generator cannot be modified and starts off with the same state. Thus you will get the same sequence of numbers for the same sequence of calls.

Returns

a new random vector. Floating-point values will be in the 0-1 range. Integers will use the full range the integer representation allows.

Note

This function may use a very small amount of state and thus will be a weak random number generator.

Definition at line 719 of file simdarray.h.

operator[]() [1/2]

reference operator[] ( size_t  i )

inlinenoexcept

This operator can be used to modify scalar entries of the vector.

Parameters

index

A value between 0 and Size. This value is not checked internally so you must make/be sure it is in range.

Returns

a reference to the vector entry at the given index.

Warning

The use of this function may result in suboptimal performance. Please check whether you can find a more vector-friendly way to do what you intended.

Note

the returned object models the concept of a reference and as such it can exist longer than the data it is referencing.

to avoid lifetime issues, we strongly advice not to store any reference objects.

the returned object models the concept of a reference and as such it can exist longer than the data it is referencing.

to avoid lifetime issues, we strongly advice not to store any reference objects.

Definition at line 1035 of file simdarray.h.

operator[]() [2/2]

value_type operator[] ( size_t  index ) const

inlinenoexcept

This operator can be used to read scalar entries of the vector.

Parameters

index

A value between 0 and Size. This value is not checked internally so you must make/be sure it is in range.

Returns

a copy of the vector entry at the given index.

Definition at line 1042 of file simdarray.h.

operator()()

Common::WriteMaskedVector<SimdArray, mask_type> operator() ( const mask_type &  mask )

inline

Writemask the vector before an assignment.

Parameters

mask	The writemask to be used.

Returns

an object that can be used for any kind of masked assignment.

The returned object is only to be used for assignments and should not be assigned to a variable.

Examples:

float_v v = float_v::Zero();         // v  = [0, 0, 0, 0]
int_v v2 = int_v::IndexesFromZero(); // v2 = [0, 1, 2, 3]
v(v2 < 2) = 1.f;                     // v  = [1, 1, 0, 0]
v(v2 < 3) += 1.f;                    // v  = [2, 2, 1, 0]
++v2(v < 1.f);                       // v2 = [0, 1, 2, 4]

Definition at line 1050 of file simdarray.h.

sorted()

fixed_size_simd<T, N> sorted ( ) const

inline

Return a sorted copy of the vector.

Returns

a sorted vector. The returned values are in ascending order:

v[0] <= v[1] <= v[2] <= v[3] ...

Note

If the vector contains NaNs the result is undefined.

Example:

int_v v = int_v::Random();
int_v s = v.sorted();
std::cout << v << '\n' << s << '\n';

With SSE the output would be:

[1513634383, -963914658, 1763536262, -1285037745]
[-1285037745, -963914658, 1513634383, 1763536262]

With the Scalar implementation:

[1513634383]
[1513634383]

Definition at line 1361 of file simdarray.h.

---

The documentation for this class was generated from the following files:

• /home/axel/build/Vc/src/Vc/fwddecl.h
• /home/axel/build/Vc/src/Vc/common/simdarray.h