Vc  1.4.1
SIMD Vector Classes for C++
Public Types | Public Member Functions | Static Public Member Functions | Static Public Attributes | List of all members
SimdArray< T, N, V, Wt > Class Template Reference
SIMD Array

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
TThe type of the vector's elements. The supported types currently are limited to the types supported by Vc::Vector<T>.
NThe 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.
VDon'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).
WtDon'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 82 of file fwddecl.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)
 
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, ...]

This also works for gathers into arrays of structures:

struct Point { float x, y, z; };
Vc::array<Point, 100> points;
// fill points ...
auto indexes = float_v::IndexType::IndexesFromZero();
float_v xs = data[indexes][&Point::x]; // [points[0].x, points[1].x, points[2].x, ...]
float_v ys = data[indexes][&Point::y]; // [points[0].y, points[1].y, points[2].y, ...]
float_v zs = data[indexes][&Point::z]; // [points[0].z, points[1].z, points[2].z, ...]

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
memA pointer to memory which contains objects of type MT at the offsets given by indexes.
indexesA 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).
maskIf 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<class MT , class IT , int Scale>
 SimdArray (const Common::GatherArguments< MT, IT, Scale > &args)
 
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<class MT , class IT , int Scale>
 SimdArray (const Common::GatherArguments< MT, IT, Scale > &args, MaskArgument mask)
 
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
memA 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...
 

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

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)
 

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

Member Typedef Documentation

◆ Mask

using Mask = mask_type

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

Definition at line 677 of file simdarray.h.

◆ MaskType

using MaskType = Mask

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

Definition at line 679 of file simdarray.h.

◆ EntryType

using EntryType = value_type

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

Definition at line 683 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 685 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
aThe scalar value to broadcast to all entries of the constructed vector.

Definition at line 754 of file simdarray.h.

Member Function Documentation

◆ size()

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 674 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 718 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
indexA 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 1034 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
indexA 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 1041 of file simdarray.h.

◆ operator()()

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

Writemask the vector before an assignment.

Parameters
maskThe 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 1049 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 1360 of file simdarray.h.

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