#include <TensorRandom.h>

Public Member Functions
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE	NormalRandomGenerator (uint64_t seed=0)

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE	NormalRandomGenerator (const NormalRandomGenerator &other)

template<typename Index >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T	operator() (Index i) const

template<typename Packet , typename Index >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet	packetOp (Index i) const

Static Public Attributes
static constexpr bool	PacketAccess = true

Private Attributes
uint64_t	m_state

Constructor & Destructor Documentation

◆ NormalRandomGenerator() [1/2]

template<typename T >

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Eigen::internal::NormalRandomGenerator< T >::NormalRandomGenerator ( uint64_t seed = 0 )

inline

                                                                                  {
     m_state = PCG_XSH_RS_state(seed);
 #ifdef EIGEN_USE_SYCL
     // In SYCL it is not possible to build PCG_XSH_RS_state in one step.
     // Therefore, we need two steps to initializate the m_state.
     // IN SYCL, the constructor of the functor is s called on the CPU
     // and we get the clock seed here from the CPU. However, This seed is
     // the same for all the thread. As unlike CUDA, the thread.ID, BlockID, etc is not a global function.
     // and only  available on the Operator() function (which is called on the GPU).
     // Therefore, the thread Id injection is not available at this stage. However when the operator()
     // is called the thread ID will be available. So inside the operator,
     // we add the thrreadID, BlockId,... (which is equivalent of i)
     // to the seed and construct the unique m_state per thead similar to cuda.
     m_exec_once = false;
 #endif
   }

References Eigen::internal::NormalRandomGenerator< T >::m_state, and Eigen::internal::PCG_XSH_RS_state().

◆ NormalRandomGenerator() [2/2]

template<typename T >

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Eigen::internal::NormalRandomGenerator< T >::NormalRandomGenerator ( const NormalRandomGenerator< T > & other )

inline

                                                                                                   {
     m_state = other.m_state;
 #ifdef EIGEN_USE_SYCL
     m_exec_once = other.m_exec_once;
 #endif
   }

References Eigen::internal::NormalRandomGenerator< T >::m_state.

Member Function Documentation

◆ operator()()

template<typename T >

template<typename Index >

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T Eigen::internal::NormalRandomGenerator< T >::operator() ( Index i ) const

inline

                                                                     {
 #ifdef EIGEN_USE_SYCL
     if (!m_exec_once) {
       // This is the second stage of adding thread Id to the CPU clock seed and build unique seed per thread
       m_state += (i * 6364136223846793005ULL);
       m_exec_once = true;
     }
 #endif
     T result = RandomToTypeNormal<T>(&m_state, i);
     return result;
   }

References i, and Eigen::internal::NormalRandomGenerator< T >::m_state.

◆ packetOp()

template<typename T >

template<typename Packet , typename Index >

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet Eigen::internal::NormalRandomGenerator< T >::packetOp ( Index i ) const

inline

                                                                        {
     const int packetSize = internal::unpacket_traits<Packet>::size;
     EIGEN_ALIGN_MAX T values[packetSize];
 #ifdef EIGEN_USE_SYCL
     if (!m_exec_once) {
       // This is the second stage of adding thread Id to the CPU clock seed and build unique seed per thread
       m_state += (i * 6364136223846793005ULL);
       m_exec_once = true;
     }
 #endif
     EIGEN_UNROLL_LOOP
     for (int j = 0; j < packetSize; ++j) {
       values[j] = RandomToTypeNormal<T>(&m_state, i);
     }
     return internal::pload<Packet>(values);
   }