Robust/src/Runtime/bamboo/gcqueue.h

   1 #ifndef GCQUEUE_H
   2 #define GCQUEUE_H
   3
   4 #include "stdio.h"
   5
   6 #define NUMPTRS 120
   7
   8 struct pointerblock {
   9   unsigned int ptrs[NUMPTRS];
  10   struct pointerblock *next;
  11 };
  12
  13 #define NUMLOBJPTRS 20
  14
  15 struct lobjpointerblock {
  16   unsigned int lobjs[NUMLOBJPTRS];
  17   int lengths[NUMLOBJPTRS];
  18   int hosts[NUMLOBJPTRS];
  19   struct lobjpointerblock *next;
  20   struct lobjpointerblock *prev;
  21 };
  22
  23 extern struct pointerblock *gchead;
  24 extern int gcheadindex;
  25 extern struct pointerblock *gctail;
  26 extern int gctailindex;
  27 extern struct pointerblock *gctail2;
  28 extern int gctailindex2;
  29 extern struct pointerblock *gcspare;
  30
  31 extern struct lobjpointerblock *gclobjhead;
  32 extern int gclobjheadindex;
  33 extern struct lobjpointerblock *gclobjtail;
  34 extern int gclobjtailindex;
  35 extern struct lobjpointerblock *gclobjtail2;
  36 extern int gclobjtailindex2;
  37 extern struct lobjpointerblock *gclobjspare;
  38
  39 static void gc_queueinit() {
  40   // initialize queue
  41   if (gchead==NULL) {
  42     gcheadindex=gctailindex=gctailindex2 = 0;
  43     gchead=gctail=gctail2=RUNMALLOC(sizeof(struct pointerblock));
  44   } else {
  45     gctailindex=gctailindex2=gcheadindex=0;
  46     gctail=gctail2=gchead;
  47   }
  48   gchead->next=NULL;
  49   // initialize the large obj queues
  50   if (gclobjhead==NULL) {
  51     gclobjheadindex=0;
  52     gclobjtailindex=0;
  53     gclobjtailindex2=0;
  54     gclobjhead=gclobjtail=gclobjtail2=RUNMALLOC(sizeof(struct lobjpointerblock));
  55   } else {
  56     gclobjtailindex=gclobjtailindex2=gclobjheadindex=0;
  57     gclobjtail=gclobjtail2=gclobjhead;
  58   }
  59   gclobjhead->next=gclobjhead->prev=NULL;
  60 }
  61
  62 ////////////////////////////////////////////////////////////////////
  63 // functions that should be invoked with interrupts off
  64 ////////////////////////////////////////////////////////////////////
  65 static void gc_enqueue_I(unsigned int ptr) {
  66   if (gcheadindex==NUMPTRS) {
  67     struct pointerblock * tmp;
  68     if (gcspare!=NULL) {
  69       tmp=gcspare;
  70       gcspare=NULL;
  71       tmp->next = NULL;
  72     } else {
  73       tmp=RUNMALLOC_I(sizeof(struct pointerblock));
  74     }
  75     gchead->next=tmp;
  76     gchead=tmp;
  77     gcheadindex=0;
  78   }
  79   gchead->ptrs[gcheadindex++]=ptr;
  80 }
  81
  82 // dequeue and destroy the queue
  83 static unsigned int gc_dequeue_I() {
  84   if (gctailindex==NUMPTRS) {
  85     struct pointerblock *tmp=gctail;
  86     gctail=gctail->next;
  87     gctailindex=0;
  88     if (gcspare!=NULL) {
  89       RUNFREE_I(tmp);
  90     } else {
  91       gcspare=tmp;
  92       gcspare->next = NULL;
  93     }
  94   }
  95   return gctail->ptrs[gctailindex++];
  96 }
  97
  98 // dequeue and do not destroy the queue
  99 static unsigned int gc_dequeue2_I() {
 100   if (gctailindex2==NUMPTRS) {
 101     struct pointerblock *tmp=gctail2;
 102     gctail2=gctail2->next;
 103     gctailindex2=0;
 104   }
 105   return gctail2->ptrs[gctailindex2++];
 106 }
 107
 108 static int gc_moreItems_I() {
 109   return !((gchead==gctail)&&(gctailindex==gcheadindex));
 110 }
 111
 112 static int gc_moreItems2_I() {
 113   return !((gchead==gctail2)&&(gctailindex2==gcheadindex));
 114 }
 115
 116 // should be invoked with interruption closed
 117 // enqueue a large obj: start addr & length
 118 static void gc_lobjenqueue_I(unsigned int ptr,
 119                              unsigned int length,
 120                              unsigned int host) {
 121   if (gclobjheadindex==NUMLOBJPTRS) {
 122     struct lobjpointerblock * tmp;
 123     if (gclobjspare!=NULL) {
 124       tmp=gclobjspare;
 125       gclobjspare=NULL;
 126       tmp->next = NULL;
 127       tmp->prev = NULL;
 128     } else {
 129       tmp=RUNMALLOC_I(sizeof(struct lobjpointerblock));
 130     }
 131     gclobjhead->next=tmp;
 132     tmp->prev = gclobjhead;
 133     gclobjhead=tmp;
 134     gclobjheadindex=0;
 135   }
 136   gclobjhead->lobjs[gclobjheadindex]=ptr;
 137   gclobjhead->lengths[gclobjheadindex]=length;
 138   gclobjhead->hosts[gclobjheadindex++]=host;
 139 }
 140
 141 // dequeue and destroy the queue
 142 static unsigned int gc_lobjdequeue_I(unsigned int * length,
 143                                      unsigned int * host) {
 144   if (gclobjtailindex==NUMLOBJPTRS) {
 145     struct lobjpointerblock *tmp=gclobjtail;
 146     gclobjtail=gclobjtail->next;
 147     gclobjtailindex=0;
 148     gclobjtail->prev = NULL;
 149     if (gclobjspare!=NULL) {
 150       RUNFREE_I(tmp);
 151     } else {
 152       gclobjspare=tmp;
 153       tmp->next = NULL;
 154       tmp->prev = NULL;
 155     }
 156   }
 157   if(length != NULL) {
 158     *length = gclobjtail->lengths[gclobjtailindex];
 159   }
 160   if(host != NULL) {
 161     *host = (unsigned int)(gclobjtail->hosts[gclobjtailindex]);
 162   }
 163   return gclobjtail->lobjs[gclobjtailindex++];
 164 }
 165
 166 static int gc_lobjmoreItems_I() {
 167   return !((gclobjhead==gclobjtail)&&(gclobjtailindex==gclobjheadindex));
 168 }
 169
 170 // dequeue and don't destroy the queue
 171 static void gc_lobjdequeue2_I() {
 172   if (gclobjtailindex2==NUMLOBJPTRS) {
 173     gclobjtail2=gclobjtail2->next;
 174     gclobjtailindex2=1;
 175   } else {
 176     gclobjtailindex2++;
 177   }
 178 }
 179
 180 static int gc_lobjmoreItems2_I() {
 181   return !((gclobjhead==gclobjtail2)&&(gclobjtailindex2==gclobjheadindex));
 182 }
 183
 184 // 'reversly' dequeue and don't destroy the queue
 185 static void gc_lobjdequeue3_I() {
 186   if (gclobjtailindex2==0) {
 187     gclobjtail2=gclobjtail2->prev;
 188     gclobjtailindex2=NUMLOBJPTRS-1;
 189   } else {
 190     gclobjtailindex2--;
 191   }
 192 }
 193
 194 static int gc_lobjmoreItems3_I() {
 195   return !((gclobjtail==gclobjtail2)&&(gclobjtailindex2==gclobjtailindex));
 196 }
 197
 198 static void gc_lobjqueueinit4_I() {
 199   gclobjtail2 = gclobjtail;
 200   gclobjtailindex2 = gclobjtailindex;
 201 }
 202
 203 static unsigned int gc_lobjdequeue4_I(unsigned int * length,
 204                                       unsigned int * host) {
 205   if (gclobjtailindex2==NUMLOBJPTRS) {
 206     gclobjtail2=gclobjtail2->next;
 207     gclobjtailindex2=0;
 208   }
 209   if(length != NULL) {
 210     *length = gclobjtail2->lengths[gclobjtailindex2];
 211   }
 212   if(host != NULL) {
 213     *host = (unsigned int)(gclobjtail2->hosts[gclobjtailindex2]);
 214   }
 215   return gclobjtail2->lobjs[gclobjtailindex2++];
 216 }
 217
 218 static int gc_lobjmoreItems4_I() {
 219   return !((gclobjhead==gclobjtail2)&&(gclobjtailindex2==gclobjheadindex));
 220 }
 221
 222 ////////////////////////////////////////////////////////////////////
 223 // functions that can be invoked in normal places
 224 ////////////////////////////////////////////////////////////////////
 225 static void gc_enqueue(unsigned int ptr) {
 226   BAMBOO_ENTER_RUNTIME_MODE_FROM_CLIENT();
 227   if (gcheadindex==NUMPTRS) {
 228     struct pointerblock * tmp;
 229     if (gcspare!=NULL) {
 230       tmp=gcspare;
 231       gcspare=NULL;
 232       tmp->next = NULL;
 233     } else {
 234       tmp=RUNMALLOC_I(sizeof(struct pointerblock));
 235     }
 236     gchead->next=tmp;
 237     gchead=tmp;
 238     gcheadindex=0;
 239   }
 240   gchead->ptrs[gcheadindex++]=ptr;
 241   BAMBOO_ENTER_CLIENT_MODE_FROM_RUNTIME();
 242 }
 243
 244 static unsigned int gc_dequeue() {
 245   BAMBOO_ENTER_RUNTIME_MODE_FROM_CLIENT();
 246   if (gctailindex==NUMPTRS) {
 247     struct pointerblock *tmp=gctail;
 248     gctail=gctail->next;
 249     gctailindex=0;
 250     if (gcspare!=NULL) {
 251       RUNFREE_I(tmp);
 252     } else {
 253       gcspare=tmp;
 254       gcspare->next = NULL;
 255     }
 256   }
 257   unsigned int r = gctail->ptrs[gctailindex++];
 258   BAMBOO_ENTER_CLIENT_MODE_FROM_RUNTIME();
 259   return r;
 260 }
 261
 262 static int gc_moreItems() {
 263   BAMBOO_ENTER_RUNTIME_MODE_FROM_CLIENT();
 264   int r = !((gchead==gctail)&&(gctailindex==gcheadindex));
 265   BAMBOO_ENTER_CLIENT_MODE_FROM_RUNTIME();
 266   return r;
 267 }
 268
 269 // dequeue and do not destroy the queue
 270 static unsigned int gc_dequeue2() {
 271   BAMBOO_ENTER_RUNTIME_MODE_FROM_CLIENT();
 272   if (gctailindex2==NUMPTRS) {
 273     struct pointerblock *tmp=gctail2;
 274     gctail2=gctail2->next;
 275     gctailindex2=0;
 276   }
 277   unsigned int r = gctail2->ptrs[gctailindex2++];
 278   BAMBOO_ENTER_CLIENT_MODE_FROM_RUNTIME();
 279   return r;
 280 }
 281
 282 static int gc_moreItems2() {
 283   BAMBOO_ENTER_RUNTIME_MODE_FROM_CLIENT();
 284   int r = !((gchead==gctail2)&&(gctailindex2==gcheadindex));
 285   BAMBOO_ENTER_CLIENT_MODE_FROM_RUNTIME();
 286   return r;
 287 }
 288
 289 static void gc_lobjenqueue(unsigned int ptr,
 290                            unsigned int length,
 291                            unsigned int host) {
 292   BAMBOO_ENTER_RUNTIME_MODE_FROM_CLIENT();
 293   if (gclobjheadindex==NUMLOBJPTRS) {
 294     struct lobjpointerblock * tmp;
 295     if (gclobjspare!=NULL) {
 296       tmp=gclobjspare;
 297       gclobjspare=NULL;
 298       tmp->next = NULL;
 299       tmp->prev = NULL;
 300     } else {
 301       tmp=RUNMALLOC_I(sizeof(struct lobjpointerblock));
 302     }
 303     gclobjhead->next=tmp;
 304     tmp->prev = gclobjhead;
 305     gclobjhead=tmp;
 306     gclobjheadindex=0;
 307   }
 308   gclobjhead->lobjs[gclobjheadindex]=ptr;
 309   gclobjhead->lengths[gclobjheadindex]=length;
 310   gclobjhead->hosts[gclobjheadindex++]=host;
 311   BAMBOO_ENTER_CLIENT_MODE_FROM_RUNTIME();
 312 }
 313 #endif