#include <TensorScanSycl.h>

Public Member Functions
EIGEN_STRONG_INLINE	ScanInfo (const Index &total_size_, const Index &scan_size_, const Index &panel_size_, const Index &non_scan_size_, const Index &scan_stride_, const Index &non_scan_stride_, const Eigen::SyclDevice &dev_)

ScanParameters< Index >	get_scan_parameter ()

cl::sycl::nd_range< 1 >	get_thread_range ()

Public Attributes
const Index &	total_size

const Index &	scan_size

const Index &	panel_size

const Index &	non_scan_size

const Index &	scan_stride

const Index &	non_scan_stride

Index	max_elements_per_block

Index	block_size

Index	panel_threads

Index	group_threads

Index	block_threads

Index	elements_per_group

Index	elements_per_block

Index	loop_range

Index	global_range

Index	local_range

const Eigen::SyclDevice &	dev

Constructor & Destructor Documentation

◆ ScanInfo()

template<typename Index >

EIGEN_STRONG_INLINE Eigen::TensorSycl::internal::ScanInfo< Index >::ScanInfo	(	const Index &	total_size_,
		const Index &	scan_size_,
		const Index &	panel_size_,
		const Index &	non_scan_size_,
		const Index &	scan_stride_,
		const Index &	non_scan_stride_,
		const Eigen::SyclDevice &	dev_
	)

inline

       : total_size(total_size_),
         scan_size(scan_size_),
         panel_size(panel_size_),
         non_scan_size(non_scan_size_),
         scan_stride(scan_stride_),
         non_scan_stride(non_scan_stride_),
         dev(dev_) {
     // must be power of 2
     local_range = std::min(Index(dev.getNearestPowerOfTwoWorkGroupSize()),
                            Index(EIGEN_SYCL_LOCAL_THREAD_DIM0 * EIGEN_SYCL_LOCAL_THREAD_DIM1));
  
     max_elements_per_block = local_range * ScanParameters<Index>::ScanPerThread;
  
     elements_per_group =
         dev.getPowerOfTwo(Index(roundUp(Index(scan_size), ScanParameters<Index>::ScanPerThread)), true);
     const Index elements_per_panel = elements_per_group * non_scan_size;
     elements_per_block = std::min(Index(elements_per_group), Index(max_elements_per_block));
     panel_threads = elements_per_panel / ScanParameters<Index>::ScanPerThread;
     group_threads = elements_per_group / ScanParameters<Index>::ScanPerThread;
     block_threads = elements_per_block / ScanParameters<Index>::ScanPerThread;
     block_size = elements_per_group / elements_per_block;
 #ifdef EIGEN_SYCL_MAX_GLOBAL_RANGE
     const Index max_threads = std::min(Index(panel_threads * panel_size), Index(EIGEN_SYCL_MAX_GLOBAL_RANGE));
 #else
     const Index max_threads = panel_threads * panel_size;
 #endif
     global_range = roundUp(max_threads, local_range);
     loop_range = Index(
         std::ceil(double(elements_per_panel * panel_size) / (global_range * ScanParameters<Index>::ScanPerThread)));
   }

Member Function Documentation

◆ get_scan_parameter()

template<typename Index >

ScanParameters<Index> Eigen::TensorSycl::internal::ScanInfo< Index >::get_scan_parameter ( )

inline

                                                     {
     return ScanParameters<Index>(total_size, non_scan_size, scan_size, non_scan_stride, scan_stride, panel_threads,
                                  group_threads, block_threads, elements_per_group, elements_per_block, loop_range);
   }

◆ get_thread_range()

template<typename Index >

cl::sycl::nd_range<1> Eigen::TensorSycl::internal::ScanInfo< Index >::get_thread_range ( )

inline

                                               {
     return cl::sycl::nd_range<1>(cl::sycl::range<1>(global_range), cl::sycl::range<1>(local_range));
   }

References Eigen::TensorSycl::internal::ScanInfo< Index >::global_range, and Eigen::TensorSycl::internal::ScanInfo< Index >::local_range.