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 & (~(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(0xc001);
  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 & (~(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(0xc002);
  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(0xc003);
  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("macalloc_i %s %d \n", file, line);
 118         BAMBOO_EXIT(0xc004);
 119   }
 120   return p;
 121 }
 122
 123 void myfree(void * ptr) {
 124 #ifdef MULTICORE_GC
 125   if(ptr >= BAMBOO_LOCAL_HEAP_START_VA ) {
 126 #endif
 127         BAMBOO_LOCAL_MEM_FREE(ptr);
 128 #ifdef MULTICORE_GC
 129   } else if(ptr >= BAMBOO_LOCAL_HEAP_START_VA_S) {
 130         BAMBOO_LOCAL_MEM_FREE_S(ptr);
 131   }
 132 #endif
 133   return;
 134 }
 135
 136 #endif