VectorTypes

#include <poplar/VectorTypes.hpp>
template<typename T, unsigned MinAlign, bool Interleaved>
struct poplar::detail::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 poplar::detail::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 poplar::detail::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 poplar::detail::VLayoutEnumToType<T, VectorLayout::SCALED_PTR32, MinAlign, Interleaved>

Public Types

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

Public Types

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

Public Types

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

Public Types

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

Public Types

using type = OnePtrVectorBaseImplicitDeref<UnboxIO_t<T>, MinAlign>
template<typename T, unsigned MinAlign, bool Interleaved>
struct poplar::detail::ImplicitVLayoutEnumToType<T, VectorLayout::SCALED_PTR32, MinAlign, Interleaved>
template<typename T, unsigned MinAlign, bool Interleaved>
struct poplar::detail::ImplicitVLayoutEnumToType<T, VectorLayout::SCALED_PTR64, MinAlign, Interleaved>
template<typename T, unsigned MinAlign, bool Interleaved>
struct poplar::detail::ImplicitVLayoutEnumToType<T, VectorLayout::SCALED_PTR128, MinAlign, Interleaved>
template<typename T, VectorLayout L, unsigned MinAlign, bool Interleaved>
struct poplar::detail::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>
#include <VectorTypes.hpp>

InOut<Vector>.

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>

Input<Vector>.

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>

Public Types

typedef T *iterator
typedef const T *const_iterator

Public Functions

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

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>
#include <VectorTypes.hpp>

Output<Vector>.

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>

Public Types

typedef T *iterator
typedef const T *const_iterator

Public Functions

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

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>

Public Types

typedef T *iterator
typedef const T *const_iterator

Public Functions

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

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>

Public Types

typedef T *iterator
typedef const T *const_iterator

Public Functions

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

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>

Public Types

typedef T *iterator
typedef const T *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 = 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>

Public Types

typedef T *iterator
typedef const T *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 = 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 : public poplar::detail::VectorBase<T, L, MinAlign, Interleaved>

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>
#include <VectorTypes.hpp>

Vector<InOut>.

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>

Vector<InOut<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>
#include <VectorTypes.hpp>

Vector<Input>.

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>

Vector<Input<Vector<T>>.

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>
#include <VectorTypes.hpp>

Vector<Output>.

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>

Vector<Output<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

using UnboxIO_t = typename UnboxIO<T>::type
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< T, L, MinAlign, Interleaved >, 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 >, poplar::Vector< const T, L, MinAlign, Interleaved >

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>