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 transstart:
 156   trans = transStart();
 157   ptr = transRead(trans, (unsigned int) VAR(___this___));
 158   struct ___Thread___ *p = (struct ___Thread___ *) ptr;
 159 #ifdef THREADJOINDEBUG
 160   printf("Start join process for Oid = %x\n", (unsigned int) VAR(___this___));
 161 #endif
 162   if(p->___threadDone___ == 1) {
 163 #ifdef THREADJOINDEBUG
 164     printf("Thread oid = %x is done\n", (unsigned int) VAR(___this___));
 165 #endif
 166     transAbort(trans);
 167     return;
 168   } else {
 169
 170     version = (ptr-1)->version;
 171     if((oidarray = calloc(1, sizeof(unsigned int))) == NULL) {
 172       printf("Calloc error %s, %d\n", __FILE__, __LINE__);
 173       return;
 174     }
 175
 176     oidarray[0] = (unsigned int) VAR(___this___);
 177
 178     if((versionarray = calloc(1, sizeof(unsigned short))) == NULL) {
 179       printf("Calloc error %s, %d\n", __FILE__, __LINE__);
 180       free(oidarray);
 181       return;
 182     }
 183     versionarray[0] = version;
 184     /* Request Notification */
 185 #ifdef PRECISE_GC
 186     struct listitem *tmp=stopforgc((struct garbagelist *)___params___);
 187 #endif
 188     reqNotify(oidarray, versionarray, 1);
 189 #ifdef PRECISE_GC
 190     restartaftergc(tmp);
 191 #endif
 192     free(oidarray);
 193     free(versionarray);
 194     transAbort(trans);
 195     goto transstart;
 196   }
 197   return;
 198 }
 199 #endif
 200
 201 #ifdef THREADS
 202 void CALL01(___Thread______nativeJoin____, struct ___Thread___ * ___this___) {
 203   pthread_mutex_lock(&joinlock);
 204   while(!VAR(___this___)->___finished___)
 205     pthread_cond_wait(&joincond, &joinlock);
 206   pthread_mutex_unlock(&joinlock);
 207 }
 208
 209 void CALL01(___Thread______nativeCreate____, struct ___Thread___ * ___this___) {
 210   pthread_t thread;
 211   int retval;
 212   pthread_attr_t nattr;
 213
 214   pthread_mutex_lock(&gclistlock);
 215   threadcount++;
 216   pthread_mutex_unlock(&gclistlock);
 217   pthread_attr_init(&nattr);
 218   pthread_attr_setdetachstate(&nattr, PTHREAD_CREATE_DETACHED);
 219
 220   do {
 221     retval=pthread_create(&thread, &nattr, (void * (*)(void *)) &initthread, VAR(___this___));
 222     if (retval!=0)
 223       usleep(1);
 224   } while(retval!=0);
 225   /* This next statement will likely not work on many machines */
 226
 227   pthread_attr_destroy(&nattr);
 228 }
 229 #endif
 230
 231 #ifdef DSTM
 232 void CALL12(___Thread______start____I, int ___mid___, struct ___Thread___ * ___this___, int ___mid___) {
 233   startRemoteThread((unsigned int)VAR(___this___), ___mid___);
 234 }
 235 #endif
 236
 237 #ifdef DSTM
 238 void globalDestructor(void *value) {
 239   free(value);
 240   pthread_setspecific(oidval, NULL);
 241 }
 242
 243 void initDSMthread(int *ptr) {
 244   objheader_t *tmp;
 245   transrecord_t * trans;
 246   void *threadData;
 247   int oid=ptr[0];
 248   int type=ptr[1];
 249   free(ptr);
 250 #ifdef PRECISE_GC
 251   int p[]={1, 0 /* NULL */, oid};
 252   ((void(*) (void *))virtualtable[type*MAXCOUNT+RUNMETHOD])(p);
 253 #else
 254   ((void(*) (void *))virtualtable[type*MAXCOUNT+RUNMETHOD])(oid);
 255 #endif
 256   threadData = calloc(1, sizeof(unsigned int));
 257   *((unsigned int *) threadData) = oid;
 258   pthread_setspecific(oidval, threadData);
 259   pthread_mutex_lock(&gclistlock);
 260   threadcount--;
 261   pthread_cond_signal(&gccond);
 262   pthread_mutex_unlock(&gclistlock);
 263   /* Add transaction to check if thread finished for join operation */
 264   goto transstart;
 265 transstart:
 266   {
 267     transrecord_t * trans = transStart();
 268     tmp  = transRead(trans, (unsigned int) oid);
 269     ((struct ___Thread___ *)tmp)->___threadDone___ = 1;
 270     *((unsigned int *)&((struct ___Object___ *) tmp)->___localcopy___) |=DIRTY;
 271     if(transCommit(trans)!= 0) {
 272       goto transstart;
 273     }
 274   }
 275   pthread_exit(NULL);
 276 }
 277
 278 void startDSMthread(int oid, int objType) {
 279   pthread_t thread;
 280   int retval;
 281   pthread_attr_t nattr;
 282
 283   pthread_mutex_lock(&gclistlock);
 284   threadcount++;
 285   pthread_mutex_unlock(&gclistlock);
 286   pthread_attr_init(&nattr);
 287   pthread_attr_setdetachstate(&nattr, PTHREAD_CREATE_DETACHED);
 288   int * ptr=malloc(sizeof(int)*2);
 289   ptr[0]=oid;
 290   ptr[1]=objType;
 291   pthread_key_create(&oidval, globalDestructor);
 292   do {
 293     retval=pthread_create(&thread, &nattr, (void * (*)(void *)) &initDSMthread,  ptr);
 294     if (retval!=0)
 295       usleep(1);
 296   } while(retval!=0);
 297
 298   pthread_attr_destroy(&nattr);
 299 }
 300
 301 #endif