Robust/src/Runtime/mem.c

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