Robust/src/Runtime/mem.c

   1 #include "mem.h"
   2
   3 #ifdef MULTICORE
   4 #include "runtime.h"
   5 #include "runtime_arch.h"
   6
   7 void * mycalloc(int m,
   8                         int size) {
   9   void * p = NULL;
  10   int isize = size;
  11   BAMBOO_ENTER_RUNTIME_MODE_FROM_CLIENT();
  12 #ifdef MULTICORE_GC
  13   extern bool gc_localheap_s;
  14 inermycalloc_i:
  15   p = gc_localheap_s ? BAMBOO_LOCAL_MEM_CALLOC_S(m, isize) :
  16         BAMBOO_LOCAL_MEM_CALLOC(m, isize);
  17 #else
  18   p = BAMBOO_LOCAL_MEM_CALLOC(m, isize); // calloc(m, isize);
  19 #endif
  20   if(p == NULL) {
  21 #ifdef MULTICORE_GC
  22         if(!gc_localheap_s) {
  23           gc_localheap_s = true;
  24           goto inermycalloc_i;
  25         }
  26 #endif
  27           BAMBOO_EXIT(0xc001);
  28   }
  29   BAMBOO_ENTER_CLIENT_MODE_FROM_RUNTIME();
  30   return p;
  31 }
  32
  33 #ifdef MULTICORE_GC
  34 void * mycalloc_share(struct garbagelist * stackptr,
  35                               int m,
  36                                           int size) {
  37         void * p = NULL;
  38   //int isize = 2*BAMBOO_CACHE_LINE_SIZE-4+(size-1)&(~BAMBOO_CACHE_LINE_MASK);
  39   int isize = (size & (~(BAMBOO_CACHE_LINE_MASK))) + (BAMBOO_CACHE_LINE_SIZE);
  40         int hasgc = 0;
  41 memalloc:
  42   BAMBOO_ENTER_RUNTIME_MODE_FROM_CLIENT();
  43   p = BAMBOO_SHARE_MEM_CALLOC_I(m, isize); // calloc(m, isize);
  44   if(p == NULL) {
  45                 // no more global shared memory
  46                 BAMBOO_ENTER_CLIENT_MODE_FROM_RUNTIME();
  47                 if(hasgc < 5) {
  48                     // start gc
  49                         if(gc(stackptr)) {
  50                           hasgc++;
  51                         }
  52                 } else {
  53                         // no more global shared memory
  54                         BAMBOO_EXIT(0xc002);
  55                 }
  56
  57                 // try to malloc again
  58                 goto memalloc;
  59   }
  60   BAMBOO_ENTER_CLIENT_MODE_FROM_RUNTIME();
  61         void * alignedp =
  62                 (void *)(BAMBOO_CACHE_LINE_SIZE+((int)p-1)&(~BAMBOO_CACHE_LINE_MASK));
  63         BAMBOO_MEMSET_WH(p, -2, (alignedp - p));
  64   BAMBOO_MEMSET_WH(alignedp + size, -2, p + isize - alignedp - size);
  65         return alignedp;
  66 }
  67
  68 void * mycalloc_share_ngc(int m,
  69                                               int size) {
  70   void * p = NULL;
  71   BAMBOO_ENTER_RUNTIME_MODE_FROM_CLIENT();
  72   p = BAMBOO_SHARED_MEM_CALLOC_NGC_I(m, size); // calloc(m, isize);
  73   BAMBOO_ENTER_CLIENT_MODE_FROM_RUNTIME();
  74   return p;
  75 }
  76
  77 void * mycalloc_share_ngc_I(int m,
  78                                                 int size) {
  79   void * p = NULL;
  80   p = BAMBOO_SHARED_MEM_CALLOC_NGC_I(m, size); // calloc(m, isize);
  81   return p;
  82 }
  83
  84 void mycalloc_free_ngc(void * ptr) {
  85   BAMBOO_ENTER_RUNTIME_MODE_FROM_CLIENT();
  86   BAMBOO_SHARED_MEM_FREE_NGC_I(ptr);
  87   BAMBOO_ENTER_CLIENT_MODE_FROM_RUNTIME();
  88 }
  89
  90 void mycalloc_free_ngc_I(void * ptr) {
  91   BAMBOO_SHARED_MEM_FREE_NGC_I(ptr);
  92 }
  93 #else
  94 void * mycalloc_share(int m,
  95                                   int size) {
  96   void * p = NULL;
  97   //int isize = 2*BAMBOO_CACHE_LINE_SIZE-4+(size-1)&(~BAMBOO_CACHE_LINE_MASK);
  98   int isize = (size & (~(BAMBOO_CACHE_LINE_MASK))) + (BAMBOO_CACHE_LINE_SIZE);
  99   BAMBOO_ENTER_RUNTIME_MODE_FROM_CLIENT();
 100   p = BAMBOO_SHARE_MEM_CALLOC_I(m, isize); // calloc(m, isize);
 101   if(p == NULL) {
 102                 // no more global shared memory
 103                 BAMBOO_EXIT(0xc003);
 104   }
 105   BAMBOO_ENTER_CLIENT_MODE_FROM_RUNTIME();
 106   return
 107                 (void *)(BAMBOO_CACHE_LINE_SIZE+((int)p-1)&(~BAMBOO_CACHE_LINE_MASK));
 108 }
 109 #endif
 110
 111 void * mycalloc_i(int m,
 112                           int size) {
 113   void * p = NULL;
 114   int isize = size;
 115 #ifdef MULTICORE_GC
 116   extern bool gc_localheap_s;
 117 inermycalloc_i:
 118   p = gc_localheap_s ? BAMBOO_LOCAL_MEM_CALLOC_S(m, isize) :
 119         BAMBOO_LOCAL_MEM_CALLOC(m, isize);
 120 #else
 121   p = BAMBOO_LOCAL_MEM_CALLOC(m, isize); // calloc(m, isize);
 122 #endif
 123   if(p == NULL) {
 124 #ifdef MULTICORE_GC
 125         if(!gc_localheap_s) {
 126           gc_localheap_s = true;
 127           goto inermycalloc_i;
 128         }
 129 #endif
 130         BAMBOO_EXIT(0xc004);
 131   }
 132   return p;
 133 }
 134
 135 void myfree(void * ptr) {
 136 #ifdef MULTICORE_GC
 137   if(ptr >= BAMBOO_LOCAL_HEAP_START_VA ) {
 138 #endif
 139         BAMBOO_LOCAL_MEM_FREE(ptr);
 140 #ifdef MULTICORE_GC
 141   } else if(ptr >= BAMBOO_LOCAL_HEAP_START_VA_S) {
 142         BAMBOO_LOCAL_MEM_FREE_S(ptr);
 143   }
 144 #endif
 145   return;
 146 }
 147
 148 #endif