dash::EpochSynchronizedAllocator< ElementType, LMemSpace, AllocationPolicy, LocalAlloc > Class Template Reference

Encapsulates a memory allocation and deallocation strategy of global memory regions distributed across local memory of units in a specified team. More...

#include <EpochSynchronizedAllocator.h>

Public Types
using	local_allocator_type = LocalAlloc< ElementType >
using	value_type = ElementType
	Allocator Traits. More...
using	size_type = dash::default_size_t
using	difference_type = dash::default_index_t
using	pointer = dart_gptr_t
using	const_pointer = dart_gptr_t const
using	void_pointer = dart_gptr_t
using	const_void_pointer = dart_gptr_t const
using	local_pointer = typename allocator_traits::pointer
using	const_local_pointer = typename allocator_traits::const_pointer
using	local_void_pointer = typename allocator_traits::void_pointer
using	const_local_void_pointer = typename allocator_traits::const_void_pointer
using	allocation_policy = std::integral_constant< global_allocation_policy, AllocationPolicy >
template<class U >
using	rebind = dash::EpochSynchronizedAllocator< U, LMemSpace, AllocationPolicy, LocalAlloc >
	Convert EpochSynchronizedAllocator<T> to EpochSynchronizedAllocator<U>. More...

Public Member Functions
	EpochSynchronizedAllocator (Team const &team, LMemSpace *r=nullptr) noexcept
	Constructor. More...
	EpochSynchronizedAllocator (const self_t &other) noexcept
	Copy constructor. More...
self_t &	operator= (const self_t &other) noexcept
	Copy Assignment operator. More...
	EpochSynchronizedAllocator (self_t &&other) noexcept
	Move-constructor. More...
self_t &	operator= (self_t &&other) noexcept
	Move-assignment operator. More...
void	swap (self_t &other) noexcept
	Swap two collective Allocators. More...
	~EpochSynchronizedAllocator () noexcept
	Destructor. More...
size_type	max_size () const noexcept
	Estimate the largest supported size. More...
pointer	attach (local_pointer lptr, size_type num_local_elem)
	Register pre-allocated local memory segment of num_local_elem elements in global memory space. More...
void	detach (pointer gptr, size_type num_local_elem)
	Unregister local memory segment from global memory space. More...
local_pointer	allocate_local (size_type num_local_elem)
	Allocates num_local_elem local elements in the active unit's local memory. More...
void	deallocate_local (local_pointer lptr, size_type num_local_elem)
	Deallocates memory segment in the active unit's local memory. More...
pointer	allocate (size_type num_local_elem)
	Allocates a global memory segment with at least num_local_elem bytes. More...
void	deallocate (pointer gptr, size_type num_local_elem)
	Deallocates a memory segment from global memory space. More...
local_allocator_type	get_local_allocator () const noexcept
	Returns a copy of the local allocator object associated with the vector. More...

Friends
template<class T , class U >
bool	operator== (const EpochSynchronizedAllocator< T, LMemSpace, AllocationPolicy, LocalAlloc > &lhs, const EpochSynchronizedAllocator< U, LMemSpace, AllocationPolicy, LocalAlloc > &rhs)
template<class T , class U >
bool	operator!= (const EpochSynchronizedAllocator< T, LMemSpace, AllocationPolicy, LocalAlloc > &lhs, const EpochSynchronizedAllocator< U, LMemSpace, AllocationPolicy, LocalAlloc > &rhs)

Detailed Description

template<typename ElementType, typename LMemSpace = dash::HostSpace, global_allocation_policy AllocationPolicy = global_allocation_policy::epoch_synchronized, template< class T > class LocalAlloc = allocator::DefaultAllocator>
class dash::EpochSynchronizedAllocator< ElementType, LMemSpace, AllocationPolicy, LocalAlloc >

Encapsulates a memory allocation and deallocation strategy of global memory regions distributed across local memory of units in a specified team.

Satisfied STL concepts:

• Allocator

• CopyAssignable

  Implemented concept:

  DashAllocatorConcept

Definition at line 45 of file EpochSynchronizedAllocator.h.

Member Typedef Documentation

rebind

template<typename ElementType , typename LMemSpace = dash::HostSpace, global_allocation_policy AllocationPolicy = global_allocation_policy::epoch_synchronized, template< class T > class LocalAlloc = allocator::DefaultAllocator>

template<class U >

using dash::EpochSynchronizedAllocator< ElementType, LMemSpace, AllocationPolicy, LocalAlloc >::rebind = dash:: EpochSynchronizedAllocator<U, LMemSpace, AllocationPolicy, LocalAlloc>

Convert EpochSynchronizedAllocator<T> to EpochSynchronizedAllocator<U>.

Definition at line 121 of file EpochSynchronizedAllocator.h.

value_type

template<typename ElementType , typename LMemSpace = dash::HostSpace, global_allocation_policy AllocationPolicy = global_allocation_policy::epoch_synchronized, template< class T > class LocalAlloc = allocator::DefaultAllocator>

using dash::EpochSynchronizedAllocator< ElementType, LMemSpace, AllocationPolicy, LocalAlloc >::value_type = ElementType

Allocator Traits.

Definition at line 100 of file EpochSynchronizedAllocator.h.

Constructor & Destructor Documentation

EpochSynchronizedAllocator() [1/3]

template<typename ElementType , typename LMemSpace , global_allocation_policy AllocationPolicy, template< class > class LocalAlloc>

dash::EpochSynchronizedAllocator< ElementType, LMemSpace, AllocationPolicy, LocalAlloc >::EpochSynchronizedAllocator ( Team const &  team, LMemSpace *  r = nullptr  )

explicitnoexcept

Constructor.

Creates a new instance of dash::EpochSynchronizedAllocator for a given team.

Definition at line 347 of file EpochSynchronizedAllocator.h.

Referenced by dash::EpochSynchronizedAllocator< ElementType, LMemSpace, AllocationPolicy, LocalAlloc >::get_local_allocator().

  : _team(&team)
  , _alloc(
        r ? r
          : static_cast<LMemSpace *>(
                get_default_memory_space<
                    memory_domain_local,
                    typename memory_traits::memory_space_type_category>()))
  , _policy{}
{
  DASH_LOG_DEBUG(
      "EpochSynchronizedAllocator.SymmetricAllocator(team, alloc) >");
  _segments.reserve(1);
}

EpochSynchronizedAllocator() [2/3]

template<typename ElementType , typename LMemSpace , global_allocation_policy AllocationPolicy, template< class > class LocalAlloc>

dash::EpochSynchronizedAllocator< ElementType, LMemSpace, AllocationPolicy, LocalAlloc >::EpochSynchronizedAllocator ( const self_t &  other )

noexcept

Copy constructor.

See also

DashAllocatorConcept

Definition at line 371 of file EpochSynchronizedAllocator.h.

References dash::EpochSynchronizedAllocator< ElementType, LMemSpace, AllocationPolicy, LocalAlloc >::operator=().

{
  operator=(other);
}

EpochSynchronizedAllocator() [3/3]

template<typename ElementType , typename LMemSpace , global_allocation_policy AllocationPolicy, template< class > class LocalAlloc>

dash::EpochSynchronizedAllocator< ElementType, LMemSpace, AllocationPolicy, LocalAlloc >::EpochSynchronizedAllocator ( self_t &&  other )

noexcept

Move-constructor.

Takes ownership of the moved instance's allocation.

Definition at line 385 of file EpochSynchronizedAllocator.h.

  : _team(other._team)
  , _alloc(std::move(other._alloc))
  , _segments(std::move(other._segments))
  , _policy(other._policy)
{
  other.clear();
}

~EpochSynchronizedAllocator()

template<typename ElementType , typename LMemSpace , global_allocation_policy AllocationPolicy, template< class > class LocalAlloc>

dash::EpochSynchronizedAllocator< ElementType, LMemSpace, AllocationPolicy, LocalAlloc >::~EpochSynchronizedAllocator ( )

noexcept

Destructor.

Frees all global memory regions allocated by this allocator instance.

Definition at line 465 of file EpochSynchronizedAllocator.h.

{
  clear();
}

Member Function Documentation

allocate()

template<typename ElementType , typename LMemSpace , global_allocation_policy AllocationPolicy, template< class > class LocalAlloc>

EpochSynchronizedAllocator< ElementType, LMemSpace, AllocationPolicy, LocalAlloc >::pointer dash::EpochSynchronizedAllocator< ElementType, LMemSpace, AllocationPolicy, LocalAlloc >::allocate

(

size_type

num_local_elem

)

Allocates a global memory segment with at least num_local_elem bytes.

It is semantically identical to call allocate_local (obtaining a local pointer) and subsequently attaching it to obtain a global pointer. it. Collective operation.

See also

DashAllocatorConcept

Definition at line 693 of file EpochSynchronizedAllocator.h.

References DART_GPTR_ISNULL.

Referenced by dash::EpochSynchronizedAllocator< ElementType, LMemSpace, AllocationPolicy, LocalAlloc >::max_size().

{
  DASH_LOG_DEBUG(
      "EpochSynchronizedAllocator.allocate",
      "num_local_elem",
      num_local_elem);

  auto it = do_local_allocate(num_local_elem);

  DASH_ASSERT_MSG(it->lptr() != nullptr, "local pointer must not be NULL");

  auto gptr = _policy.do_global_attach(
      _team->dart_id(), it->lptr(), num_local_elem * sizeof(ElementType));

  DASH_ASSERT_MSG(!DART_GPTR_ISNULL(gptr), "gptr must not be null");

  it->gptr() = gptr;

  return gptr;
}

allocate_local()

template<typename ElementType , typename LMemSpace , global_allocation_policy AllocationPolicy, template< class > class LocalAlloc>

EpochSynchronizedAllocator< ElementType, LMemSpace, AllocationPolicy, LocalAlloc >::local_pointer dash::EpochSynchronizedAllocator< ElementType, LMemSpace, AllocationPolicy, LocalAlloc >::allocate_local

(

size_type

num_local_elem

)

Allocates num_local_elem local elements in the active unit's local memory.

Local operation.

See also

DashEpochSynchronizedAllocatorConcept

Definition at line 501 of file EpochSynchronizedAllocator.h.

References dash::EpochSynchronizedAllocator< ElementType, LMemSpace, AllocationPolicy, LocalAlloc >::deallocate_local().

Referenced by dash::EpochSynchronizedAllocator< ElementType, LMemSpace, AllocationPolicy, LocalAlloc >::max_size().

{
  DASH_LOG_DEBUG(
      "SymmetricAllocator.allocate_local(n)",
      "number of local values:",
      num_local_elem);

  auto it = do_local_allocate(num_local_elem);

  DASH_ASSERT_MSG(it->lptr() != nullptr, "invalid pointer");

  return it->lptr();
}

attach()

template<typename ElementType , typename LMemSpace , global_allocation_policy AllocationPolicy, template< class > class LocalAlloc>

EpochSynchronizedAllocator< ElementType, LMemSpace, AllocationPolicy, LocalAlloc >::pointer dash::EpochSynchronizedAllocator< ElementType, LMemSpace, AllocationPolicy, LocalAlloc >::attach	(	local_pointer	lptr,
		size_type	num_local_elem
	)

Register pre-allocated local memory segment of num_local_elem elements in global memory space.

Collective operation. The number of allocated elements may differ between units.

See also

DashEpochSynchronizedAllocatorConcept

Definition at line 573 of file EpochSynchronizedAllocator.h.

References DART_GPTR_ISNULL, DART_GPTR_NULL, and dash::end().

Referenced by dash::EpochSynchronizedAllocator< ElementType, LMemSpace, AllocationPolicy, LocalAlloc >::max_size().

{
  DASH_LOG_DEBUG(
      "EpochSynchronizedAllocator.attach",
      "local_pointer:",
      lptr,
      "length:",
      num_local_elem);

  auto pos = lookup_segment_by_lptr(lptr);

  if (pos == std::end(_segments)) {
    DASH_LOG_ERROR(
        "EpochSynchronizedAllocator.attach", "Invalid local pointer", lptr);
    return DART_GPTR_NULL;
  }

  DASH_ASSERT_EQ(num_local_elem, pos->length(), "invalid block length");

  auto gptr = _policy.do_global_attach(
      _team->dart_id(), pos->lptr(), pos->length() * sizeof(ElementType));

  DASH_ASSERT_MSG(!DART_GPTR_ISNULL(gptr), "gptr must not be null");

  pos->gptr() = gptr;

  return gptr;
}

deallocate()

template<typename ElementType , typename LMemSpace , global_allocation_policy AllocationPolicy, template< class > class LocalAlloc>

void dash::EpochSynchronizedAllocator< ElementType, LMemSpace, AllocationPolicy, LocalAlloc >::deallocate	(	pointer	gptr,
		size_type	num_local_elem
	)

Deallocates a memory segment from global memory space.

It is semantically identical to first call detach on the specified global pointer and subsequently locally deallocate it.

Collective operation.

See also

DashAllocatorConcept

Definition at line 648 of file EpochSynchronizedAllocator.h.

References dash::begin(), DART_GPTR_EQUAL, DART_GPTR_ISNULL, dash::end(), and dash::find_if().

Referenced by dash::EpochSynchronizedAllocator< ElementType, LMemSpace, AllocationPolicy, LocalAlloc >::get_local_allocator(), and dash::EpochSynchronizedAllocator< ElementType, LMemSpace, AllocationPolicy, LocalAlloc >::max_size().

{
  DASH_LOG_DEBUG(
      "EpochSynchronizedAllocator.deallocate", "deallocate local memory");

  if (DART_GPTR_ISNULL(gptr)) {
    return;
  }

  auto pos = std::find_if(
      std::begin(_segments),
      std::end(_segments),
      [gptr](const allocation_rec_t &a) {
        return DART_GPTR_EQUAL(a.gptr(), gptr);
      });

  if (pos == std::end(_segments)) {
    DASH_LOG_ERROR(
        "EpochSynchronizedAllocator.detach", "Invalid global pointer", gptr);
    return;
  }

  DASH_ASSERT_EQ(pos->length(), num_local_elem, "invalid block length");

  _policy.do_global_detach(pos->gptr());

  allocator_traits::deallocate(_alloc, pos->lptr(), pos->length());

  _segments.erase(pos);
}

deallocate_local()

template<typename ElementType , typename LMemSpace , global_allocation_policy AllocationPolicy, template< class > class LocalAlloc>

void dash::EpochSynchronizedAllocator< ElementType, LMemSpace, AllocationPolicy, LocalAlloc >::deallocate_local	(	local_pointer	lptr,
		size_type	num_local_elem
	)

Deallocates memory segment in the active unit's local memory.

Local operation.

See also

DashEpochSynchronizedAllocatorConcept

Definition at line 525 of file EpochSynchronizedAllocator.h.

References DART_GPTR_ISNULL, and dash::end().

Referenced by dash::EpochSynchronizedAllocator< ElementType, LMemSpace, AllocationPolicy, LocalAlloc >::allocate_local(), and dash::EpochSynchronizedAllocator< ElementType, LMemSpace, AllocationPolicy, LocalAlloc >::max_size().

{
  DASH_LOG_DEBUG(
      "EpochSynchronizedAllocator.deallocate_local(n)",
      "local pointer",
      lptr,
      "length:",
      num_local_elem);

  auto pos = lookup_segment_by_lptr(lptr);

  if (pos == std::end(_segments)) {
    DASH_LOG_ERROR(
        "EpochSynchronizedAllocator.deallocate_local",
        "invalid local pointer",
        lptr);
    return;
  }

  DASH_ASSERT_EQ(pos->length(), num_local_elem, "Invalid block length");

  if (!DART_GPTR_ISNULL(pos->gptr())) {
    DASH_LOG_ERROR(
        "EpochSynchronizedAllocator.deallocate_local",
        "local pointer must not be attached to global memory",
        lptr);
    return;
  }

  allocator_traits::deallocate(_alloc, pos->lptr(), pos->length());

  _segments.erase(pos);
}

detach()

template<typename ElementType , typename LMemSpace , global_allocation_policy AllocationPolicy, template< class > class LocalAlloc>

void dash::EpochSynchronizedAllocator< ElementType, LMemSpace, AllocationPolicy, LocalAlloc >::detach	(	pointer	gptr,
		size_type	num_local_elem
	)

Unregister local memory segment from global memory space.

Does not deallocate local memory.

Collective operation.

See also

DashEpochSynchronizedAllocatorConcept

Definition at line 611 of file EpochSynchronizedAllocator.h.

References DART_GPTR_ISNULL, DART_GPTR_NULL, and dash::end().

Referenced by dash::EpochSynchronizedAllocator< ElementType, LMemSpace, AllocationPolicy, LocalAlloc >::max_size().

{
  DASH_LOG_DEBUG(
      "EpochSynchronizedAllocator.detach",
      "global pointer:",
      gptr,
      "length:",
      num_local_elem);

  if (DART_GPTR_ISNULL(gptr)) {
    return;
  }

  auto pos = lookup_segment_by_gptr(gptr);

  if (pos == std::end(_segments)) {
    DASH_LOG_ERROR(
        "EpochSynchronizedAllocator.detach", "Invalid global pointer", gptr);
    return;
  }

  DASH_ASSERT_EQ(num_local_elem, pos->length(), "invalid block length");

  _policy.do_global_detach(pos->gptr());

  pos->gptr() = DART_GPTR_NULL;
}

get_local_allocator()

template<typename ElementType , typename LMemSpace = dash::HostSpace, global_allocation_policy AllocationPolicy = global_allocation_policy::epoch_synchronized, template< class T > class LocalAlloc = allocator::DefaultAllocator>

local_allocator_type dash::EpochSynchronizedAllocator< ElementType, LMemSpace, AllocationPolicy, LocalAlloc >::get_local_allocator ( ) const

inlinenoexcept

Returns a copy of the local allocator object associated with the vector.

Definition at line 239 of file EpochSynchronizedAllocator.h.

References dash::begin(), DART_GPTR_EQUAL, DART_GPTR_NULL, dash::EpochSynchronizedAllocator< ElementType, LMemSpace, AllocationPolicy, LocalAlloc >::deallocate(), dash::end(), dash::EpochSynchronizedAllocator< ElementType, LMemSpace, AllocationPolicy, LocalAlloc >::EpochSynchronizedAllocator(), and dash::find_if().

  {
    return _alloc;
  }

max_size()

template<typename ElementType , typename LMemSpace = dash::HostSpace, global_allocation_policy AllocationPolicy = global_allocation_policy::epoch_synchronized, template< class T > class LocalAlloc = allocator::DefaultAllocator>

size_type dash::EpochSynchronizedAllocator< ElementType, LMemSpace, AllocationPolicy, LocalAlloc >::max_size ( ) const

inlinenoexcept

Estimate the largest supported size.

Definition at line 171 of file EpochSynchronizedAllocator.h.

References dash::EpochSynchronizedAllocator< ElementType, LMemSpace, AllocationPolicy, LocalAlloc >::allocate(), dash::EpochSynchronizedAllocator< ElementType, LMemSpace, AllocationPolicy, LocalAlloc >::allocate_local(), dash::EpochSynchronizedAllocator< ElementType, LMemSpace, AllocationPolicy, LocalAlloc >::attach(), dash::EpochSynchronizedAllocator< ElementType, LMemSpace, AllocationPolicy, LocalAlloc >::deallocate(), dash::EpochSynchronizedAllocator< ElementType, LMemSpace, AllocationPolicy, LocalAlloc >::deallocate_local(), and dash::EpochSynchronizedAllocator< ElementType, LMemSpace, AllocationPolicy, LocalAlloc >::detach().

  {
    return size_type(-1) / sizeof(ElementType);
  }

operator=() [1/2]

template<typename ElementType , typename LMemSpace , global_allocation_policy AllocationPolicy, template< class > class LocalAlloc>

EpochSynchronizedAllocator< ElementType, LMemSpace, AllocationPolicy, LocalAlloc >::self_t & dash::EpochSynchronizedAllocator< ElementType, LMemSpace, AllocationPolicy, LocalAlloc >::operator= ( const self_t &  other )

noexcept

Copy Assignment operator.

See also

DashAllocatorConcept

Definition at line 408 of file EpochSynchronizedAllocator.h.

Referenced by dash::EpochSynchronizedAllocator< ElementType, LMemSpace, AllocationPolicy, LocalAlloc >::EpochSynchronizedAllocator(), and dash::EpochSynchronizedAllocator< ElementType, LMemSpace, AllocationPolicy, LocalAlloc >::operator=().

{
  if (&other == this) {
    return *this;
  }

  _alloc = other._alloc;

  _team = other._team;

  _policy = other._policy;

  return *this;
}

operator=() [2/2]

template<typename ElementType , typename LMemSpace , global_allocation_policy AllocationPolicy, template< class > class LocalAlloc>

EpochSynchronizedAllocator< ElementType, LMemSpace, AllocationPolicy, LocalAlloc >::self_t & dash::EpochSynchronizedAllocator< ElementType, LMemSpace, AllocationPolicy, LocalAlloc >::operator= ( self_t &&  other )

noexcept

Move-assignment operator.

Definition at line 437 of file EpochSynchronizedAllocator.h.

References dash::EpochSynchronizedAllocator< ElementType, LMemSpace, AllocationPolicy, LocalAlloc >::operator=(), and dash::EpochSynchronizedAllocator< ElementType, LMemSpace, AllocationPolicy, LocalAlloc >::swap().

{
  if (&other == this) {
    return *this;
  }

  if (_alloc == other._alloc) {
    // If the local allocators equal each other we can move everything
    clear();
    swap(other);
  }
  else {
    // otherwise we do not touch any data and copy assign it
    operator=(other);
  }

  return *this;
}

swap()

template<typename ElementType , typename LMemSpace , global_allocation_policy AllocationPolicy, template< class > class LocalAlloc>

void dash::EpochSynchronizedAllocator< ElementType, LMemSpace, AllocationPolicy, LocalAlloc >::swap ( self_t &  other )

noexcept

Swap two collective Allocators.

Definition at line 479 of file EpochSynchronizedAllocator.h.

Referenced by dash::EpochSynchronizedAllocator< ElementType, LMemSpace, AllocationPolicy, LocalAlloc >::operator=().

{
  std::swap(_team, other._team);
  std::swap(_alloc, other._alloc);
  std::swap(_segments, other._segments);
  std::swap(_policy, other._policy);
}

---

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

• /tmp/tmporruphar/dash/include/dash/allocator/EpochSynchronizedAllocator.h