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