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>, 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>, 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>, 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>

Public Types

using type = ScaledPtr32VectorBaseImplicitDeref<UnboxIO_t<T>, MinAlign>

template<typename T, unsigned MinAlign, bool Interleaved>
struct poplar::detail::ImplicitVLayoutEnumToType<T, VectorLayout::SCALED_PTR64, MinAlign, Interleaved>

Public Types

using type = ScaledPtr64VectorBaseImplicitDeref<UnboxIO_t<T>, MinAlign>

template<typename T, unsigned MinAlign, bool Interleaved>
struct poplar::detail::ImplicitVLayoutEnumToType<T, VectorLayout::SCALED_PTR128, MinAlign, Interleaved>

Public Types

using type = ScaledPtr128VectorBaseImplicitDeref<UnboxIO_t<T>, MinAlign>

namespace poplar

Poplar classes and functions.

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

Subclassed by poplar::OnePtrVectorBase< T, MinAlign >, poplar::ScaledPtr128VectorBase< T, MinAlign >, poplar::ScaledPtr32VectorBase< T, MinAlign >, poplar::ScaledPtr64VectorBase< T, MinAlign >, poplar::ShortSpanVectorBase< T, MinAlign >, poplar::SpanVectorBase< T, 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 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<T, L, MinAlign, Interleaved>

#include <VectorTypes.hpp>

Input<Vector>.

Public Types

using iterator = typename Vector<std::enable_if<L == VectorLayout::SPAN, T>, VectorLayout::SPAN, MinAlign, Interleaved>::const_iterator

Public Functions

inline const Vector<T, L, MinAlign, Interleaved> &operator*() const

inline const Vector<T, L, MinAlign, Interleaved> *operator->() const

template<typename T, unsigned MinAlign>
class OnePtrVectorBase : public poplar::BaseWithAlign<PtrBase, MinAlign>

Public Types

typedef T *iterator

typedef const T *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 = BaseWithAlign<PtrBase, MinAlign>

template<typename T, unsigned MinAlign>
class OnePtrVectorBaseImplicitDeref : public poplar::PtrBase

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

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

struct PtrBase

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

Public Functions

inline void *begin() const

Public Members

void *ptr

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 const T &operator[](std::size_t index) const

inline T &operator[](std::size_t index)

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 const T &operator[](std::size_t index) const

inline T &operator[](std::size_t index)

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 const T &operator[](std::size_t index) const

inline T &operator[](std::size_t index)

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, unsigned MinAlign>
class ShortSpanVectorBase : public poplar::BaseWithAlign<ShortVectorBase, 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, MinAlign>

template<typename T, unsigned MinAlign>
class ShortSpanVectorBaseImplicitDeref : public poplar::ShortVectorBase

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

struct ShortVectorBase

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

Public Functions

inline void *begin() const

inline std::uint32_t size() const

Public Members

uint32_t address

uint32_t size_

template<typename T, unsigned MinAlign>
class SpanVectorBase : public poplar::BaseWithAlign<VectorBase, 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, MinAlign>

template<typename T, unsigned MinAlign>
class SpanVectorBaseImplicitDeref : public poplar::VectorBase

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

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

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

struct VectorBase

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

Public Functions

inline void *begin() const

inline std::uint32_t size() const

Public Members

void *beginPtr

std::uint32_t size_

namespace detail

Typedefs

using UnboxIO_t = typename UnboxIO<T>::type

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

template<typename T>
struct UnboxIO<InOut<T>>

Public Types

using type = T

template<typename T>
struct UnboxIO<Input<T>>

Public Types

using type = const T

template<typename T>
struct UnboxIO<Output<T>>

Public Types

using type = T

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 >

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, 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>, 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>, MinAlign>

template<typename T, unsigned MinAlign, bool Interleaved> SPAN, MinAlign, Interleaved >

#include <VectorTypes.hpp>

Vector.

Public Types

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