#include <TensorBlock.h>

Public Types
enum	DestinationBufferKind : int { kEmpty , kContiguous , kStrided }

Public Member Functions
template<typename Scalar >
Scalar *	data () const

const Dimensions &	strides () const

const DestinationBufferKind &	kind () const

Private Member Functions
	DestinationBuffer ()

template<typename Scalar >
	DestinationBuffer (Scalar *data, const Dimensions &strides, DestinationBufferKind kind)

Static Private Member Functions
template<int Layout, typename Scalar >
static DestinationBuffer	make (const TensorBlockDescriptor &desc, Scalar *data, const Dimensions &strides)

template<int Layout>
static DestinationBufferKind	kind (const TensorBlockDescriptor &desc, const Dimensions &strides)

Private Attributes
void *	m_data

size_t	m_data_type_size

Dimensions	m_strides

DestinationBufferKind	m_kind

Friends
class	TensorBlockDescriptor< NumDims, IndexType >

Member Enumeration Documentation

◆ DestinationBufferKind

template<int NumDims, typename IndexType = Eigen::Index>

enum Eigen::internal::TensorBlockDescriptor::DestinationBuffer::DestinationBufferKind : int

Enumerator
kEmpty
kContiguous
kStrided

                                : int {
       // The above explicit specification of "int" as the enum basetype is
       // needed to get around a HIPCC link error ("the field type is not
       // amp-compatible")
       // which is issued for class members with the enum type.
       // TODO(rocm):
       // remove the "int" basetype once HIPCC has been fixed to not error out
       // in the above scenario.
  
       // Destination buffer is not defined (`m_data` == nullptr).
       kEmpty,
  
       // Tensor block defined by an owning tensor block descriptor can fit
       // contiguously into the destination buffer. In this case it's safe to
       // materialize tensor block in the destination buffer, wrap it in a
       // TensorMap, and use to build Eigen expression on top of it.
       kContiguous,
  
       // Destination buffer strides do not match strides of the contiguously
       // stored block, and it's impossible to define a TensorMap over this
       // buffer. However if we are evaluating a root of an expression tree, we
       // still can materialize an output into this destination, because we can
       // guarantee that no one will ever access it through block API.
       //
       // In theory it is possible to build valid TensorStriding<TensorMap>
       // expression on top of this destination buffer, however it has
       // inefficient coeff/packet access, and defeats the purpose of fast block
       // evaluation API.
       kStrided
     };

Constructor & Destructor Documentation

◆ DestinationBuffer() [1/2]

template<int NumDims, typename IndexType = Eigen::Index>

Eigen::internal::TensorBlockDescriptor< NumDims, IndexType >::DestinationBuffer::DestinationBuffer ( )

inlineprivate

230 : m_data(NULL), m_data_type_size(0), m_kind(kEmpty) {}

Eigen::internal::TensorBlockDescriptor::DestinationBuffer::m_kind

DestinationBufferKind m_kind

Definition: TensorBlock.h:261

Eigen::internal::TensorBlockDescriptor::DestinationBuffer::m_data

void * m_data

Definition: TensorBlock.h:254

Eigen::internal::TensorBlockDescriptor::DestinationBuffer::m_data_type_size

size_t m_data_type_size

Definition: TensorBlock.h:255

Referenced by Eigen::internal::TensorBlockDescriptor< NumDims, IndexType >::DestinationBuffer::make().

◆ DestinationBuffer() [2/2]

template<int NumDims, typename IndexType = Eigen::Index>

template<typename Scalar >

Eigen::internal::TensorBlockDescriptor< NumDims, IndexType >::DestinationBuffer::DestinationBuffer	(	Scalar *	data,
		const Dimensions &	strides,
		DestinationBufferKind	kind
	)

inlineprivate

234 : m_data(static_cast<void*>(data)), m_data_type_size(sizeof(Scalar)), m_strides(strides), m_kind(kind) {}

Scalar

SCALAR Scalar

Definition: bench_gemm.cpp:45

Eigen::internal::TensorBlockDescriptor::DestinationBuffer::m_strides

Dimensions m_strides

Definition: TensorBlock.h:259

Eigen::internal::TensorBlockDescriptor::DestinationBuffer::kind

const DestinationBufferKind & kind() const

Definition: TensorBlock.h:225

Eigen::internal::TensorBlockDescriptor::DestinationBuffer::strides

const Dimensions & strides() const

Definition: TensorBlock.h:224

Eigen::internal::TensorBlockDescriptor::DestinationBuffer::data

Scalar * data() const

Definition: TensorBlock.h:219

Member Function Documentation

◆ data()

template<int NumDims, typename IndexType = Eigen::Index>

template<typename Scalar >

Scalar* Eigen::internal::TensorBlockDescriptor< NumDims, IndexType >::DestinationBuffer::data ( ) const

inline

                          {
       eigen_assert(m_data_type_size == sizeof(Scalar));
       return static_cast<Scalar*>(m_data);
     }

References eigen_assert, Eigen::internal::TensorBlockDescriptor< NumDims, IndexType >::DestinationBuffer::m_data, and Eigen::internal::TensorBlockDescriptor< NumDims, IndexType >::DestinationBuffer::m_data_type_size.

Referenced by gdb.printers.EigenMatrixPrinter::children(), gdb.printers.EigenSparseMatrixPrinter::children(), gdb.printers.EigenQuaternionPrinter::children(), Eigen::internal::TensorBlockDescriptor< NumDims, IndexType >::DestinationBuffer::make(), gdb.printers.EigenMatrixPrinter::to_string(), gdb.printers.EigenSparseMatrixPrinter::to_string(), and gdb.printers.EigenQuaternionPrinter::to_string().

◆ kind() [1/2]

template<int NumDims, typename IndexType = Eigen::Index>

const DestinationBufferKind& Eigen::internal::TensorBlockDescriptor< NumDims, IndexType >::DestinationBuffer::kind ( ) const

inline

225 { return m_kind; }

References Eigen::internal::TensorBlockDescriptor< NumDims, IndexType >::DestinationBuffer::m_kind.

Referenced by Eigen::internal::TensorBlockDescriptor< NumDims, IndexType >::HasDestinationBuffer(), and Eigen::internal::TensorMaterializedBlock< Scalar, NumDims, Layout, IndexType >::prepareStorage().

◆ kind() [2/2]

template<int NumDims, typename IndexType = Eigen::Index>

template<int Layout>

static DestinationBufferKind Eigen::internal::TensorBlockDescriptor< NumDims, IndexType >::DestinationBuffer::kind	(	const TensorBlockDescriptor &	desc,
		const Dimensions &	strides
	)

inlinestaticprivate

                                                                                                     {
       const Dimensions& desc_dims = desc.dimensions();
       const Dimensions& desc_strides = internal::strides<Layout>(desc_dims);
       for (int i = 0; i < NumDims; ++i) {
         if (desc_dims[i] == 1) continue;
         if (desc_strides[i] != strides[i]) return kStrided;
       }
       return kContiguous;
     }

References Eigen::internal::TensorBlockDescriptor< NumDims, IndexType >::dimensions(), i, Eigen::internal::TensorBlockDescriptor< NumDims, IndexType >::DestinationBuffer::kContiguous, Eigen::internal::TensorBlockDescriptor< NumDims, IndexType >::DestinationBuffer::kStrided, and Eigen::internal::TensorBlockDescriptor< NumDims, IndexType >::DestinationBuffer::strides().

◆ make()

template<int NumDims, typename IndexType = Eigen::Index>

template<int Layout, typename Scalar >

static DestinationBuffer Eigen::internal::TensorBlockDescriptor< NumDims, IndexType >::DestinationBuffer::make	(	const TensorBlockDescriptor &	desc,
		Scalar *	data,
		const Dimensions &	strides
	)

inlinestaticprivate

                                                                                                               {
       return DestinationBuffer(data, strides, kind<Layout>(desc, strides));
     }