Enumerations
enum class	contraction_type { local , no_local }

enum class	data_source { global_mem , local_mem , private_mem }

enum class	reduction_dim { inner_most , outer_most }

enum class	scan_step { first , second }

Functions
template<bool is_internal>
bool	check_boundary (bool)
	check_boundary: is used to check the edge condition for non-internal blocks. More...

template<>
bool	check_boundary< false > (bool cond)
	check_boundary: specialization of the check_boundary for non-internal blocks. More...

template<bool PacketLoad, bool , bool IsRhs, typename PacketType , typename TensorMapper , typename StorageIndex >
static std::enable_if_t<!PacketLoad, PacketType >	read (const TensorMapper &tensorMapper, const StorageIndex &NCIndex, const StorageIndex &CIndex, const StorageIndex &)
	read, special overload of read function, when the read access is not vectorized More...

template<bool PacketLoad, bool is_coalesced_layout, bool , typename PacketType , typename TensorMapper , typename StorageIndex >
static std::enable_if_t< PacketLoad, PacketType >	read (const TensorMapper &tensorMapper, const StorageIndex &NCIndex, const StorageIndex &CIndex, const StorageIndex &ld)
	read, a template function used for loading the data from global memory. This function is used to guarantee coalesced and vectorized load whenever possible More...

template<data_source dt, typename PacketType , typename DataScalar >
static std::enable_if_t< Eigen::internal::unpacket_traits< PacketType >::size !=1 &&dt==data_source::global_mem, void >	write (PacketType &packet_data, DataScalar *ptr)
	Overloading the write function for storing the data to global memory, when vectorization enabled This function is used to guarantee coalesced and vectorized store whenever possible. More...

template<data_source dt, typename PacketType , typename DataScalar >
static std::enable_if_t< Eigen::internal::unpacket_traits< PacketType >::size==1 &&dt==data_source::global_mem, void >	write (PacketType &packet_data, DataScalar *ptr)
	Overloading the write function for storing the data to global memory, when vectorization is disabled. More...

template<typename StorageIndex , StorageIndex ld, data_source dt, typename PacketType , typename DataScalar >
static std::enable_if_t< dt !=data_source::global_mem, void >	write (PacketType &packet_data, DataScalar ptr)
	write, a template function used for storing the data to local memory. This function is used to guarantee coalesced and vectorized store whenever possible. More...

Enumeration Type Documentation

◆ contraction_type

enum Eigen::TensorSycl::internal::contraction_type

strong

Enumerator
local
no_local

Definition at line 128 of file TensorContractionSycl.h.

128 { local, no_local };

Eigen::TensorSycl::internal::contraction_type::no_local

@ no_local

Eigen::TensorSycl::internal::contraction_type::local

@ local

◆ data_source

enum Eigen::TensorSycl::internal::data_source

strong

Enumerator
global_mem
local_mem
private_mem

Definition at line 132 of file TensorContractionSycl.h.

132 { global_mem, local_mem, private_mem };

Eigen::TensorSycl::internal::data_source::private_mem

@ private_mem

Eigen::TensorSycl::internal::data_source::global_mem

@ global_mem

Eigen::TensorSycl::internal::data_source::local_mem

@ local_mem

◆ reduction_dim

enum Eigen::TensorSycl::internal::reduction_dim

strong

Enumerator
inner_most
outer_most

Definition at line 253 of file TensorReductionSycl.h.

253 { inner_most, outer_most };

Eigen::TensorSycl::internal::reduction_dim::outer_most

@ outer_most

Eigen::TensorSycl::internal::reduction_dim::inner_most

@ inner_most

◆ scan_step

enum Eigen::TensorSycl::internal::scan_step

strong

Enumerator
first
second

Definition at line 82 of file TensorScanSycl.h.

82 { first, second };

Eigen::TensorSycl::internal::scan_step::second

@ second

first

EIGEN_CONSTEXPR Index first(const T &x) EIGEN_NOEXCEPT

Function Documentation

◆ check_boundary()

template<bool is_internal>

bool Eigen::TensorSycl::internal::check_boundary ( bool )

inline

check_boundary: is used to check the edge condition for non-internal blocks.

Template Parameters

is_internal determines if the block is internal

Definition at line 279 of file TensorContractionSycl.h.

                                                                 {
   return true;
 }

◆ check_boundary< false >()

template<>

bool Eigen::TensorSycl::internal::check_boundary< false > ( bool cond )

inline

check_boundary: specialization of the check_boundary for non-internal blocks.

Parameters

cond	true when the data is in range. Otherwise false

Definition at line 289 of file TensorContractionSycl.h.

                                                                             {
   return cond;
 }

◆ read() [1/2]

template<bool PacketLoad, bool , bool IsRhs, typename PacketType , typename TensorMapper , typename StorageIndex >

static std::enable_if_t<!PacketLoad, PacketType> Eigen::TensorSycl::internal::read	(	const TensorMapper &	tensorMapper,
		const StorageIndex &	NCIndex,
		const StorageIndex &	CIndex,
		const StorageIndex &
	)

inlinestatic

read, special overload of read function, when the read access is not vectorized

Template Parameters

PacketLoad determines if the each element of this tensor block should be loaded in a packet mode

Parameters

is_coalesced_layout determines whether or not the Tensor data in a memory can be access coalesced and vectorized when possible. Coalesced memory access is a key factor in Kernel performance. When a tensor is 2d and the contracting dimension is 1, it is always possible to accessed tensor data coalesced and vectorized. This is the case when RHS(right hand side) Tensor is transposed or when LHS(left hand side) Tensor is not transposed.

Template Parameters

PacketType	determines the type of packet
TensorMapper	determines the input tensor mapper type
StorageIndex	determines the Index type

Parameters

tensorMapper	is the input tensor
NCIndex	is the non-contracting dim index
CIndex	is the contracting dim index

Definition at line 191 of file TensorContractionSycl.h.

                                                                                                                      {
   const StorageIndex row = (IsRhs) ? CIndex : NCIndex;
   const StorageIndex col = (IsRhs) ? NCIndex : CIndex;
   return tensorMapper(row, col);
 }

◆ read() [2/2]

template<bool PacketLoad, bool is_coalesced_layout, bool , typename PacketType , typename TensorMapper , typename StorageIndex >

static std::enable_if_t<PacketLoad, PacketType> Eigen::TensorSycl::internal::read	(	const TensorMapper &	tensorMapper,
		const StorageIndex &	NCIndex,
		const StorageIndex &	CIndex,
		const StorageIndex &	ld
	)

inlinestatic

read, a template function used for loading the data from global memory. This function is used to guarantee coalesced and vectorized load whenever possible

Template Parameters

PacketLoad determines if the each element of this tensor block should be loaded in a packet mode

Parameters

is_coalesced_layout determines whether or not the Tensor data in a memory can be access coalesced and vectorized when possible. Coalesced memory access is a key factor in Kernel performance. When a tensor is 2d and the contracting dimension is 1, it is always possible to accessed tensor data coalesced and vectorized. This is the case when RHS(right hand side) Tensor is transposed or when LHS(left hand side) Tensor is not transposed.

Template Parameters

PacketType	determines the type of packet
TensorMapper	determines the input tensor mapper type
StorageIndex	determines the Index type

Parameters

tensorMapper	is the input tensor
NCIndex	is the non-contracting dim index
CIndex	is the contracting dim index
ld	is the leading dimension of the flattened tensor

Definition at line 161 of file TensorContractionSycl.h.

                                                                                                                        {
   const StorageIndex row = (is_coalesced_layout) ? NCIndex : CIndex;
   const StorageIndex col = (is_coalesced_layout) ? CIndex : NCIndex;
   return tensorMapper.get_tensor().template packet<Unaligned>(row + (col * ld));
 }

◆ write() [1/3]

template<data_source dt, typename PacketType , typename DataScalar >

static std::enable_if_t< Eigen::internal::unpacket_traits<PacketType>::size != 1 && dt == data_source::global_mem, void> Eigen::TensorSycl::internal::write	(	PacketType &	packet_data,
		DataScalar *	ptr
	)

inlinestatic

Overloading the write function for storing the data to global memory, when vectorization enabled This function is used to guarantee coalesced and vectorized store whenever possible.

Template Parameters

data_source	an enum value representing if the location of the data in a memory hierarchy.
PacketType	determines the type of packet
DataScalar	determines the output data type

Parameters

packet_data	the data to be written in the local memory
ptr	a pointer to the local memory

Definition at line 249 of file TensorContractionSycl.h.

                                                 {
   ::Eigen::internal::pstoreu<DataScalar, PacketType>(ptr, packet_data);
 }

◆ write() [2/3]

template<data_source dt, typename PacketType , typename DataScalar >

static std::enable_if_t< Eigen::internal::unpacket_traits<PacketType>::size == 1 && dt == data_source::global_mem, void> Eigen::TensorSycl::internal::write	(	PacketType &	packet_data,
		DataScalar *	ptr
	)

inlinestatic

Overloading the write function for storing the data to global memory, when vectorization is disabled.

Template Parameters

data_source	an enum value representing if the location of the data in a memory hierarchy.
PacketType	determines the type of packet
DataScalar	determines the output data type

Parameters

packet_data	the data to be written in the local memory
ptr	a pointer to the local memory

Definition at line 269 of file TensorContractionSycl.h.

                                                 {
   *ptr = packet_data;
 }

◆ write() [3/3]

template<typename StorageIndex , StorageIndex ld, data_source dt, typename PacketType , typename DataScalar >

static std::enable_if_t<dt != data_source::global_mem, void> Eigen::TensorSycl::internal::write	(	PacketType &	packet_data,
		DataScalar	ptr
	)

inlinestatic

write, a template function used for storing the data to local memory. This function is used to guarantee coalesced and vectorized store whenever possible.

Template Parameters

StorageIndex determines the Index type

Parameters

ld	is the leading dimension of the local memory. ld is a compile time value for the local memory

Template Parameters

data_source	an enum value representing if the location of the data in a memory hierarchy.
PacketType	determines the type of packet
DataScalar	determines the output data type

Parameters

packet_data	the data to be written in the local memory
ptr	a pointer to the local memory
CIndex	is the contracting dim index

Definition at line 222 of file TensorContractionSycl.h.

                                                    {
   EIGEN_CONSTEXPR int PacketSize = Eigen::internal::unpacket_traits<PacketType>::size;
   EIGEN_UNROLL_LOOP
   for (int i = 0; i < PacketSize; i++) {
     *ptr = PacketWrapper<PacketType, PacketSize>::scalarize(i, packet_data);
     ptr += ld;
   }
 }

Enumerations

Functions

Enumeration Type Documentation

◆ contraction_type

◆ data_source

◆ reduction_dim

◆ scan_step

Function Documentation

◆ check_boundary()

◆ check_boundary< false >()

◆ read() [1/2]

◆ read() [2/2]

◆ write() [1/3]

◆ write() [2/3]

◆ write() [3/3]