OMPallocator< T, HostAllocator > Struct Template Reference

OMPallocator is an allocator with fused device and dualspace allocator functionality. More...

Inheritance diagram for OMPallocator< T, HostAllocator >:

Collaboration diagram for OMPallocator< T, HostAllocator >:

Classes
struct	rebind

Public Types
using	value_type = typename HostAllocator::value_type
using	size_type = typename HostAllocator::size_type
using	pointer = typename HostAllocator::pointer
using	const_pointer = typename HostAllocator::const_pointer

Public Member Functions
	OMPallocator ()=default
	OMPallocator (const OMPallocator &)
	Gives you a OMPallocator with no state. More...
template<class U , class V >
	OMPallocator (const OMPallocator< U, V > &)
value_type *	allocate (std::size_t n)
void	deallocate (value_type *pt, std::size_t n)
void	attachReference (const OMPallocator &from, std::ptrdiff_t ptr_offset)
T *	get_device_ptr ()
const T *	get_device_ptr () const

Private Attributes
T *	device_ptr_ = nullptr

Detailed Description

template<typename T, class HostAllocator = std::allocator<T>>
struct qmcplusplus::OMPallocator< T, HostAllocator >

OMPallocator is an allocator with fused device and dualspace allocator functionality.

it is mostly c++03 style but is stateful with respect to the bond between the returned pt on the host and the device_ptr_. While many containers may need a copy only one can own the memory it returns and it can only service one owner. i.e. only one object should call the allocate and deallocate methods.

Note: in the style of openmp portability this class always thinks its dual space even when its not, this happens through the magic of openmp ignoring target pragmas when target isn't enabled. i.e. -fopenmp-targets=... isn't passed at compile time. This makes the code "simpler" and more "portable" since its the same code you would write for openmp CPU implementation exploding head and that is the same implementation + pragmas as the serial implementation. This definitely isn't true for all QMCPACK code using offload but it is true for OMPAllocator so we do test it that way.

Definition at line 60 of file OMPallocator.hpp.

---

Class Documentation

qmcplusplus::OMPallocator::rebind

struct qmcplusplus::OMPallocator::rebind

template<typename T, class HostAllocator = std::allocator<T>>
template<class U, class V>
struct qmcplusplus::OMPallocator< T, HostAllocator >::rebind< U, V >

Definition at line 79 of file OMPallocator.hpp.

Collaboration diagram for OMPallocator< T, HostAllocator >::rebind< U, V >:

Class Members
typedef OMPallocator< U, V >	other

Member Typedef Documentation

const_pointer

using const_pointer = typename HostAllocator::const_pointer

Definition at line 65 of file OMPallocator.hpp.

pointer

using pointer = typename HostAllocator::pointer

Definition at line 64 of file OMPallocator.hpp.

size_type

using size_type = typename HostAllocator::size_type

Definition at line 63 of file OMPallocator.hpp.

value_type

using value_type = typename HostAllocator::value_type

Definition at line 62 of file OMPallocator.hpp.

Constructor & Destructor Documentation

OMPallocator() [1/3]

OMPallocator ( )

default

OMPallocator() [2/3]

OMPallocator ( const OMPallocator< T, HostAllocator > &  )

inline

Gives you a OMPallocator with no state.

But OMPallocoator is stateful so this copy constructor is a lie. However until allocators are correct > c++11 this is retained since our < c++11 compliant containers may expect it.

Definition at line 73 of file OMPallocator.hpp.

: device_ptr_(nullptr) {}

OMPallocator() [3/3]

OMPallocator ( const OMPallocator< U, V > &  )

inline

Definition at line 75 of file OMPallocator.hpp.

                                          : device_ptr_(nullptr)
  {}

Member Function Documentation

allocate()

value_type* allocate ( std::size_t  n )

inline

Definition at line 84 of file OMPallocator.hpp.

Referenced by qmcplusplus::TEST_CASE().

  {
    static_assert(std::is_same<T, value_type>::value, "OMPallocator and HostAllocator data types must agree!");
    value_type* pt = HostAllocator::allocate(n);
#if defined(QMC_OFFLOAD_MEM_ASSOCIATED)
    cudaErrorCheck(cudaMalloc(&device_ptr_, n * sizeof(T)), "cudaMalloc failed in OMPallocator!");
    const int status = omp_target_associate_ptr(pt, device_ptr_, n * sizeof(T), 0, omp_get_default_device());
    if (status != 0)
      throw std::runtime_error("omp_target_associate_ptr failed in OMPallocator!");
#else
    PRAGMA_OFFLOAD("omp target enter data map(alloc:pt[0:n])")
    device_ptr_ = getOffloadDevicePtr(pt);
#endif
    OMPallocator_device_mem_allocated += n * sizeof(T);
    return pt;
  }

attachReference()

void attachReference ( const OMPallocator< T, HostAllocator > &  from, std::ptrdiff_t  ptr_offset  )

inline

Definition at line 116 of file OMPallocator.hpp.

Referenced by qmc_allocator_traits< OMPallocator< T, HostAllocator > >::attachReference().

  {
    device_ptr_ = const_cast<typename OMPallocator::pointer>(from.get_device_ptr()) + ptr_offset;
  }

deallocate()

void deallocate ( value_type *  pt, std::size_t  n  )

inline

Definition at line 101 of file OMPallocator.hpp.

Referenced by qmcplusplus::TEST_CASE().

  {
    OMPallocator_device_mem_allocated -= n * sizeof(T);
#if defined(QMC_OFFLOAD_MEM_ASSOCIATED)
    T* device_ptr_from_omp = getOffloadDevicePtr(pt);
    const int status       = omp_target_disassociate_ptr(pt, omp_get_default_device());
    if (status != 0)
      throw std::runtime_error("omp_target_disassociate_ptr failed in OMPallocator!");
    cudaErrorCheck(cudaFree(device_ptr_from_omp), "cudaFree failed in OMPallocator!");
#else
    PRAGMA_OFFLOAD("omp target exit data map(delete:pt[0:n])")
#endif
    HostAllocator::deallocate(pt, n);
  }

get_device_ptr() [1/2]

T* get_device_ptr ( )

inline

Definition at line 121 of file OMPallocator.hpp.

Referenced by OMPallocator< Value >::attachReference(), and qmc_allocator_traits< OMPallocator< T, HostAllocator > >::deviceSideCopyN().

{ return device_ptr_; }

get_device_ptr() [2/2]

const T* get_device_ptr ( ) const

inline

Definition at line 122 of file OMPallocator.hpp.

{ return device_ptr_; }

Member Data Documentation

device_ptr_

T* device_ptr_ = nullptr

private

Definition at line 126 of file OMPallocator.hpp.

Referenced by OMPallocator< Value >::allocate(), OMPallocator< Value >::attachReference(), and OMPallocator< Value >::get_device_ptr().

---

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

• /home/pk7/projects/qmc/for_cron_doxygen/qmcpack/src/Platforms/OMPTarget/OMPallocator.hpp