Memory< V, Size1, Size2, InitPadding > Class Template Reference

Detailed Description

template<typename V, size_t Size1, size_t Size2, bool InitPadding>
class Vc::Common::Memory< V, Size1, Size2, InitPadding >

A helper class for fixed-size two-dimensional arrays.

Parameters

V	The vector type you want to operate on. (e.g. float_v or uint_v)
Size1	Number of rows
Size2	Number of columns

Definition at line 67 of file memory.h.

#include <Vc/Memory>

Inherits MemoryBase< V, Memory< V, Size1, Size2, InitPadding >, 2, Memory< V, Size2, 0, InitPadding > >.

Public Member Functions
template<typename Parent, typename RM>
Memory &	operator= (const MemoryBase< V, Parent, 2, RM > &rhs)
	Copies the data from a different object.
Memory &	operator= (const V &v)
	Initialize all data with the given vector.
std::enable_if<!std::is_convertible< Flags, int >::value, vector_reference< Flags > >::type	vector (size_t i, Flags=Flags())
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.
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())
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.
size_t	entriesCount () const
size_t	vectorsCount () const
MemoryVectorIterator< V, Flags >	begin (Flags flags=Flags())
	Return a (vectorized) iterator to the start of this memory object.
MemoryVectorIterator< V, Flags >	end (Flags flags=Flags())
	Return a (vectorized) iterator to the end of this memory object.
vector_reference< Flags >	vectorAt (size_t i, Flags flags=Flags())
vector_reference< Flags >	firstVector (Flags f=Flags())
vector_reference< Flags >	lastVector (Flags f=Flags())
void	setZero ()
	Zero the whole memory area.
Memory< V, Size1, Size2, InitPadding > &	operator+= (const MemoryBase< V, P2, Dimension, RM > &rhs)
	(Inefficient) shorthand to add up two arrays.
Memory< V, Size1, Size2, InitPadding > &	operator-= (const MemoryBase< V, P2, Dimension, RM > &rhs)
	(Inefficient) shorthand to subtract two arrays.
Memory< V, Size1, Size2, InitPadding > &	operator*= (const MemoryBase< V, P2, Dimension, RM > &rhs)
	(Inefficient) shorthand to multiply two arrays.
Memory< V, Size1, Size2, InitPadding > &	operator/= (const MemoryBase< V, P2, Dimension, RM > &rhs)
	(Inefficient) shorthand to divide two arrays.
bool	operator== (const MemoryBase< V, P2, Dimension, RM > &rhs) const
	(Inefficient) shorthand compare equality of two arrays.
bool	operator!= (const MemoryBase< V, P2, Dimension, RM > &rhs) const
	(Inefficient) shorthand compare two arrays.
bool	operator< (const MemoryBase< V, P2, Dimension, RM > &rhs) const
	(Inefficient) shorthand compare two arrays.
bool	operator<= (const MemoryBase< V, P2, Dimension, RM > &rhs) const
	(Inefficient) shorthand compare two arrays.
bool	operator> (const MemoryBase< V, P2, Dimension, RM > &rhs) const
	(Inefficient) shorthand compare two arrays.
bool	operator>= (const MemoryBase< V, P2, Dimension, RM > &rhs) const
	(Inefficient) shorthand compare two arrays.

Static Public Member Functions
static constexpr size_t	rowsCount ()
static constexpr size_t	entriesCount ()
static constexpr size_t	vectorsCount ()

Member Function Documentation

rowsCount()

template<typename V, size_t Size1, size_t Size2, bool InitPadding>

constexpr size_t rowsCount ( )

inlinestaticconstexpr

Returns

the number of rows in the array.

Note

This function can be eliminated by an optimizing compiler.

Definition at line 102 of file memory.h.

entriesCount() [1/2]

template<typename V, size_t Size1, size_t Size2, bool InitPadding>

constexpr size_t entriesCount ( )

inlinestaticconstexpr

Returns

the number of scalar entries in the whole array.

Warning

Do not use this function for scalar iteration over the array since there will be padding between rows if Size2 is not divisible by V::Size.

Note

This function can be optimized into a compile-time constant.

Definition at line 111 of file memory.h.

vectorsCount() [1/2]

template<typename V, size_t Size1, size_t Size2, bool InitPadding>

constexpr size_t vectorsCount ( )

inlinestaticconstexpr

Returns

the number of vectors in the whole array.

Note

This function can be optimized into a compile-time constant.

Definition at line 117 of file memory.h.

operator=() [1/2]

template<typename V, size_t Size1, size_t Size2, bool InitPadding>

template<typename Parent, typename RM>

Memory & operator= ( const MemoryBase< V, Parent, 2, RM > & rhs )

inline

Copies the data from a different object.

Parameters

rhs	The object to copy the data from.

Returns

reference to the modified Memory object.

Note

Both objects must have the exact same vectorsCount().

Definition at line 129 of file memory.h.

operator=() [2/2]

template<typename V, size_t Size1, size_t Size2, bool InitPadding>

Memory & operator= ( const V & v )

inline

Initialize all data with the given vector.

Parameters

v	This vector will be used to initialize the memory.

Returns

reference to the modified Memory object.

Definition at line 147 of file memory.h.

vector() [1/3]

template<typename V, size_t Size1, size_t Size2, bool InitPadding>

std::enable_if<!std::is_convertible< Flags, int >::value, vector_reference< Flags > >::type vector ( size_t i, Flags = Flags() )

inline

Parameters

i	Selects 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;

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, size_t Size1, size_t Size2, bool InitPadding>

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

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

vector() [3/3]

template<typename V, size_t Size1, size_t Size2, bool InitPadding>

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

i	Selects 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]).
shift	Shifts 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.

entriesCount() [2/2]

size_t entriesCount ( ) const

inlineinherited

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() [2/2]

size_t vectorsCount ( ) const

inlineinherited

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.

vectorAt()

vector_reference< Flags > vectorAt ( size_t i, Flags flags = Flags() )

inlineinherited

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;
}

Parameters

i	Specifies 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.
flags	You 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.

firstVector()

vector_reference< Flags > firstVector ( Flags f = Flags() )

inlineinherited

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

vector_reference< Flags > lastVector ( Flags f = Flags() )

inlineinherited

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 file:

• /home/abuild/rpmbuild/BUILD/Vc-1.4.5-build/Vc-1.4.5/Vc/common/memory.h