Robust/src/Runtime/thread.c

   1 #include "runtime.h"
   2 #include <sys/types.h>
   3 #include <unistd.h>
   4 #include <errno.h>
   5 #include <stdlib.h>
   6 #include "thread.h"
   7 #include "option.h"
   8 #include <signal.h>
   9 #include <DSTM/interface/dstm.h>
  10 #include <DSTM/interface/llookup.h>
  11
  12 #ifndef RAW
  13 #include <stdio.h>
  14 #endif
  15 int threadcount;
  16 pthread_mutex_t gclock;
  17 pthread_mutex_t gclistlock;
  18 pthread_cond_t gccond;
  19 pthread_mutex_t objlock;
  20 pthread_cond_t objcond;
  21
  22 pthread_mutex_t joinlock;
  23 pthread_cond_t joincond;
  24 pthread_key_t threadlocks;
  25 pthread_mutex_t threadnotifylock;
  26 pthread_cond_t threadnotifycond;
  27 pthread_key_t oidval;
  28
  29 void threadexit() {
  30   objheader_t* ptr;
  31   void *value;
  32   transrecord_t * trans;
  33   unsigned int oidvalue;
  34
  35 #ifdef THREADS
  36   struct ___Object___ *ll=pthread_getspecific(threadlocks);
  37   while(ll!=NULL) {
  38     struct ___Object___ *llnext=ll->___nextlockobject___;
  39     ll->___nextlockobject___=NULL;
  40     ll->___prevlockobject___=NULL;
  41     ll->lockcount=0;
  42     ll->tid=0; //unlock it
  43     ll=llnext;
  44   }
  45   pthread_mutex_lock(&objlock);//wake everyone up
  46   pthread_cond_broadcast(&objcond);
  47   pthread_mutex_unlock(&objlock);
  48 #endif
  49   pthread_mutex_lock(&gclistlock);
  50   threadcount--;
  51   pthread_cond_signal(&gccond);
  52   pthread_mutex_unlock(&gclistlock);
  53 #ifdef DSTM
  54   /* Add transaction to check if thread finished for join operation */
  55   value = pthread_getspecific(oidval);
  56   oidvalue = *((unsigned int *)value);
  57   goto transstart;
  58 transstart:
  59   {
  60     transrecord_t * trans = transStart();
  61     ptr = transRead(trans, oidvalue);
  62     struct ___Thread___ *p = (struct ___Thread___ *) ptr;
  63     p->___threadDone___ = 1;
  64     *((unsigned int *)&((struct ___Object___ *) p)->___localcopy___) |=DIRTY;
  65     if(transCommit(trans) != 0) {
  66       goto transstart;
  67     }
  68   }
  69 #endif
  70   pthread_exit(NULL);
  71 }
  72
  73 void threadhandler(int sig, siginfo_t *info, void *uap) {
  74 #ifdef DEBUG
  75   printf("sig=%d\n",sig);
  76   printf("signal\n");
  77 #endif
  78   threadexit();
  79 }
  80
  81 void initializethreads() {
  82   struct sigaction sig;
  83   threadcount=1;
  84   pthread_mutex_init(&gclock, NULL);
  85   pthread_mutex_init(&gclistlock, NULL);
  86   pthread_cond_init(&gccond, NULL);
  87   pthread_mutex_init(&objlock,NULL);
  88   pthread_cond_init(&objcond,NULL);
  89   pthread_mutex_init(&joinlock,NULL);
  90   pthread_cond_init(&joincond,NULL);
  91   pthread_key_create(&threadlocks, NULL);
  92   processOptions();
  93   initializeexithandler();
  94
  95   sig.sa_sigaction=&threadhandler;
  96   sig.sa_flags=SA_SIGINFO;
  97   sigemptyset(&sig.sa_mask);
  98
  99   /* Catch bus errors, segmentation faults, and floating point exceptions*/
 100   sigaction(SIGBUS,&sig,0);
 101   sigaction(SIGSEGV,&sig,0);
 102   sigaction(SIGFPE,&sig,0);
 103   signal(SIGPIPE, SIG_IGN);
 104 }
 105
 106 #ifdef THREADS
 107 void initthread(struct ___Thread___ * ___this___) {
 108 #ifdef PRECISE_GC
 109   int p[]={1, (int) NULL, (int) ___this___};
 110   ___Thread______staticStart____L___Thread___((struct ___Thread______staticStart____L___Thread____params *)p);
 111   ___this___=(struct ___Thread___ *) p[2];
 112 #else
 113   ___Thread______staticStart____L___Thread___(___this___);
 114 #endif
 115   ___this___->___finished___=1;
 116   pthread_mutex_lock(&joinlock);
 117   pthread_cond_signal(&joincond);
 118   pthread_mutex_unlock(&joinlock);
 119
 120   pthread_mutex_lock(&gclistlock);
 121   threadcount--;
 122   pthread_cond_signal(&gccond);
 123   pthread_mutex_unlock(&gclistlock);
 124 }
 125 #endif
 126
 127 void CALL11(___Thread______sleep____J, long long ___millis___, long long ___millis___) {
 128 #ifdef THREADS
 129 #ifdef PRECISE_GC
 130   struct listitem *tmp=stopforgc((struct garbagelist *)___params___);
 131 #endif
 132 #endif
 133   usleep(___millis___);
 134 #ifdef THREADS
 135 #ifdef PRECISE_GC
 136   restartaftergc(tmp);
 137 #endif
 138 #endif
 139 }
 140
 141 #if defined(DSTM)||defined(THREADS)
 142 void CALL00(___Thread______yield____) {
 143   pthread_yield();
 144 }
 145 #endif
 146
 147 #ifdef DSTM
 148 /* Add thread join capability */
 149 void CALL01(___Thread______join____, struct ___Thread___ * ___this___) {
 150   unsigned int *oidarray;
 151   unsigned short *versionarray, version;
 152   transrecord_t *trans;
 153   objheader_t *ptr;
 154   /* Add transaction to check if thread finished for join operation */
 155   goto transstart;
 156 transstart:
 157   trans = transStart();
 158   ptr = transRead(trans, (unsigned int) VAR(___this___));
 159   struct ___Thread___ *p = (struct ___Thread___ *) ptr;
 160   if(p->___threadDone___ == 1) {
 161           transAbort(trans);
 162           return;
 163   } else {
 164
 165           version = (ptr-1)->version;
 166           if((oidarray = calloc(1, sizeof(unsigned int))) == NULL) {
 167                   printf("Calloc error %s, %d\n", __FILE__, __LINE__);
 168                   return;
 169           }
 170
 171           oidarray[0] = (unsigned int) VAR(___this___);
 172
 173           if((versionarray = calloc(1, sizeof(unsigned short))) == NULL) {
 174                   printf("Calloc error %s, %d\n", __FILE__, __LINE__);
 175                   free(oidarray);
 176                   return;
 177           }
 178           versionarray[0] = version;
 179           /* Request Notification */
 180 #ifdef PRECISE_GC
 181           struct listitem *tmp=stopforgc((struct garbagelist *)___params___);
 182 #endif
 183           reqNotify(oidarray, versionarray, 1);
 184 #ifdef PRECISE_GC
 185           restartaftergc(tmp);
 186 #endif
 187           free(oidarray);
 188           free(versionarray);
 189           transAbort(trans);
 190           goto transstart;
 191   }
 192   return;
 193 }
 194 #endif
 195
 196 #ifdef THREADS
 197 void CALL01(___Thread______nativeJoin____, struct ___Thread___ * ___this___) {
 198   pthread_mutex_lock(&joinlock);
 199   while(!VAR(___this___)->___finished___)
 200     pthread_cond_wait(&joincond, &joinlock);
 201   pthread_mutex_unlock(&joinlock);
 202 }
 203
 204 void CALL01(___Thread______nativeCreate____, struct ___Thread___ * ___this___) {
 205   pthread_t thread;
 206   int retval;
 207   pthread_attr_t nattr;
 208
 209   pthread_mutex_lock(&gclistlock);
 210   threadcount++;
 211   pthread_mutex_unlock(&gclistlock);
 212   pthread_attr_init(&nattr);
 213   pthread_attr_setdetachstate(&nattr, PTHREAD_CREATE_DETACHED);
 214
 215   do {
 216     retval=pthread_create(&thread, &nattr, (void * (*)(void *)) &initthread, VAR(___this___));
 217     if (retval!=0)
 218       usleep(1);
 219   } while(retval!=0);
 220   /* This next statement will likely not work on many machines */
 221
 222   pthread_attr_destroy(&nattr);
 223 }
 224 #endif
 225
 226 #ifdef DSTM
 227 void CALL12(___Thread______start____I, int ___mid___, struct ___Thread___ * ___this___, int ___mid___) {
 228   startRemoteThread((unsigned int)VAR(___this___), ___mid___);
 229 }
 230 #endif
 231
 232 #ifdef DSTM
 233 void globalDestructor(void *value) {
 234         free(value);
 235         pthread_setspecific(oidval, NULL);
 236 }
 237
 238 void initDSMthread(int *ptr) {
 239   objheader_t *tmp;
 240   transrecord_t * trans;
 241   void *threadData;
 242   int oid=ptr[0];
 243   int type=ptr[1];
 244   free(ptr);
 245 #ifdef PRECISE_GC
 246   int p[]={1, 0 /* NULL */, oid};
 247   ((void (*)(void *))virtualtable[type*MAXCOUNT+RUNMETHOD])(p);
 248 #else
 249   ((void (*)(void *))virtualtable[type*MAXCOUNT+RUNMETHOD])(oid);
 250 #endif
 251   threadData = calloc(1, sizeof(unsigned int));
 252   *((unsigned int *) threadData) = oid;
 253   pthread_setspecific(oidval, threadData);
 254   pthread_mutex_lock(&gclistlock);
 255   threadcount--;
 256   pthread_cond_signal(&gccond);
 257   pthread_mutex_unlock(&gclistlock);
 258   /* Add transaction to check if thread finished for join operation */
 259   goto transstart;
 260 transstart:
 261   {
 262     transrecord_t * trans = transStart();
 263     tmp  = transRead(trans, (unsigned int) oid);
 264     ((struct ___Thread___ *)tmp)->___threadDone___ = 1;
 265     *((unsigned int *)&((struct ___Object___ *) tmp)->___localcopy___) |=DIRTY;
 266     if(transCommit(trans)!= 0) {
 267       goto transstart;
 268     }
 269   }
 270   pthread_exit(NULL);
 271 }
 272
 273 void startDSMthread(int oid, int objType) {
 274         pthread_t thread;
 275         int retval;
 276         pthread_attr_t nattr;
 277
 278         pthread_mutex_lock(&gclistlock);
 279         threadcount++;
 280         pthread_mutex_unlock(&gclistlock);
 281   pthread_attr_init(&nattr);
 282   pthread_attr_setdetachstate(&nattr, PTHREAD_CREATE_DETACHED);
 283   int * ptr=malloc(sizeof(int)*2);
 284   ptr[0]=oid;
 285   ptr[1]=objType;
 286   pthread_key_create(&oidval, globalDestructor);
 287   do {
 288     retval=pthread_create(&thread, &nattr, (void * (*)(void *)) &initDSMthread,  ptr);
 289     if (retval!=0)
 290       usleep(1);
 291   } while(retval!=0);
 292
 293   pthread_attr_destroy(&nattr);
 294 }
 295
 296 #endif