VectorTypes

#include <poplar/VectorTypes.hpp>
template<typename T, unsigned MinAlign, bool Interleaved>
struct VLayoutEnumToType<T, VectorLayout::SPAN, MinAlign, Interleaved>
#include <VectorTypes.hpp>

Vector.

Public Types

using type = SpanVectorBase<UnboxIO_t<T>, UnboxIO_baseT<T>, MinAlign>
template<typename T, unsigned MinAlign, bool Interleaved>
struct VLayoutEnumToType<T, VectorLayout::SHORT_SPAN, MinAlign, Interleaved>

Public Types

using type = ShortSpanVectorBase<UnboxIO_t<T>, UnboxIO_baseT<T>, MinAlign>
template<typename T, unsigned MinAlign, bool Interleaved>
struct VLayoutEnumToType<T, VectorLayout::ONE_PTR, MinAlign, Interleaved>

Public Types

using type = OnePtrVectorBase<UnboxIO_t<T>, UnboxIO_baseT<T>, MinAlign>
template<typename T, unsigned MinAlign, bool Interleaved>
struct VLayoutEnumToType<T, VectorLayout::SCALED_PTR32, MinAlign, Interleaved>

Public Types

using type = ScaledPtr32VectorBase<UnboxIO_t<T>, MinAlign>
template<typename T, unsigned MinAlign, bool Interleaved>
struct VLayoutEnumToType<T, VectorLayout::SCALED_PTR64, MinAlign, Interleaved>

Public Types

using type = ScaledPtr64VectorBase<UnboxIO_t<T>, MinAlign>
template<typename T, unsigned MinAlign, bool Interleaved>
struct VLayoutEnumToType<T, VectorLayout::SCALED_PTR128, MinAlign, Interleaved>

Public Types

using type = ScaledPtr128VectorBase<UnboxIO_t<T>, MinAlign>
template<typename T, unsigned MinAlign, bool Interleaved>
struct ImplicitVLayoutEnumToType<T, VectorLayout::SPAN, MinAlign, Interleaved>

Public Types

using type = SpanVectorBaseImplicitDeref<UnboxIO_t<T>, MinAlign>
template<typename T, unsigned MinAlign, bool Interleaved>
struct ImplicitVLayoutEnumToType<T, VectorLayout::ONE_PTR, MinAlign, Interleaved>

Public Types

using type = OnePtrVectorBaseImplicitDeref<UnboxIO_t<T>, MinAlign>
template<typename T, unsigned MinAlign, bool Interleaved>
struct ImplicitVLayoutEnumToType<T, VectorLayout::SCALED_PTR32, MinAlign, Interleaved>

Public Types

using type = ScaledPtr32VectorBaseImplicitDeref<UnboxIO_t<T>, MinAlign>
template<typename T, unsigned MinAlign, bool Interleaved>
struct ImplicitVLayoutEnumToType<T, VectorLayout::SCALED_PTR64, MinAlign, Interleaved>

Public Types

using type = ScaledPtr64VectorBaseImplicitDeref<UnboxIO_t<T>, MinAlign>
template<typename T, unsigned MinAlign, bool Interleaved>
struct ImplicitVLayoutEnumToType<T, VectorLayout::SCALED_PTR128, MinAlign, Interleaved>

Public Types

using type = ScaledPtr128VectorBaseImplicitDeref<UnboxIO_t<T>, MinAlign>
template<typename T, VectorLayout L, unsigned MinAlign, bool Interleaved>
struct VectorOrder<poplar::Vector<T, L, MinAlign, Interleaved>>

Public Static Attributes

static constexpr unsigned value = 1 + VectorOrder<T>::value
namespace poplar

Poplar classes and functions.

template<class Base, unsigned MinAlign>
struct BaseWithAlign : public Base

Subclassed by poplar::OnePtrVectorBase< T, baseT, MinAlign >, poplar::ScaledPtr128VectorBase< T, MinAlign >, poplar::ScaledPtr32VectorBase< T, MinAlign >, poplar::ScaledPtr64VectorBase< T, MinAlign >, poplar::ShortSpanVectorBase< T, baseT, MinAlign >, poplar::SpanVectorBase< T, baseT, MinAlign >, poplar::ScaledPtr32VectorBase< DeltaN, 4 >

Public Functions

inline void *begin() const
template<typename T, VectorLayout L, unsigned MinAlign, bool Interleaved>
class InOut<Vector<T, L, MinAlign, Interleaved>> : public poplar::Vector<T, L, MinAlign, Interleaved>

Public Types

using baseT = T

Public Functions

inline const Vector<T, L, MinAlign, Interleaved> &operator*() const
inline const Vector<T, L, MinAlign, Interleaved> *operator->() const
inline Vector<T, L, MinAlign, Interleaved> &operator*()
inline Vector<T, L, MinAlign, Interleaved> *operator->()
template<typename T, VectorLayout L, unsigned MinAlign, bool Interleaved>
class Input<Vector<T, L, MinAlign, Interleaved>> : public poplar::Vector<const T, L, MinAlign, Interleaved>
#include <VectorTypes.hpp>

Create a 1D Input edge for a Poplar vertex, with dereference (->) and indirection (*) operators.

Example use 

 Input<Vector<T, L, MinAlign, Interleaved> edgeName;

In compute() method: 

 auto data0 = *edgeName;
 auto ref = &edgeName;
 auto iterator = ref->begin();

A class for use in C++ vertex definitions, which defines an Input to the vertex. The input is a 1D vector of data stored contiguously in memory. Because it is defined as an input, Poplar will assume that its content is unchanged by the vertex it is attached to. The data can be described as a “live” variable when the vertex is called.

Param T

The type of data stored in the input.

Param L

The type of vector layout used to describe the vector. For example ONE_PTR (pointer to data only) or SPAN (pointer to data and length). See FieldTypes.hpp Defaults to SPAN

Param MinAlign

The minimum alignment of the start of the data in bytes. This Defaults to the sizeof(T) although larger alignments can be specified, which must be a multiple of sizeof(T).

Param Interleaved

Indicates that the data must be stored in interleaved memory.

Public Types

using type = Vector<const T, L, MinAlign, Interleaved>
using baseT = const T

Public Functions

inline const Vector<const T, L, MinAlign, Interleaved> &operator*() const
inline const Vector<const T, L, MinAlign, Interleaved> *operator->() const
template<typename T, typename baseT, unsigned MinAlign>
class OnePtrVectorBase : public poplar::BaseWithAlign<PtrBase<baseT>, MinAlign>
#include <VectorTypes.hpp>

Define the begin() member function and the index [] operator for the ONE_PTR layout.

The layout is applicable to the 1D and 2D vectors. In the case of the 2D vector it applies to both inner and outer vectors. There are no end() or size() member functions as there is no length field.

Example use 

 Input<Vector<T, ONE_PTR> myInput;
 Vector<Input<Vector<T, ONE_PTR>, ONE_PTR> myInput2D;

In compute() method: 

 auto dataVectorPtr = myInput2D[1];
 auto startIterator = myInput2D.begin();
 auto data0 = myInput[0];
 auto data1 = myInput2D[0][1];

Public Types

typedef T *iterator

Public Functions

inline const_iterator begin() const
inline iterator begin()
inline  __attribute__ ((always_inline)) const T &operator[](std

Public Members

const typedef T * const_iterator

Private Types

using Base = BaseWithAlign<PtrBase<baseT>, MinAlign>
template<typename T, unsigned MinAlign>
class OnePtrVectorBaseImplicitDeref : public poplar::PtrBase<T>

Public Types

typedef DerefRandomAccessIterator<T, MinAlign> iterator
typedef DerefRandomAccessIterator<const T, MinAlign> const_iterator

Public Functions

inline const_iterator begin() const
inline iterator begin()
inline const T &operator[](std::size_t index) const
inline T &operator[](std::size_t index)

Private Types

using Base = PtrBase<T>
template<typename T, VectorLayout L, unsigned MinAlign, bool Interleaved>
class Output<Vector<T, L, MinAlign, Interleaved>> : public poplar::Vector<T, L, MinAlign, Interleaved>

Public Types

using baseT = T

Public Functions

inline const Vector<T, L, MinAlign, Interleaved> &operator*() const
inline const Vector<T, L, MinAlign, Interleaved> *operator->() const
inline Vector<T, L, MinAlign, Interleaved> &operator*()
inline Vector<T, L, MinAlign, Interleaved> *operator->()
template<typename T>
struct PtrBase

Subclassed by poplar::BaseWithAlign< PtrBase< baseT >, MinAlign >, poplar::OnePtrVectorBaseImplicitDeref< T, MinAlign >, poplar::PtrBase< const quarter >

Public Functions

inline void *begin() const

Public Members

void *ptr
template<>
struct PtrBase<const quarter> : public poplar::PtrBase<quarter>

Public Functions

__attribute__((always_inline)) inline const MetadataType *getMetadata()
template<>
struct PtrBase<quarter>

Public Functions

inline void *begin() const
__attribute__((always_inline)) inline const MetadataType *getMetadata()

Public Members

void *ptr
void *meta
struct ScaledBase128

Subclassed by poplar::BaseWithAlign< ScaledBase128, MinAlign >, poplar::ScaledPtr128VectorBaseImplicitDeref< T, MinAlign >

Public Functions

ScaledBase128() = default
inline void set(void *p)
inline ScaledBase128(void *p)
inline void *begin() const

Public Members

unsigned short pOffset
struct ScaledBase32

Subclassed by poplar::BaseWithAlign< ScaledBase32, MinAlign >, poplar::ScaledPtr32VectorBaseImplicitDeref< T, MinAlign >

Public Functions

ScaledBase32() = default
inline void set(void *p)
inline ScaledBase32(void *p)
inline void *begin() const

Public Members

unsigned short pOffset

Public Static Attributes

static const uintptr_t memBase = 0x40000
struct ScaledBase64

Subclassed by poplar::BaseWithAlign< ScaledBase64, MinAlign >, poplar::ScaledPtr64VectorBaseImplicitDeref< T, MinAlign >

Public Functions

ScaledBase64() = default
inline void set(void *p)
inline ScaledBase64(void *p)
inline void *begin() const

Public Members

unsigned short pOffset
template<typename T, unsigned MinAlign>
class ScaledPtr128VectorBase : public poplar::BaseWithAlign<ScaledBase128, MinAlign>
#include <VectorTypes.hpp>

Define the begin() member function and the index [] operator for the SCALED_PTR128 layout.

The layout is applicable to the 1D and 2D vectors. In the case of the 2D vector it applies to both inner and outer vectors. There are no end() or size() member functions as there is no length field.

Example use 

 Input<Vector<T, SCALED_PTR128> myInput;
 Vector<Input<Vector<T, SCALED_PTR128>, SCALED_PTR128> myInput2D;

In compute() method: 

 auto dataVectorPtr = myInput2D[1];
 auto startIterator = myInput2D.begin();
 auto data0 = myInput[0];
 auto data1 = myInput2D[0][1];

Public Types

typedef T *iterator

Public Functions

inline const_iterator begin() const
inline iterator begin()
inline  __attribute__ ((always_inline)) const T &operator[](std

Public Members

const typedef T * const_iterator

Private Types

using Base = BaseWithAlign<ScaledBase128, MinAlign>
template<typename T, unsigned MinAlign>
class ScaledPtr128VectorBaseImplicitDeref : public poplar::ScaledBase128

Public Types

typedef DerefRandomAccessIterator<T, MinAlign> iterator
typedef DerefRandomAccessIterator<const T, MinAlign> const_iterator

Public Functions

inline const_iterator begin() const
inline iterator begin()
inline const T &operator[](std::size_t index) const
inline T &operator[](std::size_t index)

Private Types

using Base = ScaledBase128
template<typename T, unsigned MinAlign>
class ScaledPtr32VectorBase : public poplar::BaseWithAlign<ScaledBase32, MinAlign>
#include <VectorTypes.hpp>

Define the begin() member function and the index [] operator for the SCALED_PTR32 vertex state layout.

The layout is applicable to the 1D and 2D vectors. In the case of the 2D vector it applies to both inner and outer vectors. There are no end() or size() member functions as there is no length field.

Example use 

 Input<Vector<T, SCALED_PTR32> myInput;
 Vector<Input<Vector<T, SCALED_PTR32>, SCALED_PTR32> myInput2D;

In compute() method: 

 auto dataVectorPtr = myInput2D[1];
 auto startIterator = myInput2D.begin();
 auto data0 = myInput[0];
 auto data1 = myInput2D[0][1];

Public Types

typedef T *iterator

Public Functions

inline const_iterator begin() const
inline iterator begin()
inline  __attribute__ ((always_inline)) const T &operator[](std

Public Members

const typedef T * const_iterator

Private Types

using Base = BaseWithAlign<ScaledBase32, MinAlign>
template<typename T, unsigned MinAlign>
class ScaledPtr32VectorBaseImplicitDeref : public poplar::ScaledBase32

Public Types

typedef DerefRandomAccessIterator<T, MinAlign> iterator
typedef DerefRandomAccessIterator<const T, MinAlign> const_iterator

Public Functions

inline const_iterator begin() const
inline iterator begin()
inline const T &operator[](std::size_t index) const
inline T &operator[](std::size_t index)

Private Types

using Base = ScaledBase32
template<typename T, unsigned MinAlign>
class ScaledPtr64VectorBase : public poplar::BaseWithAlign<ScaledBase64, MinAlign>
#include <VectorTypes.hpp>

Define the begin() member function and the index [] operator for the SCALED_PTR64 2D vertex state layout.

The layout is applicable to the 1D and 2D vectors. In the case of the 2D vector it applies to both inner and outer vectors. There are no end() or size() member functions as there is no length field.

Example use 

 Input<Vector<T, SCALED_PTR64> myInput;
 Vector<Input<Vector<T, SCALED_PTR64>, SCALED_PTR64> myInput2D;

In compute() method: 

 auto dataVectorPtr = myInput2D[1];
 auto startIterator = myInput2D.begin();
 auto data0 = myInput[0];
 auto data1 = myInput2D[0][1];

Public Types

typedef T *iterator

Public Functions

inline const_iterator begin() const
inline iterator begin()
inline  __attribute__ ((always_inline)) const T &operator[](std

Public Members

const typedef T * const_iterator

Private Types

using Base = BaseWithAlign<ScaledBase64, MinAlign>
template<typename T, unsigned MinAlign>
class ScaledPtr64VectorBaseImplicitDeref : public poplar::ScaledBase64

Public Types

typedef DerefRandomAccessIterator<T, MinAlign> iterator
typedef DerefRandomAccessIterator<const T, MinAlign> const_iterator

Public Functions

inline const_iterator begin() const
inline iterator begin()
inline const T &operator[](std::size_t index) const
inline T &operator[](std::size_t index)

Private Types

using Base = ScaledBase64
template<typename T, typename baseT, unsigned MinAlign>
class ShortSpanVectorBase : public poplar::BaseWithAlign<ShortVectorBase<baseT>, MinAlign>
#include <VectorTypes.hpp>

Define the begin(), end() and empty() member functions and the index [] operator for the SHORT_SPAN layout.

The layout is applicable to the 1D and 2D vectors. In the case of the 2D vector it applies to both inner and outervectors. The size() member function is defined by the ShortVectorBase class, see the header file for details.

Example use 

 Input<Vector<T, SHORT_SPAN> myInput;
 Vector<Input<Vector<T, SHORT_SPAN>, SHORT_SPAN> myInput2D;

In compute() method: 

 auto numInnerVectors = myInput2D.size();
 auto dataVectorPtr = myInput2D[1];
 auto startIterator = myInput2D.begin();
 auto data0 = myInput[0];
 auto data1 = myInput2D[0][1];

Public Types

typedef T *iterator

Public Functions

inline const_iterator begin() const
inline const_iterator end() const
inline iterator begin()
inline iterator end()
inline const T &operator[](std::size_t index) const
inline T &operator[](std::size_t index)
inline bool empty() const

Public Members

const typedef T * const_iterator

Private Types

using Base = BaseWithAlign<ShortVectorBase<baseT>, MinAlign>
template<typename T, unsigned MinAlign>
class ShortSpanVectorBaseImplicitDeref : public poplar::ShortVectorBase<T>

Public Types

typedef DerefRandomAccessIterator<T, MinAlign> iterator
typedef DerefRandomAccessIterator<const T, MinAlign> const_iterator

Public Functions

inline const_iterator begin() const
inline const_iterator end() const
inline iterator begin()
inline iterator end()
inline const T &operator[](std::size_t index) const
inline T &operator[](std::size_t index)
inline bool empty() const

Private Types

using Base = ShortVectorBase<T>
template<typename T>
struct ShortVectorBase

Subclassed by poplar::BaseWithAlign< ShortVectorBase< baseT >, MinAlign >, poplar::ShortSpanVectorBaseImplicitDeref< T, MinAlign >, poplar::ShortVectorBase< const quarter >

Public Functions

inline void *begin() const
inline std::uint32_t size() const

Public Members

uint32_t address
uint32_t size_
template<>
struct ShortVectorBase<const quarter> : public poplar::ShortVectorBase<quarter>

Public Functions

__attribute__((always_inline)) inline const MetadataType *getMetadata()
template<>
struct ShortVectorBase<quarter>

Public Functions

inline void *begin() const
inline std::uint32_t size() const
__attribute__((always_inline)) inline const MetadataType *getMetadata()

Public Members

uint32_t address
uint32_t size_
void *meta
template<typename T, typename baseT, unsigned MinAlign>
class SpanVectorBase : public poplar::BaseWithAlign<VectorBase<baseT>, MinAlign>
#include <VectorTypes.hpp>

Define the begin(), end() and empty() member functions and the index [] operator for the SPAN layout.

The layout is applicable to the 1D and 2D vectors. In the case of the 2D vector it applies to both inner and outer vectors. The size() member function is defined by the VectorBase class, see the header file for details.

Example use 

 Input<Vector<T, SPAN> myInput;
 Vector<Input<Vector<T, SPAN>, SPAN> myInput2D;

In compute() method: 

 auto numInnerVectors = myInput2D.size();
 auto dataVectorPtr = myInput2D[1];
 auto startIterator = myInput2D.begin();
 auto data0 = myInput[0];
 auto data1 = myInput2D[0][1];

Public Types

typedef T *iterator

Public Functions

inline const_iterator begin() const
inline const_iterator end() const
inline iterator begin()
inline iterator end()
inline const T &operator[](std::size_t index) const
inline T &operator[](std::size_t index)
inline bool empty() const

Public Members

const typedef T * const_iterator

Private Types

using Base = BaseWithAlign<VectorBase<baseT>, MinAlign>
template<typename T, unsigned MinAlign>
class SpanVectorBaseImplicitDeref : public poplar::VectorBase<T>

Public Types

typedef DerefRandomAccessIterator<T, MinAlign> iterator
typedef DerefRandomAccessIterator<const T, MinAlign> const_iterator

Public Functions

inline const_iterator begin() const
inline const_iterator end() const
inline iterator begin()
inline iterator end()
inline const T &operator[](std::size_t index) const
inline T &operator[](std::size_t index)
inline bool empty() const

Private Types

using Base = VectorBase<T>
template<typename T, VectorLayout L = VectorLayout::SPAN, unsigned MinAlign = detail::max(alignof(T), VectorLayoutTraits<L>::MinAlign), bool Interleaved = false>
struct Vector

Subclassed by poplar::InOut< Vector< T, L, MinAlign, Interleaved > >, poplar::Input< Vector< T, L, MinAlign, Interleaved > >, poplar::Output< Vector< T, L, MinAlign, Interleaved > >

Public Functions

inline T *data() noexcept
inline const T *data() const noexcept
template<typename T, VectorLayout L, unsigned MinAlign, bool Interleaved>
class Vector<InOut<T>, L, MinAlign, Interleaved> : public poplar::detail::VectorBaseImplicitDeref<InOut<T>, L, MinAlign, Interleaved>
template<typename T, VectorLayout L1, unsigned MinAlign1, bool Interleaved, VectorLayout L2, unsigned MinAlign2>
class Vector<InOut<Vector<T, L1, MinAlign1, Interleaved>>, L2, MinAlign2, false> : public poplar::detail::VectorBase<InOut<Vector<T, L1, MinAlign1, Interleaved>>, L2, MinAlign2, false>
#include <VectorTypes.hpp>

Create a 2D InOut edge for a Poplar vertex.

Example use 

 Vector<InOut<Vector<T, L1, MinAlign1, Interleaved>,L2, MinAlign2>
 edgeName;

A class for use in C++ vertex definitions, which defines an InOut vertex edge. The input/output is a 2D jagged vector of data. Each data sub-vector is stored contiguously in memory but can be allocated independently of the other sub-vectors. The vertex should treat all data in the vector as valid and can choose to overwrite some/all of the data. The data will be “live” both before and after the vertex is executed.

Template parameters: see Vector<Input<Vector<T, …>>

template<typename T, VectorLayout L, unsigned MinAlign, bool Interleaved>
class Vector<Input<T>, L, MinAlign, Interleaved> : public poplar::detail::VectorBaseImplicitDeref<Input<T>, L, MinAlign, Interleaved>
template<typename T, VectorLayout L1, unsigned MinAlign1, bool Interleaved, VectorLayout L2, unsigned MinAlign2>
struct Vector<Input<Vector<T, L1, MinAlign1, Interleaved>>, L2, MinAlign2, false> : public poplar::detail::VectorBase<Input<Vector<T, L1, MinAlign1, Interleaved>>, L2, MinAlign2, false>
#include <VectorTypes.hpp>

Create a 2D Input edge for a Poplar vertex.

Example use 

Vector<Input<Vector<T, L1, MinAlign1, Interleaved>,L2, MinAlign2>
edgeName;

A class for use in C++ vertex definitions, which defines an Input to the vertex. The input is a 2D jagged vector of data. Each data sub-vector is stored contiguously in memory but is allocated independently of the other sub-vectors. Because it is defined as an input, Poplar will assume that its content is unchanged by the vertex it is attached to. The data will be a “live” variable when the vertex is called.

  • With L2=SPAN the vertex state will take this form:

  • SPAN(Address, Length=L)

  • Address points to L2 layout data (With L1==SPAN):

  • SPAN(Address1, Length1), … SPAN(AddressL, LengthL)

  • The L2 layout data is contiguous with alignment MinAlign2

  • Address1 points to a Length1 data elements which have alignment

  • MinAlign1 Address2 points to a Length2 data elements which have alignment MinAlign1

  • … To AddressL

Param T

The type of data stored in the input.

Param L1

The type of vector layout used to describe the sub-vectors. For example ONE_PTR (pointer to data only) or SPAN (pointer to data and length). See FieldTypes.hpp

Param MinAlign1

The minimum alignment of the start of the data in bytes. This defaults to the sizeof(T) although larger alignments can be specified, which must be a multiple of sizeof(T).

Param Interleaved

Indicates that the data must be stored in interleaved memory.

Param L2

The type of vector layout used to describe the outer vector layout data. For example ONE_PTR (pointer to data only) or SPAN (pointer to data and length). See FieldTypes.hpp

Param MinAlign2

The minimum alignment of the L2 layout data in bytes.

template<typename T, VectorLayout L, unsigned MinAlign, bool Interleaved>
class Vector<Output<T>, L, MinAlign, Interleaved> : public poplar::detail::VectorBaseImplicitDeref<Output<T>, L, MinAlign, Interleaved>
template<typename T, VectorLayout L1, unsigned MinAlign1, bool Interleaved, VectorLayout L2, unsigned MinAlign2>
class Vector<Output<Vector<T, L1, MinAlign1, Interleaved>>, L2, MinAlign2, false> : public poplar::detail::VectorBase<Output<Vector<T, L1, MinAlign1, Interleaved>>, L2, MinAlign2, false>
#include <VectorTypes.hpp>

Create a 2D Output edge for a Poplar vertex.

Example use 

 Vector<Output<Vector<T, L1, MinAlign1, Interleaved>,L2, MinAlign2>
 edgeName;

A class for use in C++ vertex definitions, which defines an Output from the vertex. The output is a 2D jagged vector of data. Each data sub-vector is stored contiguously in memory but is allocated independently of the other sub-vectors. Because it is defined as an output, Poplar guarantees nothing about the initial content of the data, and it is generally expected that the vertex will overwrite all of the data in the output, although this isn’t strictly necessary - data can be left unmodified if required. The data will be a “live” variable when the vertex it is attached to is executed.

Template parameters: see Vector<Input<Vector<T, …>>

template<typename T>
struct VectorBase

Subclassed by poplar::BaseWithAlign< VectorBase< baseT >, MinAlign >, poplar::SpanVectorBaseImplicitDeref< T, MinAlign >, poplar::VectorBase< const quarter >

Public Functions

inline void *begin() const
inline std::uint32_t size() const

Public Members

void *beginPtr
std::uint32_t size_
template<>
struct VectorBase<const quarter> : public poplar::VectorBase<quarter>

Public Functions

__attribute__((always_inline)) inline const MetadataType *getMetadata()
template<>
struct VectorBase<quarter>

Public Functions

inline void *begin() const
inline std::uint32_t size() const
__attribute__((always_inline)) inline const MetadataType *getMetadata()

Public Members

void *beginPtr
std::uint32_t size_
void *meta
namespace detail

Typedefs

template<typename T>
using UnboxIO_t = typename UnboxIO<T>::type
template<typename T>
using UnboxIO_baseT = typename UnboxIO<T>::baseT

Functions

constexpr VectorLayout resolveCompactPtr(const VectorLayout layout, const unsigned minAlign)
inline constexpr unsigned max(unsigned a, unsigned b)
template<typename T, VectorLayout L, unsigned MinAlign, bool Interleaved>
struct ImplicitVLayoutEnumToType
template<typename T, unsigned MinAlign, bool Interleaved> ONE_PTR, MinAlign, Interleaved >

Public Types

using type = OnePtrVectorBaseImplicitDeref<UnboxIO_t<T>, MinAlign>
template<typename T, unsigned MinAlign, bool Interleaved> SCALED_PTR128, MinAlign, Interleaved >

Public Types

using type = ScaledPtr128VectorBaseImplicitDeref<UnboxIO_t<T>, MinAlign>
template<typename T, unsigned MinAlign, bool Interleaved> SCALED_PTR32, MinAlign, Interleaved >

Public Types

using type = ScaledPtr32VectorBaseImplicitDeref<UnboxIO_t<T>, MinAlign>
template<typename T, unsigned MinAlign, bool Interleaved> SCALED_PTR64, MinAlign, Interleaved >

Public Types

using type = ScaledPtr64VectorBaseImplicitDeref<UnboxIO_t<T>, MinAlign>
template<typename T, unsigned MinAlign, bool Interleaved> SPAN, MinAlign, Interleaved >

Public Types

using type = SpanVectorBaseImplicitDeref<UnboxIO_t<T>, MinAlign>
template<typename T>
struct UnboxIO

Public Types

using type = T
using baseT = typename Output<T>::baseT
template<typename T>
struct UnboxIO<InOut<T>>

Public Types

using type = T
using baseT = typename InOut<T>::baseT
template<typename T>
struct UnboxIO<Input<T>>

Public Types

using type = typename Input<T>::type
using baseT = typename Input<T>::baseT
template<typename T>
struct UnboxIO<Output<T>>

Public Types

using type = T
using baseT = typename Output<T>::baseT
template<typename T, VectorLayout L, unsigned MinAlign, bool Interleaved>
struct VectorBase : public detail::VLayoutEnumToType::type<T, detail::resolveCompactPtr(L, MinAlign), MinAlign, Interleaved>

Subclassed by poplar::Vector< InOut< Vector< T, L1, MinAlign1, Interleaved > >, L2, MinAlign2, false >, poplar::Vector< Input< Vector< T, L1, MinAlign1, Interleaved > >, L2, MinAlign2, false >, poplar::Vector< Output< Vector< T, L1, MinAlign1, Interleaved > >, L2, MinAlign2, false >

template<typename T, VectorLayout L, unsigned MinAlign, bool Interleaved>
struct VectorBaseImplicitDeref : public detail::ImplicitVLayoutEnumToType::type<T, detail::resolveCompactPtr(L, MinAlign), MinAlign, Interleaved>

Subclassed by poplar::Vector< InOut< T >, L, MinAlign, Interleaved >, poplar::Vector< Input< T >, L, MinAlign, Interleaved >, poplar::Vector< Output< T >, L, MinAlign, Interleaved >

template<typename T>
struct VectorOrder

Public Static Attributes

static constexpr unsigned value = 0
template<typename T>
struct VectorOrder<InOut<T>>

Public Static Attributes

static constexpr unsigned value = VectorOrder<T>::value
template<typename T>
struct VectorOrder<Input<T>>

Public Static Attributes

static constexpr unsigned value = VectorOrder<T>::value
template<typename T>
struct VectorOrder<Output<T>>

Public Static Attributes

static constexpr unsigned value = VectorOrder<T>::value
template<typename T, VectorLayout L, unsigned MinAlign, bool Interleaved> Vector< T, L, MinAlign, Interleaved > >

Public Static Attributes

static constexpr unsigned value = 1 + VectorOrder<T>::value
template<typename T, VectorLayout L, unsigned MinAlign, bool Interleaved>
struct VLayoutEnumToType
template<typename T, unsigned MinAlign, bool Interleaved> ONE_PTR, MinAlign, Interleaved >

Public Types

using type = OnePtrVectorBase<UnboxIO_t<T>, UnboxIO_baseT<T>, MinAlign>
template<typename T, unsigned MinAlign, bool Interleaved> SCALED_PTR128, MinAlign, Interleaved >

Public Types

using type = ScaledPtr128VectorBase<UnboxIO_t<T>, MinAlign>
template<typename T, unsigned MinAlign, bool Interleaved> SCALED_PTR32, MinAlign, Interleaved >

Public Types

using type = ScaledPtr32VectorBase<UnboxIO_t<T>, MinAlign>
template<typename T, unsigned MinAlign, bool Interleaved> SCALED_PTR64, MinAlign, Interleaved >

Public Types

using type = ScaledPtr64VectorBase<UnboxIO_t<T>, MinAlign>
template<typename T, unsigned MinAlign, bool Interleaved> SHORT_SPAN, MinAlign, Interleaved >

Public Types

using type = ShortSpanVectorBase<UnboxIO_t<T>, UnboxIO_baseT<T>, MinAlign>
template<typename T, unsigned MinAlign, bool Interleaved> SPAN, MinAlign, Interleaved >
#include <VectorTypes.hpp>

Vector.

Public Types

using type = SpanVectorBase<UnboxIO_t<T>, UnboxIO_baseT<T>, MinAlign>