dart_globmem.h

Go to the documentation of this file.

#ifndef DART_GLOBMEM_H_INCLUDED
#define DART_GLOBMEM_H_INCLUDED

#include <dash/dart/if/dart_util.h>
#include <dash/dart/if/dart_types.h>
#include <dash/dart/if/dart_team_group.h>

#ifdef __cplusplus
extern "C" {
#endif

#define DART_INTERFACE_ON

/*
  --- DART global pointers ---

  There are multiple options for representing the global
  pointer that come to mind:

  1) struct with pre-defined members (say, unit id
    and local address)
  2) an opaque object that leaves the details to a specific
    implementation and is manipulated only through pointers
  3) a fixed size integer data type (say 64 bit or 128 bit),
    manipulated through c macros that packs all the
    relevant information

 There are pros and cons to each option...

 Another question is that of offsets vs. addresses: Either a local
 virtual address is directly included and one in which the pointer
 holds something like a segment ID and an offset within that segment.

 If we want to support virtual addresses then 64 bits is not enough to
 represent the pointer. If we only support segment offsets, 64 bit
 could be sufficient

 Yet another question is what kind of operations are supported on
 global pointers. For example UPC global pointers keep "phase"
 information that allows pointer arithmetic (the phase is needed for
 knowing when you have to move to the next node).

 PROPOSAL: Don't include phase information with pointers on the DART
 level, but don't preclude support the same concept on the DASH level.

  */

  /*
 PROPOSAL: use 128 bit global pointers with the following layout:


 0       1       2       3       4       5       6       7
 0123456701234567012345670123456701234567012345670123456701234567
 |----<24 bit unit id>---|-flags-|-<segment id>--|---<team id>--|
 |-----------<64 bit virtual address or offset>-----------------|

  */

typedef struct
{
  dart_unit_t  unitid : 24;
  unsigned int flags  :  8;
  int16_t     segid;
  int16_t     teamid;
  union
  {
    uint64_t offset;
    void*    addr;
  } addr_or_offs;
} dart_gptr_t;

#ifdef __cplusplus
#define DART_GPTR_NULL (dart_gptr_t { -1, 0, 0, DART_TEAM_NULL, { 0 } })
#else
#define DART_GPTR_NULL \
(dart_gptr_t){ .unitid = -1, \
               .flags  =  0, \
               .segid  =  0, \
               .teamid  =  DART_TEAM_NULL, \
               .addr_or_offs.offset = 0 }
#endif

#define DART_GPTR_ISNULL(gptr_)         \
  (gptr_.unitid<0 && gptr_.segid==0 &&  \
   gptr_.teamid==DART_TEAM_NULL   &&    \
   gptr_.addr_or_offs.addr==0)

#define DART_GPTR_EQUAL(gptr1_, gptr2_ )    \
  ((gptr1_.unitid == gptr2_.unitid) &&      \
   (gptr1_.segid  == gptr2_.segid)  &&      \
   (gptr1_.teamid == gptr2_.teamid) &&      \
   (gptr1_.addr_or_offs.offset ==           \
    gptr2_.addr_or_offs.offset) )


#define DART_SEGMENT_LOCAL ((int16_t)0)


dart_ret_t dart_gptr_getaddr(
  const dart_gptr_t    gptr,
        void        ** addr) DART_NOTHROW;

dart_ret_t dart_gptr_setaddr(
  dart_gptr_t * gptr,
  void        * addr) DART_NOTHROW;

DART_INLINE DART_NOTHROW
dart_ret_t
dart_gptr_incaddr(
  dart_gptr_t * gptr,
  int64_t       offs)
{
  gptr->addr_or_offs.offset += offs;
  return DART_OK;
}

DART_INLINE DART_NOTHROW
dart_ret_t dart_gptr_setunit(
  dart_gptr_t      * gptr,
  dart_team_unit_t   unit)
{
  gptr->unitid = unit.id;
  return DART_OK;
}

dart_ret_t dart_gptr_getflags(
  dart_gptr_t   gptr,
  uint16_t    * flags) DART_NOTHROW;


dart_ret_t dart_gptr_setflags(
  dart_gptr_t * gptr,
  uint16_t      flags) DART_NOTHROW;

typedef struct dart_allocator_struct * dart_allocator_t;

dart_ret_t dart_allocator_new(
  size_t             pool_size,
  dart_team_t        team,
  dart_allocator_t * new_allocator);

dart_ret_t dart_allocator_alloc(
  size_t             nelem,
  dart_datatype_t    dtype,
  dart_gptr_t      * gptr,
  dart_allocator_t   allocator);

dart_ret_t dart_allocator_free(
  dart_gptr_t      * gptr,
  dart_allocator_t   allocator);

dart_ret_t dart_allocator_destroy(dart_allocator_t *allocator);

dart_ret_t dart_memalloc(
  size_t            nelem,
  dart_datatype_t   dtype,
  dart_gptr_t     * gptr) DART_NOTHROW;

dart_ret_t dart_memfree(dart_gptr_t gptr) DART_NOTHROW;

dart_ret_t dart_team_memalloc_aligned(
  dart_team_t       teamid,
  size_t            nelem,
  dart_datatype_t   dtype,
  dart_gptr_t     * gptr) DART_NOTHROW;

dart_ret_t dart_team_memfree(
  dart_gptr_t gptr) DART_NOTHROW;

dart_ret_t dart_team_memregister_aligned(
  dart_team_t       teamid,
  size_t            nelem,
  dart_datatype_t   dtype,
  void            * addr,
  dart_gptr_t     * gptr) DART_NOTHROW;

dart_ret_t dart_team_memregister(
  dart_team_t       teamid,
  size_t            nlelem,
  dart_datatype_t   dtype,
  void            * addr,
  dart_gptr_t     * gptr) DART_NOTHROW;

dart_ret_t dart_team_memderegister(dart_gptr_t gptr) DART_NOTHROW;


#define DART_INTERFACE_OFF

#ifdef __cplusplus
}
#endif

#endif /* DART_GLOBMEM_H_INCLUDED */