Vc 1.4.5
SIMD Vector Classes for C++
 
Loading...
Searching...
No Matches
Public Types | Public Member Functions | List of all members
MemoryBase< V, Parent, Dimension, RowMemory > Class Template Reference

Detailed Description

template<typename V, typename Parent, int Dimension, typename RowMemory>
class Vc::Common::MemoryBase< V, Parent, Dimension, RowMemory >

Common interface to all Memory classes, independent of allocation on the stack or heap.

Parameters
VThe vector type you want to operate on. (e.g. float_v or uint_v)
ParentThis type is the complete type of the class that derives from MemoryBase.
DimensionThe number of dimensions the implementation provides.
RowMemoryClass to be used to work on a single row.

Definition at line 40 of file memoryfwd.h.

#include <Vc/Memory>

Inherits MemoryDimensionBase< V, Parent, Dimension, RowMemory >.

Public Types

typedef V::EntryType EntryType
 The type of the scalar entries in the array.
 

Public Member Functions

size_t entriesCount () const
 
size_t vectorsCount () const
 
template<typename Flags = AlignedTag>
MemoryVectorIterator< V, Flags > begin (Flags flags=Flags())
 Return a (vectorized) iterator to the start of this memory object.
 
template<typename Flags = AlignedTag>
MemoryVectorIterator< const V, Flags > begin (Flags flags=Flags()) const
 const overload of the above
 
template<typename Flags = AlignedTag>
MemoryVectorIterator< V, Flags > end (Flags flags=Flags())
 Return a (vectorized) iterator to the end of this memory object.
 
template<typename Flags = AlignedTag>
MemoryVectorIterator< const V, Flags > end (Flags flags=Flags()) const
 const overload of the above
 
template<typename Flags = AlignedTag>
std::enable_if<!std::is_convertible< Flags, int >::value, vector_reference< Flags > >::type vector (size_t i, Flags=Flags())
 
template<typename Flags = AlignedTag>
std::enable_if<!std::is_convertible< Flags, int >::value, const_vector_reference< Flags > >::type vector (size_t i, Flags=Flags()) const
 Const overload of the above function.
 
template<typename Flags = UnalignedTag>
vector_reference< Flags > vectorAt (size_t i, Flags flags=Flags())
 
template<typename Flags = UnalignedTag>
const_vector_reference< Flags > vectorAt (size_t i, Flags flags=Flags()) const
 Const overload of the above function.
 
template<typename ShiftT , typename Flags = decltype(Unaligned)>
std::enable_if< std::is_convertible< ShiftT, int >::value, vector_reference< decltype(std::declval< Flags >()|Unaligned)> ::type vector (size_t i, ShiftT shift, Flags=Flags())
 
template<typename ShiftT , typename Flags = decltype(Unaligned)>
std::enable_if< std::is_convertible< ShiftT, int >::value, const_vector_reference< decltype(std::declval< Flags >()|Unaligned)> ::type vector (size_t i, ShiftT shift, Flags=Flags()) const
 Const overload of the above function.
 
template<typename Flags = AlignedTag>
vector_reference< Flags > firstVector (Flags f=Flags())
 
template<typename Flags = AlignedTag>
const_vector_reference< Flags > firstVector (Flags f=Flags()) const
 Const overload of the above function.
 
template<typename Flags = AlignedTag>
vector_reference< Flags > lastVector (Flags f=Flags())
 
template<typename Flags = AlignedTag>
const_vector_reference< Flags > lastVector (Flags f=Flags()) const
 Const overload of the above function.
 
void setZero ()
 Zero the whole memory area.
 
template<typename U >
Parent & operator= (U &&x)
 Assign a value to all vectors in the array.
 
template<typename P2 , typename RM >
Parent & operator+= (const MemoryBase< V, P2, Dimension, RM > &rhs)
 (Inefficient) shorthand to add up two arrays.
 
template<typename P2 , typename RM >
Parent & operator-= (const MemoryBase< V, P2, Dimension, RM > &rhs)
 (Inefficient) shorthand to subtract two arrays.
 
template<typename P2 , typename RM >
Parent & operator*= (const MemoryBase< V, P2, Dimension, RM > &rhs)
 (Inefficient) shorthand to multiply two arrays.
 
template<typename P2 , typename RM >
Parent & operator/= (const MemoryBase< V, P2, Dimension, RM > &rhs)
 (Inefficient) shorthand to divide two arrays.
 
Parent & operator+= (EntryType rhs)
 (Inefficient) shorthand to add a value to an array.
 
Parent & operator-= (EntryType rhs)
 (Inefficient) shorthand to subtract a value from an array.
 
Parent & operator*= (EntryType rhs)
 (Inefficient) shorthand to multiply a value to an array.
 
Parent & operator/= (EntryType rhs)
 (Inefficient) shorthand to divide an array with a value.
 
template<typename P2 , typename RM >
bool operator== (const MemoryBase< V, P2, Dimension, RM > &rhs) const
 (Inefficient) shorthand compare equality of two arrays.
 
template<typename P2 , typename RM >
bool operator!= (const MemoryBase< V, P2, Dimension, RM > &rhs) const
 (Inefficient) shorthand compare two arrays.
 
template<typename P2 , typename RM >
bool operator< (const MemoryBase< V, P2, Dimension, RM > &rhs) const
 (Inefficient) shorthand compare two arrays.
 
template<typename P2 , typename RM >
bool operator<= (const MemoryBase< V, P2, Dimension, RM > &rhs) const
 (Inefficient) shorthand compare two arrays.
 
template<typename P2 , typename RM >
bool operator> (const MemoryBase< V, P2, Dimension, RM > &rhs) const
 (Inefficient) shorthand compare two arrays.
 
template<typename P2 , typename RM >
bool operator>= (const MemoryBase< V, P2, Dimension, RM > &rhs) const
 (Inefficient) shorthand compare two arrays.
 

Member Function Documentation

◆ entriesCount()

template<typename V , typename Parent , int Dimension, typename RowMemory >
size_t entriesCount ( ) const
inline
Returns
the number of scalar entries in the array. This function is optimized away if a constant size array is used.

Definition at line 384 of file memorybase.h.

◆ vectorsCount()

template<typename V , typename Parent , int Dimension, typename RowMemory >
size_t vectorsCount ( ) const
inline
Returns
the number of vector entries that span the array. This function is optimized away if a constant size array is used.

Definition at line 389 of file memorybase.h.

Referenced by Memory< V, Size1, Size2, InitPadding >::operator=(), and Memory< V, 0u, 0u, true >::operator=().

◆ vector() [1/3]

template<typename V , typename Parent , int Dimension, typename RowMemory >
template<typename Flags = AlignedTag>
std::enable_if<!std::is_convertible< Flags, int >::value, vector_reference< Flags > >::type vector ( size_t i,
Flags = Flags() )
inline
Parameters
iSelects the offset, where the vector should be read.
Returns
a smart object to wrap the i-th vector in the memory.

The return value can be used as any other vector object. I.e. you can substitute something like

float_v a = ..., b = ...;
a += b;
Vc::Vector
The main vector class for expressing data parallelism.
Definition vector.h:126

with

mem.vector(i) += b;

This function ensures that only aligned loads and stores are used. Thus it only allows to access memory at fixed strides. If access to known offsets from the aligned vectors is needed the vector(size_t, int) function can be used.

Definition at line 436 of file memorybase.h.

◆ vector() [2/3]

template<typename V , typename Parent , int Dimension, typename RowMemory >
template<typename Flags = AlignedTag>
std::enable_if<!std::is_convertible< Flags, int >::value, const_vector_reference< Flags > >::type vector ( size_t i,
Flags = Flags() ) const
inline

Const overload of the above function.

Parameters
iSelects the offset, where the vector should be read.
Returns
a smart object to wrap the i-th vector in the memory.

Definition at line 450 of file memorybase.h.

◆ vectorAt() [1/2]

template<typename V , typename Parent , int Dimension, typename RowMemory >
template<typename Flags = UnalignedTag>
vector_reference< Flags > vectorAt ( size_t i,
Flags flags = Flags() )
inline
Returns
a smart object to wrap the vector starting from the i-th scalar entry in the memory.

Example:

Memory<float_v, N> mem;
mem.setZero();
for (int i = 0; i < mem.entriesCount(); i += float_v::Size) {
mem.vectorAt(i) += b;
}
Vc::Common::MemoryBase::setZero
void setZero()
Zero the whole memory area.
Definition memorybase.h:591
Vc::Common::MemoryBase::vectorAt
vector_reference< Flags > vectorAt(size_t i, Flags flags=Flags())
Definition memorybase.h:475
Vc::Common::Memory
A helper class for fixed-size two-dimensional arrays.
Definition memoryfwd.h:37
Vc::Common::Memory::entriesCount
static constexpr size_t entriesCount()
Definition memory.h:111
Vc::Vector::Size
static constexpr size_t Size
Returns the number of scalar components ( ) in a vector of this type.
Definition vector.h:772
Parameters
iSpecifies the scalar entry from where the vector will be loaded/stored. I.e. the values scalar(i), scalar(i + 1), ..., scalar(i + V::Size - 1) will be read/overwritten.
flagsYou must take care to determine whether an unaligned load/store is required. Per default an unaligned load/store is used. If i is a multiple of V::Size you may want to pass Vc::Aligned here.

Definition at line 475 of file memorybase.h.

◆ vectorAt() [2/2]

template<typename V , typename Parent , int Dimension, typename RowMemory >
template<typename Flags = UnalignedTag>
const_vector_reference< Flags > vectorAt ( size_t i,
Flags flags = Flags() ) const
inline

Const overload of the above function.

Returns
a smart object to wrap the vector starting from the i-th scalar entry in the memory.
Parameters
iSpecifies the scalar entry from where the vector will be loaded/stored. I.e. the values scalar(i), scalar(i + 1), ..., scalar(i + V::Size - 1) will be read/overwritten.
flagsYou must take care to determine whether an unaligned load/store is required. Per default an unaligned load/store is used. If i is a multiple of V::Size you may want to pass Vc::Aligned here.

Definition at line 492 of file memorybase.h.

◆ vector() [3/3]

template<typename V , typename Parent , int Dimension, typename RowMemory >
template<typename ShiftT , typename Flags = decltype(Unaligned)>
std::enable_if< std::is_convertible< ShiftT, int >::value, vector_reference< decltype(std::declval< Flags >()|Unaligned)> ::type vector ( size_t i,
ShiftT shift,
Flags = Flags() )
inline
Returns
a smart object to wrap the i-th vector + shift in the memory.

This function ensures that only unaligned loads and stores are used. It allows to access memory at any location aligned to the entry type.

Parameters
iSelects the memory location of the i-th vector. Thus if V::Size == 4 and i is set to 3 the base address for the load/store will be the 12th entry (same as &mem[12]).
shiftShifts the base address determined by parameter i by shift many entries. Thus vector(3, 1) for V::Size == 4 will load/store the 13th - 16th entries (same as &mem[13]).
Note
Any shift value is allowed as long as you make sure it stays within bounds of the allocated memory. Shift values that are a multiple of V::Size will not result in aligned loads. You have to use the above vector(size_t) function for aligned loads instead.
Thus a simple way to access vectors randomly is to set i to 0 and use shift as the parameter to select the memory address:
// don't use:
mem.vector(i / V::Size, i % V::Size) += 1;
// instead use:
mem.vector(0, i) += 1;

Definition at line 529 of file memorybase.h.

◆ firstVector()

template<typename V , typename Parent , int Dimension, typename RowMemory >
template<typename Flags = AlignedTag>
vector_reference< Flags > firstVector ( Flags f = Flags())
inline
Returns
the first vector in the allocated memory.

This function is simply a shorthand for vector(0).

Definition at line 553 of file memorybase.h.

◆ lastVector()

template<typename V , typename Parent , int Dimension, typename RowMemory >
template<typename Flags = AlignedTag>
vector_reference< Flags > lastVector ( Flags f = Flags())
inline
Returns
the last vector in the allocated memory.

This function is simply a shorthand for vector(vectorsCount() - 1).

Definition at line 571 of file memorybase.h.

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