template<typename V, size_t Size>
class ROOT::Vc::Memory< V, Size, 0u >
A helper class to simplify usage of correctly aligned and padded memory, allowing both vector and scalar access.
Example:
int x = array[i];
}
int x = array.scalar(i);
}
}
This code allocates a small array and implements three equivalent loops (that do nothing useful). The loops show how scalar and vector read/write access is best implemented.
Since the size of 11 is not a multiple of int_v::Size (unless you use the scalar Vc implementation) the last write access of the vector loop would normally be out of bounds. But the Memory class automatically pads the memory such that the whole array can be accessed with correctly aligned memory addresses.
- Parameters
-
V | The vector type you want to operate on. (e.g. float_v or uint_v) |
Size | The number of entries of the scalar base type the memory should hold. This is thus the same number as you would use for a normal C array (e.g. float mem[11] becomes Memory<float_v, 11> mem). |
- See also
- Memory<V, 0u>
Definition at line 254 of file memory.h.
|
_VC_CONSTEXPR size_t | entriesCount () const |
|
_VC_CONSTEXPR size_t | vectorsCount () const |
|
Vc_ALWAYS_INLINE | Memory () |
|
| Memory (const Memory &rhs) |
|
template<size_t S> |
| Memory (const Memory< V, S > &rhs) |
|
Memory & | operator= (const Memory &rhs) |
|
template<size_t S> |
Memory & | operator= (const Memory< V, S > &rhs) |
|
Vc_ALWAYS_INLINE Memory & | operator= (const EntryType *rhs) |
|
Memory & | operator= (const V &v) |
|
Vc_ALWAYS_INLINE Vc_PURE size_t | entriesCount () const |
|
Vc_ALWAYS_INLINE Vc_PURE size_t | vectorsCount () const |
|
Vc_ALWAYS_INLINE Vc_PURE VectorPointerHelper< V, AlignedFlag > | vector (size_t i) |
|
Vc_ALWAYS_INLINE Vc_PURE const VectorPointerHelperConst< V, AlignedFlag > | vector (size_t i) const |
| Const overload of the above function. More...
|
|
Vc_ALWAYS_INLINE Vc_PURE VectorPointerHelper< V, UnalignedFlag > | vector (size_t i, int shift) |
|
Vc_ALWAYS_INLINE Vc_PURE const VectorPointerHelperConst< V, UnalignedFlag > | vector (size_t i, int shift) const |
| Const overload of the above function. More...
|
|
Vc_ALWAYS_INLINE Vc_PURE VectorPointerHelper< V, A > | vectorAt (size_t i, A) |
|
Vc_ALWAYS_INLINE Vc_PURE const VectorPointerHelperConst< V, A > | vectorAt (size_t i, A) const |
|
Vc_ALWAYS_INLINE Vc_PURE VectorPointerHelper< V, AlignedFlag > | vectorAt (size_t i) |
|
Vc_ALWAYS_INLINE Vc_PURE const VectorPointerHelperConst< V, AlignedFlag > | vectorAt (size_t i) const |
|
Vc_ALWAYS_INLINE Vc_PURE VectorPointerHelper< V, AlignedFlag > | firstVector () |
|
Vc_ALWAYS_INLINE Vc_PURE const VectorPointerHelperConst< V, AlignedFlag > | firstVector () const |
| Const overload of the above function. More...
|
|
Vc_ALWAYS_INLINE Vc_PURE VectorPointerHelper< V, AlignedFlag > | lastVector () |
|
Vc_ALWAYS_INLINE Vc_PURE const VectorPointerHelperConst< V, AlignedFlag > | lastVector () const |
| Const overload of the above function. More...
|
|
Vc_ALWAYS_INLINE Vc_PURE V | gather (const unsigned char *indexes) const |
|
Vc_ALWAYS_INLINE Vc_PURE V | gather (const unsigned short *indexes) const |
|
Vc_ALWAYS_INLINE Vc_PURE V | gather (const unsigned int *indexes) const |
|
Vc_ALWAYS_INLINE Vc_PURE V | gather (const unsigned long *indexes) const |
|
Vc_ALWAYS_INLINE void | setZero () |
|
Memory< V, Size, 0u > & | operator+= (const MemoryBase< V, P2, Dimension, RM > &rhs) |
|
Memory< V, Size, 0u > & | operator+= (EntryType rhs) |
|
Memory< V, Size, 0u > & | operator-= (const MemoryBase< V, P2, Dimension, RM > &rhs) |
|
Memory< V, Size, 0u > & | operator-= (EntryType rhs) |
|
Memory< V, Size, 0u > & | operator*= (const MemoryBase< V, P2, Dimension, RM > &rhs) |
|
Memory< V, Size, 0u > & | operator*= (EntryType rhs) |
|
Memory< V, Size, 0u > & | operator/= (const MemoryBase< V, P2, Dimension, RM > &rhs) |
|
Memory< V, Size, 0u > & | operator/= (EntryType rhs) |
|
bool | operator== (const MemoryBase< V, P2, Dimension, RM > &rhs) const |
|
bool | operator!= (const MemoryBase< V, P2, Dimension, RM > &rhs) const |
|
bool | operator< (const MemoryBase< V, P2, Dimension, RM > &rhs) const |
|
bool | operator<= (const MemoryBase< V, P2, Dimension, RM > &rhs) const |
|
bool | operator> (const MemoryBase< V, P2, Dimension, RM > &rhs) const |
|
bool | operator>= (const MemoryBase< V, P2, Dimension, RM > &rhs) const |
|
template<typename V , size_t Size>
Wrap existing data with the Memory convenience class.
This function returns a reference to a Memory<V, Size, 0> object that you must capture to avoid a copy of the whole data:
Memory<float_v, 16> &
m = Memory<float_v, 16>::fromRawData(someAlignedPointerToFloat)
- Parameters
-
ptr | An aligned pointer to memory of type V::EntryType (e.g. float for Vc::float_v). |
- Returns
- A Memory object placed at the given location in memory.
- Warning
- The pointer
ptr
passed to this function must be aligned according to the alignment restrictions of V
.
-
The size of the accessible memory must match
Size
. This includes the required padding at the end to allow the last entries to be accessed via vectors. If you know what you are doing you might violate this constraint.
-
It is your responsibility to ensure that the memory is released correctly (not too early/not leaked). This function simply adds convenience functions to access the memory.
Definition at line 309 of file memory.h.