LCOV - code coverage report
Current view: top level - home/fuchsto/workspaces/dash-development/dart-impl/mpi/src - dart_globmem.c (source / functions) Hit Total Coverage
Test: coverage.info.cleaned Lines: 120 189 63.5 %
Date: 2016-06-29 12:30:40 Functions: 9 11 81.8 %

          Line data    Source code
       1             : /**
       2             :  * \file dart_globmem.c
       3             :  *
       4             :  * Implementation of all the related global pointer operations
       5             :  *
       6             :  * All the following functions are implemented with the underlying *MPI-3*
       7             :  * one-sided runtime system.
       8             :  */
       9             : 
      10             : #include <stdio.h>
      11             : #include <mpi.h>
      12             : #include <dash/dart/base/logging.h>
      13             : #include <dash/dart/if/dart_types.h>
      14             : #include <dash/dart/if/dart_globmem.h>
      15             : #include <dash/dart/if/dart_team_group.h>
      16             : #include <dash/dart/if/dart_communication.h>
      17             : #include <dash/dart/mpi/dart_mpi_util.h>
      18             : #include <dash/dart/mpi/dart_mem.h>
      19             : #include <dash/dart/mpi/dart_translation.h>
      20             : #include <dash/dart/mpi/dart_team_private.h>
      21             : 
      22             : /* For PRIu64, uint64_t in printf */
      23             : #define __STDC_FORMAT_MACROS
      24             : #include <inttypes.h>
      25             : 
      26             : /**
      27             :  * @note For dart collective allocation/free: offset in the returned gptr
      28             :  * represents the displacement relative to the beginning of sub-memory
      29             :  * spanned by certain dart collective allocation.
      30             :  * For dart local allocation/free: offset in the returned gptr represents
      31             :  * the displacement relative to
      32             :  * the base address of memory region reserved for the dart local
      33             :  * allocation/free.
      34             :  */
      35             : int16_t dart_memid;
      36             : int16_t dart_registermemid;
      37             : 
      38        2410 : dart_ret_t dart_gptr_getaddr(const dart_gptr_t gptr, void **addr)
      39             : {
      40        2410 :         int16_t seg_id = gptr.segid;
      41        2410 :         uint64_t offset = gptr.addr_or_offs.offset;
      42             :         dart_unit_t myid;
      43        2410 :         dart_myid (&myid);
      44             : 
      45        2410 :         if (myid == gptr.unitid) {
      46        2410 :                 if (seg_id) {
      47        2362 :                         if (dart_adapt_transtable_get_selfbaseptr(seg_id, (char **)addr) == -1) {
      48           0 :                                 return DART_ERR_INVAL;}
      49             : 
      50        2362 :                         *addr = offset + (char *)(*addr);
      51             :                 } else {
      52          48 :                         if (myid == gptr.unitid) {
      53          48 :                                 *addr = offset + dart_mempool_localalloc;
      54             :                         }
      55             :                 }
      56             :         } else {
      57           0 :                 *addr = NULL;
      58             :         }
      59        2410 :         return DART_OK;
      60             : }
      61             : 
      62           0 : dart_ret_t dart_gptr_setaddr(dart_gptr_t* gptr, void* addr)
      63             : {
      64           0 :         int16_t seg_id = gptr->segid;
      65             :         /* The modification to addr is reflected in the fact that modifying
      66             :    * the offset.
      67             :    */
      68           0 :         if (seg_id) {
      69             :                 char* addr_base;
      70           0 :     if (dart_adapt_transtable_get_selfbaseptr(seg_id, &addr_base) == -1) {
      71           0 :                         return DART_ERR_INVAL;
      72             :     }
      73           0 :                 gptr->addr_or_offs.offset = (char *)addr - addr_base;
      74             :         } else {
      75           0 :                 gptr->addr_or_offs.offset = (char *)addr - dart_mempool_localalloc;
      76             :         }
      77           0 :         return DART_OK;
      78             : }
      79             : 
      80    12806075 : dart_ret_t dart_gptr_incaddr (dart_gptr_t* gptr, int offs)
      81             : {
      82    12806075 :         gptr -> addr_or_offs.offset += offs;
      83    12806075 :         return DART_OK;
      84             : }
      85             : 
      86             : 
      87    12800830 : dart_ret_t dart_gptr_setunit (dart_gptr_t* gptr, dart_unit_t unit_id)
      88             : {
      89    12800830 :         gptr->unitid = unit_id;
      90    12800830 :         return DART_OK;
      91             : }
      92             : 
      93          24 : dart_ret_t dart_memalloc (size_t nbytes, dart_gptr_t *gptr)
      94             : {
      95             :         dart_unit_t unitid;
      96          24 :         dart_myid (&unitid);
      97          24 :         gptr->unitid = unitid;
      98          24 :         gptr->segid = 0; /* For local allocation, the segid is marked as '0'. */
      99          24 :         gptr->flags = 0; /* For local allocation, the flag is marked as '0'. */
     100          24 :         gptr->addr_or_offs.offset = dart_buddy_alloc(dart_localpool, nbytes);
     101          24 :         if (gptr->addr_or_offs.offset == (uint64_t)(-1)) {
     102           0 :                 DART_LOG_ERROR("dart_memalloc: Out of bounds "
     103             :                    "(dart_buddy_alloc %zu bytes): global memory exhausted",
     104             :                    nbytes);
     105           0 :                 return DART_ERR_OTHER;
     106             :         }
     107             :         DART_LOG_DEBUG("dart_memalloc: local alloc nbytes:%lu offset:%"PRIu64"",
     108             :                  nbytes, gptr->addr_or_offs.offset);
     109          24 :         return DART_OK;
     110             : }
     111             : 
     112          24 : dart_ret_t dart_memfree (dart_gptr_t gptr)
     113             : {
     114          24 :   if (dart_buddy_free(dart_localpool, gptr.addr_or_offs.offset) == -1) {
     115           0 :     DART_LOG_ERROR("dart_memfree: invalid local global pointer: "
     116             :                    "invalid offset: %"PRIu64"",
     117             :                    gptr.addr_or_offs.offset);
     118           0 :                 return DART_ERR_INVAL;
     119             :         }
     120             :         DART_LOG_DEBUG("dart_memfree: local free, gptr.unitid:%2d offset:%"PRIu64"",
     121             :                  gptr.unitid, gptr.addr_or_offs.offset);
     122          24 :         return DART_OK;
     123             : }
     124             : 
     125             : dart_ret_t
     126         636 : dart_team_memalloc_aligned(
     127             :   dart_team_t   teamid,
     128             :   size_t        nbytes,
     129             :   dart_gptr_t * gptr)
     130             : {
     131             :         size_t team_size;
     132             :         dart_unit_t unitid;
     133         636 :   dart_unit_t gptr_unitid = -1;
     134         636 :         dart_team_myid(teamid, &unitid);
     135         636 :         dart_team_size(teamid, &team_size);
     136             : 
     137             :         char * sub_mem;
     138             : 
     139             :         /* The units belonging to the specified team are eligible to participate
     140             :          * below codes enclosed.
     141             :    */
     142             : 
     143             :         MPI_Win    win;
     144             :         MPI_Comm   comm;
     145             :         MPI_Aint   disp;
     146         636 :         MPI_Aint * disp_set = (MPI_Aint*)(malloc(team_size * sizeof (MPI_Aint)));
     147             : 
     148             :         uint16_t index;
     149         636 :         int result = dart_adapt_teamlist_convert(teamid, &index);
     150             :   DART_LOG_DEBUG(
     151             :     "dart_team_memalloc_aligned: dart_adapt_teamlist_convert completed, "
     152             :     "index:%d", index);
     153             : 
     154         636 :         if (result == -1) {
     155           0 :                 return DART_ERR_INVAL;
     156             :         }
     157         636 :         comm = dart_teams[index];
     158             : #if !defined(DART_MPI_DISABLE_SHARED_WINDOWS)
     159             :         MPI_Win  sharedmem_win;
     160             :         MPI_Comm sharedmem_comm;
     161         636 :         sharedmem_comm = dart_sharedmem_comm_list[index];
     162             : #endif
     163         636 :         dart_unit_t localid = 0;
     164         636 :         if (index == 0) {
     165         636 :                 gptr_unitid = localid;
     166             :         } else {
     167             :                 MPI_Group group;
     168             :                 MPI_Group group_all;
     169           0 :                 MPI_Comm_group(comm, &group);
     170           0 :                 MPI_Comm_group(MPI_COMM_WORLD, &group_all);
     171           0 :                 MPI_Group_translate_ranks(group, 1, &localid, group_all, &gptr_unitid);
     172             :         }
     173             : #if !defined(DART_MPI_DISABLE_SHARED_WINDOWS)
     174             :         MPI_Info win_info;
     175         636 :         MPI_Info_create(&win_info);
     176         636 :         MPI_Info_set(win_info, "alloc_shared_noncontig", "true");
     177             : 
     178             :         /* Allocate shared memory on sharedmem_comm, and create the related
     179             :    * sharedmem_win */
     180             : 
     181             :   /* NOTE:
     182             :    * Windows should definitely be optimized for the concrete value type i.e.
     183             :    * via MPI_Type_create_index_block as this greatly improves performance of
     184             :    * MPI_Get, MPI_Put and other RMA friends.
     185             :    *
     186             :    * !!! BUG IN INTEL-MPI 5.0
     187             :    * !!!
     188             :    * !!! See:
     189             :    * !!! https://software.intel.com/de-de/forums/intel-clusters-and-hpc-technology/topic/519995
     190             :    * !!!
     191             :    * !!! Quote:
     192             :    * !!!  "[When allocating, e.g., an] integer*4-array of array dimension N,
     193             :    * !!!   then use it by the MPI-processes (on the same node), and then
     194             :    * !!!   repeats the same for the next shared allocation [...] the number of
     195             :    * !!!   shared windows do accumulate in the run, because I do not free the
     196             :    * !!!   shared windows allocated so far. This allocation of shared windows
     197             :    * !!!   works, but only until the total number of allocated memory exceeds
     198             :    * !!!   a limit of ~30 millions of Integer*4 numbers (~120 MB).
     199             :    * !!!   When that limit is reached, the next call of
     200             :    * !!!   MPI_WIN_ALLOCATE_SHARED, MPI_WIN_SHARED_QUERY to allocated one
     201             :    * !!!   more shared window do not give an error message, but the 1st
     202             :    * !!!   attempt to use that allocated shared array results in a bus error
     203             :    * !!!   (because the shared array has not been allocated correctly)."
     204             :    * !!!
     205             :    * !!! Reproduced on SuperMUC and mpich3.1 on projekt03.
     206             :    *
     207             :    * Related support ticket of MPICH:
     208             :    * http://trac.mpich.org/projects/mpich/ticket/2178
     209             :    */
     210             :   DART_LOG_DEBUG("dart_team_memalloc_aligned: "
     211             :                  "MPI_Win_allocate_shared(nbytes:%ld)", nbytes);
     212         636 :         if (sharedmem_comm != MPI_COMM_NULL) {
     213         636 :     int ret = MPI_Win_allocate_shared(
     214             :                 nbytes,
     215             :                 sizeof(char),
     216             :                 win_info,
     217             :                 sharedmem_comm,
     218             :                 &sub_mem,
     219             :                 &sharedmem_win);
     220         636 :     if (ret != MPI_SUCCESS) {
     221           0 :       DART_LOG_ERROR("dart_team_memalloc_aligned: "
     222             :                      "MPI_Win_allocate_shared failed, error %d (%s)",
     223             :                      ret, DART__MPI__ERROR_STR(ret));
     224           0 :       return DART_ERR_OTHER;
     225             :     }
     226             :   } else {
     227           0 :     DART_LOG_ERROR("dart_team_memalloc_aligned: "
     228             :                    "Shared memory communicator is MPI_COMM_NULL, "
     229             :                    "cannot call MPI_Win_allocate_shared");
     230           0 :     return DART_ERR_OTHER;
     231             :   }
     232             : 
     233             :         int         sharedmem_unitid;
     234             :         MPI_Aint    winseg_size;
     235             :         char     ** baseptr_set;
     236             :         char      * baseptr;
     237             :         int         disp_unit, i;
     238         636 :         MPI_Comm_rank (sharedmem_comm, &sharedmem_unitid);
     239         636 :         baseptr_set = (char**)malloc(sizeof(char*) * dart_sharedmemnode_size[index]);
     240             : 
     241        3180 :         for (i = 0; i < dart_sharedmemnode_size[index]; i++) {
     242        2544 :                 if (sharedmem_unitid != i) {
     243        1908 :                         MPI_Win_shared_query(sharedmem_win, i,
     244             :                            &winseg_size, &disp_unit, &baseptr);
     245        1908 :                         baseptr_set[i] = baseptr;
     246             :                 } else {
     247         636 :       baseptr_set[i] = sub_mem;
     248             :     }
     249             :         }
     250             : #else
     251             :         if (MPI_Alloc_mem(nbytes, MPI_INFO_NULL, &sub_mem) != MPI_SUCCESS) {
     252             :     DART_LOG_ERROR(
     253             :       "dart_team_memalloc_aligned: bytes:%lu MPI_Alloc_mem failed", nbytes);
     254             :     return DART_ERR_OTHER;
     255             :   }
     256             : #endif
     257             : 
     258         636 :         win = dart_win_lists[index];
     259             :         /* Attach the allocated shared memory to win */
     260         636 :         if (MPI_Win_attach(win, sub_mem, nbytes) != MPI_SUCCESS) {
     261           0 :     DART_LOG_ERROR(
     262             :       "dart_team_memalloc_aligned: bytes:%lu MPI_Win_attach failed", nbytes);
     263           0 :     return DART_ERR_OTHER;
     264             :   }
     265         636 :         if (MPI_Get_address(sub_mem, &disp) != MPI_SUCCESS) {
     266           0 :     DART_LOG_ERROR(
     267             :       "dart_team_memalloc_aligned: bytes:%lu MPI_Get_address failed", nbytes);
     268           0 :     return DART_ERR_OTHER;
     269             :   }
     270             : 
     271             :         /* Collect the disp information from all the ranks in comm */
     272         636 :         MPI_Allgather(&disp, 1, MPI_AINT, disp_set, 1, MPI_AINT, comm);
     273             : 
     274             :         /* -- Updating infos on gptr -- */
     275         636 :         gptr->unitid = gptr_unitid;
     276             :   /* Segid equals to dart_memid (always a positive integer), identifies an
     277             :    * unique collective global memory. */
     278         636 :         gptr->segid  = dart_memid;
     279             :   /* For collective allocation, the flag is marked as 'index' */
     280         636 :         gptr->flags  = index;
     281         636 :         gptr->addr_or_offs.offset = 0;
     282             : 
     283             :         /* Updating the translation table of teamid with the created
     284             :    * (offset, win) infos */
     285             :         info_t item;
     286         636 :         item.seg_id  = dart_memid;
     287         636 :         item.size    = nbytes;
     288         636 :         item.disp    = disp_set;
     289             : #if !defined(DART_MPI_DISABLE_SHARED_WINDOWS)
     290         636 :         item.win     = sharedmem_win;
     291         636 :         item.baseptr = baseptr_set;
     292             : #else
     293             :         item.win     = MPI_WIN_NULL;
     294             :         item.baseptr = NULL;
     295             : #endif
     296         636 :         item.selfbaseptr = sub_mem;
     297             :         /* Add this newly generated correspondence relationship record into the
     298             :    * translation table. */
     299         636 :         dart_adapt_transtable_add(item);
     300             : #if !defined(DART_MPI_DISABLE_SHARED_WINDOWS)
     301         636 :         MPI_Info_free(&win_info);
     302             : #endif
     303         636 :         dart_memid++;
     304             : 
     305             :   DART_LOG_DEBUG(
     306             :     "dart_team_memalloc_aligned: bytes:%lu offset:%d gptr_unitid:%d "
     307             :     "across team %d",
     308             :                 nbytes, 0, gptr_unitid, teamid);
     309             : 
     310         636 :         return DART_OK;
     311             : }
     312             : 
     313         632 : dart_ret_t dart_team_memfree(
     314             :   dart_team_t teamid,
     315             :   dart_gptr_t gptr)
     316             : {
     317             :         dart_unit_t unitid;
     318         632 :         uint16_t    index  = gptr.flags;
     319         632 :   int16_t     seg_id = gptr.segid;
     320             :         char *      sub_mem;
     321             :         MPI_Win     win;
     322             : 
     323         632 :   dart_team_myid(teamid, &unitid);
     324             : 
     325         632 :         win = dart_win_lists[index];
     326             : 
     327         632 :   if (dart_adapt_transtable_get_selfbaseptr(seg_id, &sub_mem) == -1) {
     328           0 :           return DART_ERR_INVAL;
     329             :   }
     330             : 
     331             :   /* Detach the window associated with sub-memory to be freed:
     332             :    */
     333         632 :         MPI_Win_detach(win, sub_mem);
     334             : 
     335             :         /* Free the window's associated sub-memory:
     336             :    */
     337             : #if !defined(DART_MPI_DISABLE_SHARED_WINDOWS)
     338             :         MPI_Win sharedmem_win;
     339         632 :         if (dart_adapt_transtable_get_win(seg_id, &sharedmem_win) == -1) {
     340           0 :                 return DART_ERR_OTHER;
     341             :   }
     342         632 :         if (MPI_Win_free(&sharedmem_win) != MPI_SUCCESS) {
     343           0 :     DART_LOG_ERROR("dart_team_memfree: MPI_Win_free failed");
     344           0 :     return DART_ERR_OTHER;
     345             :   }
     346             : #else
     347             :         if (MPI_Free_mem(sub_mem) != MPI_SUCCESS) {
     348             :     DART_LOG_ERROR("dart_team_memfree: MPI_Free_mem failed");
     349             :     return DART_ERR_OTHER;
     350             :   }
     351             : #endif
     352             :   DART_LOG_DEBUG("dart_team_memfree: collective free, team unit id: %2d "
     353             :                  "offset:%"PRIu64" gptr_unitid:%d across team %d",
     354             :                  unitid, gptr.addr_or_offs.offset, gptr.unitid, teamid);
     355             :         /* Remove the related correspondence relation record from the related
     356             :    * translation table. */
     357         632 :         if (dart_adapt_transtable_remove(seg_id) == -1) {
     358           0 :                 return DART_ERR_INVAL;
     359             :         }
     360         632 :         return DART_OK;
     361             : }
     362             : 
     363             : dart_ret_t
     364           0 : dart_team_memregister_aligned(
     365             :    dart_team_t   teamid,
     366             :    size_t        nbytes,
     367             :    void        * addr,
     368             :    dart_gptr_t * gptr)
     369             : {
     370             :         size_t size;
     371             :         dart_unit_t unitid;
     372           0 :   dart_unit_t gptr_unitid = -1;
     373           0 :         dart_team_myid(teamid, &unitid);
     374           0 :         dart_team_size(teamid, &size);
     375             : 
     376             :         MPI_Win    win;
     377             :         MPI_Comm   comm;
     378             :         MPI_Aint   disp;
     379           0 :         MPI_Aint * disp_set = (MPI_Aint*)malloc(size * sizeof (MPI_Aint));
     380             :         uint16_t   index;
     381           0 :         int        result   = dart_adapt_teamlist_convert(teamid, &index);
     382             : 
     383           0 :         if (result == -1) {
     384           0 :                 return DART_ERR_INVAL;
     385             :         }
     386           0 :         comm = dart_teams[index];
     387           0 :         dart_unit_t localid = 0;
     388           0 :         if (index == 0) {
     389           0 :                 gptr_unitid = localid;
     390             :         } else {
     391             :                 MPI_Group group;
     392             :                 MPI_Group group_all;
     393           0 :                 MPI_Comm_group(comm, &group);
     394           0 :                 MPI_Comm_group(MPI_COMM_WORLD, &group_all);
     395           0 :                 MPI_Group_translate_ranks(group, 1, &localid,
     396             :                                 group_all, &gptr_unitid);
     397             :         }
     398           0 :         win = dart_win_lists[index];
     399           0 :         MPI_Win_attach(win, (char*)addr, nbytes);
     400           0 :         MPI_Get_address((char*)addr, &disp);
     401           0 :         MPI_Allgather(&disp, 1, MPI_AINT, disp_set, 1, MPI_AINT, comm);
     402           0 :         gptr->unitid              = gptr_unitid;
     403           0 :         gptr->segid               = dart_registermemid;
     404           0 :         gptr->flags               = index;
     405           0 :         gptr->addr_or_offs.offset = 0;
     406             :         info_t item;
     407           0 :         item.seg_id               = dart_registermemid;
     408           0 :         item.size                 = nbytes;
     409           0 :         item.disp                 = disp_set;
     410           0 :         item.win                  = MPI_WIN_NULL;
     411           0 :         item.baseptr              = NULL;
     412           0 :         item.selfbaseptr          = (char*)addr;
     413           0 :         dart_adapt_transtable_add(item);
     414           0 :         dart_registermemid--;
     415             :         DART_LOG_DEBUG("dart_team_memregister_aligned: collective alloc, "
     416             :                  "unit:%2d, nbytes:%lu offset:%d gptr_unitid:%d "
     417             :                  "across team %d",
     418             :                  unitid, nbytes, 0, gptr_unitid, teamid);
     419           0 :         return DART_OK;
     420             : }
     421             : 
     422             : dart_ret_t
     423         208 : dart_team_memregister(
     424             :    dart_team_t   teamid,
     425             :    size_t        nbytes,
     426             :    void        * addr,
     427             :    dart_gptr_t * gptr)
     428             : {
     429             :         size_t size;
     430             :         dart_unit_t unitid;
     431         208 :   dart_unit_t gptr_unitid = -1;
     432         208 :         dart_team_myid(teamid, &unitid);
     433         208 :         dart_team_size(teamid, &size);
     434             : 
     435             :         MPI_Win    win;
     436             :         MPI_Comm   comm;
     437             :         MPI_Aint   disp;
     438         208 :         MPI_Aint * disp_set = (MPI_Aint*)malloc(size * sizeof (MPI_Aint));
     439             :         uint16_t   index;
     440         208 :         int        result   = dart_adapt_teamlist_convert(teamid, &index);
     441             :   int        nil;
     442             : 
     443         208 :   if (nbytes == 0) {
     444             :     // Attaching empty memory region, set sendbuf to valid dummy pointer:
     445          72 :     addr = (void*)(&nil);
     446             :   }
     447             : 
     448         208 :         if (result == -1) {
     449           0 :                 return DART_ERR_INVAL;
     450             :         }
     451         208 :         comm = dart_teams[index];
     452         208 :         dart_unit_t localid = 0;
     453         208 :         if (index == 0) {
     454         208 :                 gptr_unitid = localid;
     455             :         } else {
     456             :                 MPI_Group group;
     457             :                 MPI_Group group_all;
     458           0 :                 MPI_Comm_group(comm, &group);
     459           0 :                 MPI_Comm_group(MPI_COMM_WORLD, &group_all);
     460           0 :                 MPI_Group_translate_ranks(group, 1, &localid,
     461             :                                 group_all, &gptr_unitid);
     462             :         }
     463         208 :         win = dart_win_lists[index];
     464         208 :         MPI_Win_attach(win, (char*)addr, nbytes);
     465         208 :         MPI_Get_address((char*)addr, &disp);
     466         208 :         MPI_Allgather(&disp, 1, MPI_AINT, disp_set, 1, MPI_AINT, comm);
     467         208 :         gptr->unitid              = gptr_unitid;
     468         208 :         gptr->segid               = dart_registermemid;
     469         208 :         gptr->flags               = index;
     470         208 :         gptr->addr_or_offs.offset = 0;
     471             :         info_t item;
     472         208 :         item.seg_id               = dart_registermemid;
     473         208 :         item.size                 = nbytes;
     474         208 :         item.disp                 = disp_set;
     475         208 :         item.win                  = MPI_WIN_NULL;
     476         208 :         item.baseptr              = NULL;
     477         208 :         item.selfbaseptr          = (char*)addr;
     478         208 :         dart_adapt_transtable_add(item);
     479         208 :         dart_registermemid--;
     480             : 
     481             :         DART_LOG_DEBUG("dart_team_memregister: collective alloc, "
     482             :                  "unit:%2d, nbytes:%lu offset:%d gptr_unitid:%d "
     483             :                  "across team %d",
     484             :                  unitid, nbytes, 0, gptr_unitid, teamid);
     485         208 :   return DART_OK;
     486             : }
     487             : 
     488             : dart_ret_t
     489         208 : dart_team_memderegister(
     490             :    dart_team_t teamid,
     491             :    dart_gptr_t gptr)
     492             : {
     493             :         dart_unit_t unitid;
     494         208 :         uint16_t    index  = gptr.flags;
     495         208 :         int16_t     seg_id = gptr.segid;
     496             :         char *      sub_mem;
     497             : 
     498             :         MPI_Win win;
     499             : 
     500         208 :         dart_team_myid(teamid, &unitid);
     501             : 
     502         208 :         win = dart_win_lists[index];
     503             : 
     504         208 :         if (dart_adapt_transtable_get_selfbaseptr (seg_id, &sub_mem) == -1) {
     505           0 :                 return DART_ERR_INVAL;
     506             :   }
     507         208 :         MPI_Win_detach(win, sub_mem);
     508         208 :         if (dart_adapt_transtable_remove (seg_id) == -1){
     509           0 :                 return DART_ERR_INVAL;
     510             :         }
     511             :   DART_LOG_DEBUG("dart_team_memderegister: collective free, "
     512             :                  "team unit %2d offset:%"PRIu64" gptr_unitid:%d"
     513             :                  "across team %d",
     514             :                  unitid, gptr.addr_or_offs.offset, gptr.unitid, teamid);
     515         208 :         return DART_OK;
     516             : }
     517             : 
     518             : 

Generated by: LCOV version 1.12