LCOV - code coverage report
Current view: top level - home/fuchsto/workspaces/dash-development/dart-impl/mpi/src - dart_translation.c (source / functions) Hit Total Coverage
Test: coverage.info.cleaned Lines: 79 98 80.6 %
Date: 2016-06-29 12:30:40 Functions: 8 9 88.9 %

          Line data    Source code
       1             : /**
       2             :  *  \file dart_translation.c
       3             :  *
       4             :  *  Implementation for the operations on translation table.
       5             :  */
       6             : 
       7             : #include <dash/dart/base/logging.h>
       8             : #include <dash/dart/mpi/dart_translation.h>
       9             : #include <dash/dart/mpi/dart_mem.h>
      10             : 
      11             : /* Global array: the header for the global translation table. */
      12             : node_t dart_transtable_globalalloc;
      13             : 
      14             : MPI_Win dart_win_local_alloc;
      15             : #if !defined(DART_MPI_DISABLE_SHARED_WINDOWS)
      16             : MPI_Win dart_sharedmem_win_local_alloc;
      17             : #endif
      18             : 
      19           4 : int dart_adapt_transtable_create ()
      20             : {
      21           4 :   dart_transtable_globalalloc = NULL;
      22           4 :   return 0;
      23             : }
      24             : 
      25         844 : int dart_adapt_transtable_add(info_t item)
      26             : {
      27             :   node_t pre, q;
      28         844 :   node_t p = (node_t) malloc(sizeof(node_info_t));
      29             :   DART_LOG_TRACE(
      30             :       "dart_adapt_transtable_add() item: "
      31             :       "seg_id:%d size:%zu disp:%"PRIu64" win:%"PRIu64"",
      32             :       item.seg_id, item.size, (uint64_t)item.disp, (uint64_t)item.win);
      33         844 :   p -> trans.seg_id  = item.seg_id;
      34         844 :   p -> trans.size    = item.size;
      35         844 :   p -> trans.disp    = item.disp;
      36             : #if !defined(DART_MPI_DISABLE_SHARED_WINDOWS)
      37         844 :   p -> trans.win     = item.win;
      38         844 :   p -> trans.baseptr = item.baseptr;
      39             : #endif
      40         844 :   p -> trans.selfbaseptr = item.selfbaseptr;
      41         844 :   p -> next = NULL;
      42             : 
      43             :   /* The translation table is empty. */
      44         844 :   if (dart_transtable_globalalloc == NULL) {
      45          32 :     dart_transtable_globalalloc = p;
      46             :   }
      47             : 
      48             :   /* Otherwise, insert the added item into the translation table. */
      49             :   else {
      50         812 :     q = dart_transtable_globalalloc;
      51        3707 :     while (q != NULL) {
      52        2083 :       pre = q;
      53        2083 :       q = q -> next;
      54             :     }
      55         812 :     pre -> next = p;
      56             :   }
      57         844 :   return 0;
      58             : }
      59             : 
      60         840 : int dart_adapt_transtable_remove(int16_t seg_id)
      61             : {
      62             :   node_t pre, p;
      63         840 :   p = dart_transtable_globalalloc;
      64         840 :   if (seg_id == (p -> trans.seg_id)) {
      65          28 :     dart_transtable_globalalloc = p -> next;
      66             :   } else {
      67        3221 :     while ((p != NULL ) && (seg_id != (p->trans.seg_id))) {
      68        1597 :       pre = p;
      69        1597 :       p   = p->next;
      70             :     }
      71         812 :     if (!p) {
      72           0 :       DART_LOG_ERROR(
      73             :         "Invalid seg_id:%d, can't remove the record from translation table",
      74             :         seg_id);
      75           0 :       return -1;
      76             :     }
      77         812 :     pre->next = p->next;
      78             :   }
      79             : 
      80         840 :   free(p->trans.disp);
      81             : #if !defined(DART_MPI_DISABLE_SHARED_WINDOWS)
      82         840 :   if (p->trans.baseptr) {
      83         632 :     free(p->trans.baseptr);
      84             :   }
      85             : #endif
      86         840 :   free(p);
      87         840 :   return 0;
      88             : }
      89             : 
      90             : #if !defined(DART_MPI_DISABLE_SHARED_WINDOWS)
      91         632 : int dart_adapt_transtable_get_win (int16_t seg_id, MPI_Win * win)
      92             : {
      93             :   node_t p;
      94         632 :   p = dart_transtable_globalalloc;
      95             : 
      96        2124 :   while ((p != NULL) && (seg_id != ((p -> trans).seg_id))) {
      97         860 :     p = p -> next;
      98             :   }
      99         632 :   if (!p) {
     100             : 
     101           0 :     DART_LOG_ERROR(
     102             :       "Invalid seg_id:%d, cannot get related window object",
     103             :       seg_id);
     104           0 :     return -1;
     105             :   }
     106             : 
     107         632 :   *win = (p -> trans).win;
     108         632 :   return 0;
     109             : }
     110             : #endif
     111             : 
     112             : /*
     113             : int dart_adapt_transtable_get_addr (uin16_t index, int offset, int* base, void **addr)
     114             : {
     115             :         node_t p, pre;
     116             :         p = transtable_globalalloc [index];
     117             : 
     118             :         while ((p != NULL) && (offset >= (p -> trans.offset)))
     119             :         {
     120             :                 pre = p;
     121             :                 p = p -> next;
     122             :         }
     123             : 
     124             :         if (pre -> trans.offset + pre -> trans.size <= offset)
     125             :         {
     126             :                 return -1;
     127             :         }
     128             : 
     129             : 
     130             :         *base = (pre -> trans).offset;
     131             :         *addr = (pre -> trans).addr;
     132             :         return 0;
     133             : }
     134             : */
     135             : 
     136        4659 : int dart_adapt_transtable_get_disp(int16_t seg_id,
     137             :                                    int rel_unitid,
     138             :                                    MPI_Aint * disp_s)
     139             : {
     140        4659 :   MPI_Aint trans_disp = 0;
     141        4659 :   node_t p = dart_transtable_globalalloc;
     142        4659 :   *disp_s  = 0;
     143             : 
     144             :   DART_LOG_TRACE("dart_adapt_transtable_get_disp() "
     145             :                  "seq_id:%d rel_unitid:%d", seg_id, rel_unitid);
     146       31438 :   while (p != NULL) {
     147       26779 :     int16_t trans_seg_id = (p->trans).seg_id;
     148             :     DART_LOG_TRACE("dart_adapt_transtable_get_disp: p.trans.seq_id:%d",
     149             :                    trans_seg_id);
     150       26779 :     if (seg_id == trans_seg_id) {
     151        4659 :       break;
     152             :     }
     153       22120 :     p = p->next;
     154             :   }
     155        4659 :   if (p == NULL) {
     156           0 :     DART_LOG_ERROR(
     157             :       "Invalid seg_id: %d, can not get the related displacement", seg_id);
     158           0 :     return -1;
     159             :   }
     160        4659 :   trans_disp = (p->trans).disp[rel_unitid];
     161        4659 :   *disp_s    = trans_disp;
     162             :   DART_LOG_TRACE("dart_adapt_transtable_get_disp > dist:%"PRIu64"",
     163             :                  (uint64_t)trans_disp);
     164        4659 :   return 0;
     165             : }
     166             : 
     167             : #if !defined(DART_MPI_DISABLE_SHARED_WINDOWS)
     168    12789800 : int dart_adapt_transtable_get_baseptr(
     169             :   int16_t    seg_id,
     170             :   int        rel_unitid,
     171             :   char   **  baseptr_s)
     172             : {
     173             :   node_t p;
     174    12789800 :   p = dart_transtable_globalalloc;
     175             : 
     176    38426036 :   while ((p != NULL) && (seg_id != ((p -> trans).seg_id))) {
     177    12846436 :     p = p -> next;
     178             :   }
     179    12789800 :   if (!p) {
     180           0 :     DART_LOG_ERROR("Invalid seg_id: %d, can not get the related baseptr",
     181             :                    seg_id);
     182           0 :     return -1;
     183             :   }
     184             : 
     185    12789800 :   *baseptr_s = (p -> trans).baseptr[rel_unitid];
     186    12789800 :   return 0;
     187             : }
     188             : #endif
     189             : 
     190        3202 : int dart_adapt_transtable_get_selfbaseptr(
     191             :   int16_t    seg_id,
     192             :   char   **  baseptr)
     193             : {
     194             :   node_t p;
     195        3202 :   p = dart_transtable_globalalloc;
     196             : 
     197       11095 :   while ((p != NULL) && (seg_id != ((p -> trans).seg_id))) {
     198        4691 :     p = p -> next;
     199             :   }
     200        3202 :   if (!p) {
     201           0 :     DART_LOG_ERROR ("Invalid seg_id: %d, can not get the related baseptr",
     202             :                     seg_id);
     203           0 :     return -1;
     204             :   }
     205        3202 :   *baseptr = (p -> trans).selfbaseptr;
     206        3202 :   return 0;
     207             : }
     208             : 
     209           0 : int dart_adapt_transtable_get_size(
     210             :   int16_t   seg_id,
     211             :   size_t  * size)
     212             : {
     213             :   node_t p;
     214           0 :   p = dart_transtable_globalalloc;
     215             : 
     216           0 :   while ((p != NULL) && (seg_id != ((p -> trans).seg_id))) {
     217           0 :     p = p -> next;
     218             :   }
     219             : 
     220           0 :   if (!p) {
     221           0 :     DART_LOG_ERROR("Invalid seg_id: %d, can not get the related memory size",
     222             :                    seg_id);
     223           0 :     return -1;
     224             :   }
     225           0 :   *size = (p -> trans).size;
     226           0 :   return 0;
     227             : }
     228             : 
     229           4 : int dart_adapt_transtable_destroy ()
     230             : {
     231             :   node_t p, pre;
     232           4 :   p = dart_transtable_globalalloc;
     233             :   if (p != NULL) {
     234             :     DART_LOG_DEBUG("Free up the translation table forcibly as there are "
     235             :                    "still global memory blocks functioning on this team");
     236             :   }
     237          12 :   while (p != NULL) {
     238           4 :     pre = p;
     239           4 :     p = p -> next;
     240             : 
     241           4 :     free (pre->trans.disp);
     242             : #if !defined(DART_MPI_DISABLE_SHARED_WINDOWS)
     243           4 :     if (pre->trans.baseptr) {
     244           4 :       free (pre->trans.baseptr);
     245             :     }
     246             : #endif
     247           4 :     free (pre);
     248             :   }
     249           4 :   dart_transtable_globalalloc = NULL;
     250           4 :   return 0;
     251             : }

Generated by: LCOV version 1.12