Eigen::DefaultDevice Struct Reference

#include <TensorDeviceDefault.h>

Public Member Functions
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void *	allocate (size_t num_bytes) const
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void	deallocate (void *buffer) const
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void *	allocate_temp (size_t num_bytes) const
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void	deallocate_temp (void *buffer) const
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void	memcpy (void *dst, const void *src, size_t n) const
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void	memcpyHostToDevice (void *dst, const void *src, size_t n) const
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void	memcpyDeviceToHost (void *dst, const void *src, size_t n) const
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void	memset (void *buffer, int c, size_t n) const
template<typename T >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void	fill (T *begin, T *end, const T &value) const
template<typename Type >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Type	get (Type data) const
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE size_t	numThreads () const
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE size_t	firstLevelCacheSize () const
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE size_t	lastLevelCacheSize () const
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void	synchronize () const
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE int	majorDeviceVersion () const

Member Function Documentation

allocate()

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void* Eigen::DefaultDevice::allocate ( size_t  num_bytes ) const

inline

                                                                               {
    return internal::aligned_malloc(num_bytes);
  }

References Eigen::internal::aligned_malloc().

Referenced by allocate_temp().

allocate_temp()

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void* Eigen::DefaultDevice::allocate_temp ( size_t  num_bytes ) const

inline

{ return allocate(num_bytes); }

References allocate().

deallocate()

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::DefaultDevice::deallocate ( void *  buffer ) const

inline

{ internal::aligned_free(buffer); }

References Eigen::internal::aligned_free().

Referenced by deallocate_temp().

deallocate_temp()

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::DefaultDevice::deallocate_temp ( void *  buffer ) const

inline

{ deallocate(buffer); }

References deallocate().

fill()

template<typename T >

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::DefaultDevice::fill ( T *  begin, T *  end, const T &  value  ) const

inline

                                                                                          {
#ifdef EIGEN_GPU_COMPILE_PHASE
    // std::fill is not a device function, so resort to simple loop.
    for (T* it = begin; it != end; ++it) {
      *it = value;
    }
#else
    std::fill(begin, end, value);
#endif
  }

References Eigen::placeholders::end, and Eigen::value.

firstLevelCacheSize()

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE size_t Eigen::DefaultDevice::firstLevelCacheSize ( ) const

inline

                                                                           {
#if !defined(EIGEN_GPU_COMPILE_PHASE) && !defined(SYCL_DEVICE_ONLY)
    // Running on the host CPU
    return l1CacheSize();
#elif defined(EIGEN_HIP_DEVICE_COMPILE)
    // Running on a HIP device
    return 48 * 1024;  // FIXME : update this number for HIP
#else
    // Running on a CUDA device, return the amount of shared memory available.
    return 48 * 1024;
#endif
  }

References Eigen::l1CacheSize().

Referenced by lastLevelCacheSize().

get()

template<typename Type >

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Type Eigen::DefaultDevice::get ( Type  data ) const

inline

                                                                  {
    return data;
  }

References data.

lastLevelCacheSize()

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE size_t Eigen::DefaultDevice::lastLevelCacheSize ( ) const

inline

                                                                          {
#if !defined(EIGEN_GPU_COMPILE_PHASE) && !defined(SYCL_DEVICE_ONLY)
    // Running single threaded on the host CPU
    return l3CacheSize();
#elif defined(EIGEN_HIP_DEVICE_COMPILE)
    // Running on a HIP device
    return firstLevelCacheSize();  // FIXME : update this number for HIP
#else
    // Running on a CUDA device
    return firstLevelCacheSize();
#endif
  }

References firstLevelCacheSize(), and Eigen::l3CacheSize().

majorDeviceVersion()

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE int Eigen::DefaultDevice::majorDeviceVersion ( ) const

inline

                                                                       {
#if !defined(EIGEN_GPU_COMPILE_PHASE)
    // Running single threaded on the host CPU
    // Should return an enum that encodes the ISA supported by the CPU
    return 1;
#elif defined(EIGEN_HIP_DEVICE_COMPILE)
    // Running on a HIP device
    // return 1 as major for HIP
    return 1;
#else
    // Running on a CUDA device
    return EIGEN_CUDA_ARCH / 100;
#endif
  }

memcpy()

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::DefaultDevice::memcpy ( void *  dst, const void *  src, size_t  n  ) const

inline

                                                                                                {
    ::memcpy(dst, src, n);
  }

References n.

Referenced by memcpyDeviceToHost(), and memcpyHostToDevice().

memcpyDeviceToHost()

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::DefaultDevice::memcpyDeviceToHost ( void *  dst, const void *  src, size_t  n  ) const

inline

                                                                                                            {
    memcpy(dst, src, n);
  }

References memcpy(), and n.

memcpyHostToDevice()

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::DefaultDevice::memcpyHostToDevice ( void *  dst, const void *  src, size_t  n  ) const

inline

                                                                                                            {
    memcpy(dst, src, n);
  }

References memcpy(), and n.

memset()

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::DefaultDevice::memset ( void *  buffer, int  c, size_t  n  ) const

inline

{ ::memset(buffer, c, n); }

References calibrate::c, and n.

numThreads()

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE size_t Eigen::DefaultDevice::numThreads ( ) const

inline

                                                                  {
#if !defined(EIGEN_GPU_COMPILE_PHASE)
    // Running on the host CPU
    return 1;
#elif defined(EIGEN_HIP_DEVICE_COMPILE)
    // Running on a HIP device
    return 64;
#else
    // Running on a CUDA device
    return 32;
#endif
  }

synchronize()

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::DefaultDevice::synchronize ( ) const

inline

                                                                 {
    // Nothing.  Default device operations are synchronous.
  }

---

The documentation for this struct was generated from the following file:

• TensorDeviceDefault.h