void *func4(void *arg) { gtthread_t *t3_self = (gtthread_t*) arg; gtthread_t gtt = gtthread_self(); int res = gtthread_equal(gtt, *t3_self); printf("Fourth test is not equal: %s\n", !res ? "correct" : "incorrect"); return NULL; }
int gtthread_join(gtthread_t thread, void **status){ int i = 0; steque_node_t* current; //TODO: No need to block and unblock signals? if (gtthread_equal(thread, gtthread_self())){ printf("cannot join same thread\n"); return -1; } //Searching for node with gtthread_t thread current = q->front; for (i = 0; (i < q->N); i++) { if(gtthread_equal(thread, ((node_t*)current -> item) -> id)) { break; } current = current -> next; } //Checking for canceled thread, blocking otherwise while (1){ if (((node_t*)current -> item) -> canceled == 1){ if(status != NULL){ *status = ((node_t*)current -> item) -> returns; } break; } gtthread_yield(); } return 0; }
int gtthread_create(gtthread_t *thread, void *(*start_routine)(void *), void *arg) { if (init != 1) { /*printf("Error - gtthread not initialized. \n");*/ exit(-1); } else { gtthread *newThread, *current; sigset_t oldset; /* Block alarms */ sigprocmask(SIG_BLOCK, &alrm, &oldset); /* sigprocmask(SIG_BLOCK, &alrm, NULL); */ /* do malloc for new thread and init its attributes */ if((newThread = malloc(sizeof(gtthread))) != NULL) { newThread -> id = thread_num++; newThread -> finished = 0; newThread -> cancel = 0; /* store thread id */ *thread = newThread -> id; /* get thread at front of currently running queue*/ current = (gtthread *) gtthread_self(); /* getcontext() */ if ( getcontext(&newThread -> uctx) == 0) { newThread -> uctx.uc_stack.ss_sp = (char*) malloc(SIGSTKSZ); newThread -> uctx.uc_stack.ss_size = SIGSTKSZ; /* set its successor context */ newThread -> uctx.uc_link = ¤t -> uctx; } /* init join queue for the new thread */ steque_init(&newThread -> joining); makecontext(&newThread -> uctx, (void (*)(void)) run_thread, 2, start_routine, arg); /* Add new thread to back of queue */ steque_enqueue(&globalQ, newThread); steque_enqueue(¤tly_running, newThread); sigprocmask(SIG_UNBLOCK, &alrm, NULL); } else { /*printf("Thread creation malloc failed. Exiting.\n");*/ sigprocmask(SIG_UNBLOCK, &alrm, NULL); return 1;/* ? */ } return 0; } }
void* thr2(void *in) { if(gtthread_equal(gtthread_self(), t1)) { printf("Failure.\n"); } else { printf("Success\n"); } return NULL; }
void* thr(void *in) { if(gtthread_equal(gtthread_self(), t)) { printf("Success"); } else { printf("Failure"); } return NULL; }
void* worker(void* arg) { gtthread_t tid = gtthread_self(); if(gtthread_equal(g_th2, tid)) printf("same\n"); else printf("diff\n"); }
void *func3(void *arg) { gtthread_t gtt = gtthread_self(); gtthread_yield(); // ensure that the global is set first gtthread_yield(); gtthread_yield(); int res = gtthread_equal(g_gtt, gtt); printf("Third test is equal: %s\n", res ? "correct" : "incorrect"); gtthread_t *ret = malloc(sizeof(gtt)); memcpy(ret, >t, sizeof(gtt)); return ret; }
void thread2fn() { if(gtthread_equal(*thread1, gtthread_self()) != 0) { fprintf(stderr, "\nSame"); } else { fprintf(stderr, "\nDiff"); } }
int main() { printf("test4b. Should print 'Success'.\n"); gtthread_init(50000L); gtthread_t t; gtthread_create( &t, thr, NULL); if(gtthread_equal(gtthread_self(), t)) { printf("Failure."); } else { printf("Success"); } return EXIT_SUCCESS; }
char* thr1(void *in) { int i; int j = 0; int *a = (int*)in; int k = 2000000; //for(i = 0; i<3; i++){ //printf("Exiting asd: %d\n", gtthread_equal(t2, gtthread_self())); //while(k--); //printf("Exiting Thread 1\n"); //fflush(stdout); //fflush(stdout); //gtthread_cancel(1); //} //gtthread_exit("Asd"); //for (i = 0; i< 20; i++){ //gtthread_mutex_lock(&g_mutex); //gtthread_mutex_unlock(&g_mutex); //while(1){ //if (gtthread_self()==1) //gtthread_create( &t2, thr2, NULL); for (i = 0 ; i <20; i++){ //gtthread_mutex_lock(&g_mutex); printf("Exiting %d\n", gtthread_self()); //gtthread_mutex_unlock(&g_mutex); while(k--); k = 2000000; //gtthread_yield(); } // printf("Exiting %d\n", gtthread_self()); //gtthread_join(t2, NULL); //gtthread_yield(); //k = 1000000; //} /*for (i = 0; i< 5; i++){ printf("Exiting %d\n", 1); while(k--); k = 1000000; }*/ const char quote[50] = "asdaa asd as dasd sdsdasdasd\0"; //gtthread_exit(quote); return (char*)quote; }
/* will swap out currently running thread for next thread in the queue*/ void alrm_handler(int sig) { gtthread *currentThread; /* block signals */ sigset_t oldset; sigprocmask(SIG_BLOCK, &alrm, &oldset); currentThread = (gtthread *) gtthread_self(); /* currently running thread has reached the end of its time slice */ /* push this thread to the back of the queue */ steque_cycle(¤tly_running); scheduleNextAndSwap(currentThread); sigprocmask(SIG_UNBLOCK, &alrm, NULL); }
int main() { printf("main: entering\n"); gtthread_init(100); main_thread = gtthread_self(); gtthread_t t1; gtthread_create(&t1, thr1, NULL); gtthread_exit(100); printf("main: exiting\n"); fflush(stdout); return 0; }
/* Tests creation. Should print "Hello World!" */ void thr2(void *in) { int i; int j = 0; char * a; int k = 1000000; //int *k = (int*) in; for (i = 0 ; i <10; i++){ //gtthread_mutex_lock(&g_mutex); printf("Exiting %d\n", gtthread_self()); //gtthread_mutex_unlock(&g_mutex); while(k--); k = 2000000; //gtthread_yield(); } return; }
int main() { gtthread_t t1; gtthread_t t2; gtthread_t t3; double sum_thread1 = 0; double *p1 = &sum_thread1; double **p2 = &p1; gtthread_mutex_init(&g_mutex); gtthread_init(10000); gtthread_create(&t1, thr1, NULL ); gtthread_create(&t2, thr2, NULL ); gtthread_create(&t3, thr3, NULL ); printf("id of thread1 is %d\n", t1.id); printf("id of thread1 is %d\n", t2.id); // get self id gtthread_t t0; t0 = gtthread_self(); printf("The main thread is %d \n", t0.id); //gtthread_yield(); //gtthread_cancel(t2); gtthread_join(t1, (void **) p2); printf("Returned Value from thread 1 = %f\n", **p2); gtthread_join(t2, NULL ); gtthread_join(t3, NULL ); printf("returning to main thread!\n"); // printf("returning to main thread again!\n"); gtthread_mutex_destroy(&g_mutex); printf("\n....Exiting the Main!....\n"); return EXIT_SUCCESS; }
/* The gtthread_cancel() function is analogous to pthread_cancel, allowing one thread to terminate another asynchronously. */ int gtthread_cancel(gtthread_t thread){ int i = 0; steque_node_t* current = q->front; block_signal(); if (gtthread_equal(thread, gtthread_self())){ gtthread_exit((void*)GTTHREAD_CANCELED); } for (i = 0; (i < q->N); i++) { if(gtthread_equal(thread, ((node_t*)current -> item) -> id)) { if (((node_t*)current -> item) -> canceled == 1){ return ESRCH; } else{ ((node_t*)current -> item) -> canceled = 1; ((node_t*)current -> item) -> returns = (void*)GTTHREAD_CANCELED; break; } } current = current -> next; } unblock_signal(); return 0; }
int main() { gtthread_t t1; gtthread_t t2; gtthread_t t3; double sum_thread1 = 0; double *p1 = &sum_thread1; double **p2 = &p1; gtthread_mutex_init(&g_mutex); gtthread_init(1000); gtthread_create(&t1, thr1, NULL ); printf("thread1 id %ld\n", t1); //t1.id); gtthread_create(&t2, thr2, NULL ); printf("thread2 id %ld\n", t2); //t2.id); gtthread_create(&t3, thr3, NULL ); printf("thread3 id %ld\n", t3); //t2.id); // get self id gtthread_t t0; t0 = gtthread_self(); printf("main thread id %ld \n", t0); //t0.id); //gtthread_yield(); gtthread_cancel(t2); //gtthread_join(t1, NULL); gtthread_join(t1, p2); printf("thread1 return = %f\n", **p2); gtthread_join(t2, NULL ); gtthread_join(t3, NULL ); printf("returning to main thread!\n"); // printf("returning to main thread again!\n"); gtthread_mutex_destroy(&g_mutex); printf("\n....Exiting the Main!....\n"); return EXIT_SUCCESS; }
void* thr1(void *in) { gtthread_cancel(gtthread_self()); printf("Failure. This line should not be reached.\n"); fflush(stdout); return NULL; }
/* The gtthread_cancel() function is analogous to pthread_cancel, allowing one thread to terminate another asynchronously. */ int gtthread_cancel(gtthread_t thread) { steque_enqueue(&g_cancelatorium, (void *) thread.id); if(gtthread_equal(thread, gtthread_self())) alarm_safe_yield(); return 0; }