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 565 of file simdarray.h.

#include <Vc/SimdArray>

Public Types
using	value_type = T
	The type of the elements (i.e. `T`)

using	mask_type = SimdMaskArray< T, N, vector_type >
	The type of the mask used for masked operations and returned from comparisons.

using	index_type = SimdArray< 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

SimdArray 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.

SimdArray partialSum () const

Returns a vector containing the sum of all entries with smaller index.

template<typename F >

SimdArray apply (F &&f) const

Call f on every entry of the vector and return the results as a new vector.

template<typename F >

SimdArray apply (F &&f, const mask_type &k) const

As above, but skip the entries where mask is not set.

SimdArray shifted (int amount) const

Shift vector entries to the left by amount; shifting in zeros.

SimdArray rotated (int amount) const

Rotate vector entries to the left by amount.

SimdArray reversed () const

Returns a vector with all components reversed.

SimdArray 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)

Gather constructors and member functions

Constructs or loads a vector from the objects at mem[indexes[0]], mem[indexes[1]], mem[indexes[2]], ...

All gather functions optionally take a mask as last argument. In that case only the entries that are selected in the mask are accessed in memory and copied to the vector. This enables invalid indexes in the indexes vector if those are masked off in mask.

Gathers from structured data (AoS: arrays of struct) are possible via a special subscript operator of the container (array). You can use Vc::array and Vc::vector as drop-in replacements for std::array and std::vector. These container classes contain the necessary subscript operator overload. Example:

Vc::vector<float> data(100);
std::iota(data.begin(), data.end(), 0.f);  // fill with values 0, 1, 2, ...
auto indexes = float_v::IndexType::IndexesFromZero();
float_v gathered = data[indexes];  // gathered == [0, 1, 2, ...]

Alternatively, you can use Vc::Common::AdaptSubscriptOperator to extend a given container class with the necessary subscript operator. Example:

template <typename T, typename Allocator = std::allocator<T>>

using my_vector = Vc::Common::AdaptSubscriptOperator<std::vector<T, Allocator>>;

Parameters

mem	A pointer to memory which contains objects of type `MT` at the offsets given by `indexes`.
indexes	A container/vector of offsets into `mem`. The type of `indexes` (`IT`) may either be a pointer to integers (C-array) or a vector of integers (preferrably IndexType).
mask	If a mask is given, only the active entries will be copied from memory.

Note: If you use a masked gather constructor the masked-off entries of the vector are zero-initilized.

template<typename MT , typename IT , typename = enable_if<Traits::has_subscript_operator<IT>::value>>

SimdArray (const MT *mem, const IT &indexes)

Gather constructor.

template<typename MT , typename IT , typename = enable_if<Vc::Traits::has_subscript_operator<IT>::value>>

SimdArray (const MT *mem, const IT &indexes, MaskArgument mask)

Masked gather constructor.

template<typename MT , typename IT , typename = enable_if<Vc::Traits::has_subscript_operator<IT>::value>>

void gather (const MT *mem, const IT &indexes)

Gather function.

template<typename MT , typename IT , typename = enable_if<Vc::Traits::has_subscript_operator<IT>::value>>

void gather (const MT *mem, const IT &indexes, MaskArgument mask)

Masked gather function.

Scatter functions

Stores a vector to the objects at mem[indexes[0]], mem[indexes[1]], mem[indexes[2]], ...

Parameters

mem	A pointer to memory which contains objects of type `MT` at the offsets given by `indexes`.
indexes
mask

template<typename MT , typename IT , typename = enable_if<Vc::Traits::has_subscript_operator<IT>::value>>

void scatter (MT *mem, IT &&indexes) const

Scatter function.

template<typename MT , typename IT , typename = enable_if<Vc::Traits::has_subscript_operator<IT>::value>>

void scatter (MT *mem, IT &&indexes, MaskArgument mask) const

Masked scatter function.

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...

Generators
static SimdArray	Zero ()
	Returns a vector with the entries initialized to zero.

static SimdArray	One ()
	Returns a vector with the entries initialized to one.

static SimdArray	IndexesFromZero ()
	Returns a vector with the entries initialized to 0, 1, 2, 3, 4, 5, ...

static SimdArray	Random ()
	Returns a vector with pseudo-random entries. More...

template<typename G >
static SimdArray	generate (const G &gen)
	Generate a vector object from return values of `gen` (static variant of fill).

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...

template<typename S1 , typename IT >
	SimdArray (const S1 array, const EntryType S1::member1, IT indexes)

template<typename S1 , typename IT >
	SimdArray (const S1 array, const EntryType S1::member1, IT indexes, MaskArgument mask)

template<typename S1 , typename S2 , typename IT >
	SimdArray (const S1 array, const S2 S1::member1, const EntryType S2::*member2, IT indexes)

template<typename S1 , typename S2 , typename IT >
	SimdArray (const S1 array, const S2 S1::member1, const EntryType S2::*member2, IT indexes, MaskArgument mask)

template<typename S1 , typename IT1 , typename IT2 >
	SimdArray (const S1 array, const EntryType const S1::*ptrMember1, IT1 outerIndexes, IT2 innerIndexes)

template<typename S1 , typename IT1 , typename IT2 >
	SimdArray (const S1 array, const EntryType const S1::*ptrMember1, IT1 outerIndexes, IT2 innerIndexes, MaskArgument mask)

template<typename S1 , typename IT >
void	gather (const S1 array, const EntryType S1::member1, IT indexes)

template<typename S1 , typename IT >
void	gather (const S1 array, const EntryType S1::member1, IT indexes, MaskArgument mask)

template<typename S1 , typename S2 , typename IT >
void	gather (const S1 array, const S2 S1::member1, const EntryType S2::*member2, IT indexes)

template<typename S1 , typename S2 , typename IT >
void	gather (const S1 array, const S2 S1::member1, const EntryType S2::*member2, IT indexes, MaskArgument mask)

template<typename S1 , typename IT1 , typename IT2 >
void	gather (const S1 array, const EntryType const S1::*ptrMember1, IT1 outerIndexes, IT2 innerIndexes)

template<typename S1 , typename IT1 , typename IT2 >
void	gather (const S1 array, const EntryType const S1::*ptrMember1, IT1 outerIndexes, IT2 innerIndexes, MaskArgument mask)

template<typename S1 , typename IT >
void	scatter (S1 array, EntryType S1::member1, IT indexes) const

template<typename S1 , typename IT >
void	scatter (S1 array, EntryType S1::member1, IT indexes, MaskArgument mask) const

template<typename S1 , typename S2 , typename IT >
void	scatter (S1 array, S2 S1::member1, EntryType S2::*member2, IT indexes) const

template<typename S1 , typename S2 , typename IT >
void	scatter (S1 array, S2 S1::member1, EntryType S2::*member2, IT indexes, MaskArgument mask) const

template<typename S1 , typename IT1 , typename IT2 >
void	scatter (S1 array, EntryType S1::*ptrMember1, IT1 outerIndexes, IT2 innerIndexes) const

template<typename S1 , typename IT1 , typename IT2 >
void	scatter (S1 array, EntryType S1::*ptrMember1, IT1 outerIndexes, IT2 innerIndexes, MaskArgument mask) const

SimdArray	exponent () const
	Returns the exponents of the floating-point values in the vector. More...

MaskType	isNegative () const
	Returns whether a value is negative. More...

SimdArray	copySign (const SimdArray &reference) 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...

Member Typedef Documentation

using Mask = mask_type

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

Definition at line 621 of file simdarray.h.

using MaskType = Mask

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

Definition at line 623 of file simdarray.h.

using EntryType = value_type

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

Definition at line 627 of file simdarray.h.

using IndexType = index_type

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

Definition at line 629 of file simdarray.h.

Constructor & Destructor Documentation

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 ( 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 693 of file simdarray.h.

Member Function Documentation

static constexpr std::size_t size ( )

inlinestatic

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 618 of file simdarray.h.

static SimdArray 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 662 of file simdarray.h.

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 969 of file simdarray.h.

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 976 of file simdarray.h.

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 984 of file simdarray.h.

SimdArray 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 1293 of file simdarray.h.

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

/u/mkretz/src/.Vc-dox/common/simdarray.h

Detailed Description

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

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Deprecated Members

Scalar Subscript Operators

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

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