dash::allocator::GlobalAllocationPolicy< allocation_static, synchronization_collective, LMemSpaceTag > Class Template Reference

Public Member Functions
dart_gptr_t	allocate_segment (dart_team_t teamid, LocalMemorySpaceBase< memory_space_tag > *res, std::size_t nbytes, std::size_t alignment)
	Variant to allocate symmetrically in global memory space if we allocate in the default Host Space. More...
bool	deallocate_segment (dart_gptr_t gptr, LocalMemorySpaceBase< memory_space_tag > *res, void *lptr, size_t nbytes, size_t alignment)
	Similar to the allocation case above global memory is deallocated symmetrically in DART. More...

Private Member Functions
dart_gptr_t	do_global_attach (dart_team_t teamid, void *ptr, std::size_t nbytes)
bool	do_global_detach (dart_gptr_t gptr)

Detailed Description

template<class LMemSpaceTag>
class dash::allocator::GlobalAllocationPolicy< allocation_static, synchronization_collective, LMemSpaceTag >

Definition at line 74 of file AllocationPolicy.h.

Member Function Documentation

allocate_segment()

template<class LMemSpaceTag >

dart_gptr_t dash::allocator::GlobalAllocationPolicy< allocation_static, synchronization_collective, LMemSpaceTag >::allocate_segment ( dart_team_t  teamid, LocalMemorySpaceBase< memory_space_tag > *  res, std::size_t  nbytes, std::size_t  alignment  )

inline

Variant to allocate symmetrically in global memory space if we allocate in the default Host Space.

In this case DART can allocate symmatrically.

Definition at line 84 of file AllocationPolicy.h.

References DART_GPTR_ISNULL.

  {
    DASH_LOG_DEBUG(
        "GlobalAllocationPolicy.do_global_allocate(nlocal)",
        "number of local values:",
        nbytes);

    auto lp = res->allocate(nbytes, alignment);

    if (!lp && nbytes > 0) {
      throw std::bad_alloc{};
    }

    DASH_LOG_DEBUG_VAR(
        "GlobalAllocationPolicy.do_global_allocate(nlocal)", lp);

    // Here, we attach the allocated global pointer. DART internally stores
    // this pointer in such a way that we can retrieve it by looking up the
    // local address (teamid <- my_id, addr_or_offset.offset <- 0)
    auto gptr = AttachDetachPolicy::do_global_attach(
        teamid, lp, nbytes);

    if (DART_GPTR_ISNULL(gptr)) {
      res->deallocate(lp, nbytes, alignment);
      throw std::bad_alloc{};
    }

    DASH_LOG_DEBUG_VAR(
        "GlobalAllocationPolicy.do_global_allocate(nlocal)", gptr);

    DASH_LOG_DEBUG("GlobalAllocationPolicy.do_global_allocate(nlocal) >");

    return gptr;
  }

deallocate_segment()

template<class LMemSpaceTag >

bool dash::allocator::GlobalAllocationPolicy< allocation_static, synchronization_collective, LMemSpaceTag >::deallocate_segment ( dart_gptr_t  gptr, LocalMemorySpaceBase< memory_space_tag > *  res, void *  lptr, size_t  nbytes, size_t  alignment  )

inline

Similar to the allocation case above global memory is deallocated symmetrically in DART.

Definition at line 125 of file AllocationPolicy.h.

  {
    DASH_LOG_DEBUG("< GlobalAllocationPolicy.do_global_deallocate");
    DASH_LOG_DEBUG_VAR("GlobalAllocationPolicy.do_global_deallocate", gptr);
    DASH_LOG_DEBUG_VAR("GlobalAllocationPolicy.do_global_deallocate", lptr);
    DASH_LOG_DEBUG_VAR("GlobalAllocationPolicy.do_global_deallocate", nbytes);

    DASH_ASSERT_RETURNS(AttachDetachPolicy::do_global_detach(gptr), true);

    res->deallocate(lptr, nbytes, alignment);

    DASH_LOG_DEBUG("GlobalAllocationPolicy.do_global_deallocate >");
    return true;
  }

---

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

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