dash::allocator::GlobalAllocationPolicy< allocation_static, synchronization_single, memory_space_host_tag > Class Template Reference

LocalAllocationPolicy: Implements a mechanism to allocate locally, independent of the other units. More...

#include <AllocationPolicy.h>

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

Detailed Description

template<>
class dash::allocator::GlobalAllocationPolicy< allocation_static, synchronization_single, memory_space_host_tag >

LocalAllocationPolicy: Implements a mechanism to allocate locally, independent of the other units.

This local memory portion is allocated from a memory pool which is already attached to global memory. This variant is a good fit in cases where only one units needs to allocate memory while the other units do not contribute any local portion. It is used for example used to implement dash::Shared.

Note: Both allocation and deallocation are non-collective. The user has to ensure that the owning unit does not release the memory while other units are still operating on it.

Definition at line 224 of file AllocationPolicy.h.

Member Function Documentation

allocate_segment()

dart_gptr_t dash::allocator::GlobalAllocationPolicy< allocation_static, synchronization_single, memory_space_host_tag >::allocate_segment ( LocalMemorySpaceBase< memory_space_tag > *  , std::size_t  nbytes, std::size_t    )

inline

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

In this case DART allocates from the internal buddy allocator.

Parameters

nbytes

the number of bytes to allocate

Definition at line 234 of file AllocationPolicy.h.

References DART_GPTR_NULL, dart_memalloc(), and DART_OK.

  {
    dart_gptr_t gptr = DART_GPTR_NULL;

    if (nbytes > 0) {
      dash::dart_storage<uint8_t> ds(nbytes);
      auto const ret = dart_memalloc(ds.nelem, ds.dtype, &gptr);
      if (ret != DART_OK) {
        DASH_LOG_ERROR(
            "LocalAllocationPolicy.do_global_allocate",
            "cannot allocate local memory",
            ret);
        throw std::bad_alloc{};
      }
      DASH_LOG_DEBUG_VAR("LocalAllocator.allocate >", gptr);
    }
    return gptr;
  }

deallocate_segment()

bool dash::allocator::GlobalAllocationPolicy< allocation_static, synchronization_single, memory_space_host_tag >::deallocate_segment ( dart_gptr_t  gptr, LocalMemorySpaceBase< memory_space_tag > *  , void *  , size_t  , size_t    )

inline

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

Definition at line 261 of file AllocationPolicy.h.

References dart_memfree(), and DART_OK.

  {
    auto const ret = dart_memfree(gptr) == DART_OK;
    return ret;
  }

---

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

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