void wrapper(void* (*start_routine)(void*), void *arg)
{
void *retval;
retval = (void *) start_routine(arg);
gtthread_exit(retval);
return;
}
/*
The gtthread_cancel() function is analogous to pthread_cancel,
allowing one thread to terminate another asynchronously.
*/
int gtthread_cancel(gtthread_t thread)
{
/* if a thread cancel itself */
if (gtthread_equal(current->tid, thread))
gtthread_exit(0);
sigprocmask(SIG_BLOCK, &vtalrm, NULL);
thread_t* t = thread_get(thread);
if (t == NULL)
{
sigprocmask(SIG_UNBLOCK, &vtalrm, NULL);
return -1;
}
if (t->state == GTTHREAD_DONE)
{
sigprocmask(SIG_UNBLOCK, &vtalrm, NULL);
return -1;
}
if (t->state == GTTHREAD_CANCEL)
{
sigprocmask(SIG_UNBLOCK, &vtalrm, NULL);
return -1;
}
else
t->state = GTTHREAD_CANCEL;
free(t->ucp->uc_stack.ss_sp);
free(t->ucp);
t->ucp = NULL;
t->joining = 0;
steque_enqueue(&zombie_queue, t);
sigprocmask(SIG_UNBLOCK, &vtalrm, NULL);
return 0;
}
void run_thread(void *(*start_routine)(void *), void *arg)
{
void *rv;
sigprocmask(SIG_UNBLOCK, &alrm, NULL);
rv = start_routine(arg);
gtthread_exit(rv);
}
int main() {
printf("test4c. Should print 'Success'.\n");
gtthread_init(50000L);
gtthread_create( &t, thr, NULL);
gtthread_exit(NULL);
return EXIT_SUCCESS;
}
static void start_wrapper(void *(*start_routine)(void *), void *arg) {
void *retval;
/* Unblock alarms */
sigprocmask(SIG_UNBLOCK, &vtalrm, NULL);
retval = start_routine(arg);
gtthread_exit(retval);
}
void main () {
int i;
gtthread_init(100000);
for (i=0; i<5; i++) {
gtthread_mutex_init(&chopstick[i]);
gtthread_create(&philosopher[i], (void *)dining, (int *)(i+1));
}
gtthread_exit(NULL);
}
/*
* A wrapper function to start a routine.
* The reason we need this is because we need to call gtthread_exit
* when the thread finish executing.
*/
void gtthread_start(void* (*start_routine)(void*), void* args)
{
/* unblock signal comes from gtthread_create */
sigprocmask(SIG_UNBLOCK, &vtalrm, NULL);
/* start executing the start routine*/
current->retval = (*start_routine)(args);
/* when start_rountine returns, call gtthread_exit*/
gtthread_exit(current->retval);
}
void thread_handler(void *(*thread_func)(void *), void *arg){
void *retval;
gtthread_blk_t *cur;
cur = get_cur_thread();
DEBUG_MSG("thread_handler: thread ID: # %ld\n", cur->tID);
retval = (*thread_func)(arg);
gtthread_exit(retval);
}
void *thrX(void *in)
{
int ndx;
printf("thrX: enter\n"); fflush(stdout);
for(ndx=0; ndx<5; ++ndx) {
usleep(10*1000);
puts("X");
gtthread_yield();
}
printf("thrX: exit\n"); fflush(stdout);
gtthread_exit(in);
return in;
}
int main()
{
gtthread_t th1;
gtthread_init(1000);
gtthread_create(&th1, worker, NULL);
printf("main exit\n");
gtthread_exit(NULL);
return 0;
}
/* join specified thread */
void *thrJ(void *in)
{
int result;
void* status = (void*)in;
long th = (long)in;
printf("thrJ: enter %ld\n",th); fflush(stdout);
result = gtthread_join(t[th],&status);
if(result) printf("thrJ.join %d %d\n",th,result);
printf("thread %d return %d\n",th,(long)status);
printf("thrJ: exit\n"); fflush(stdout);
gtthread_exit(status);
return status;
}
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;
}
int main() {
gtthread_t t1, t2, t3;
gtthread_init(1000);
gtthread_create(&t1, func1, NULL);
gtthread_create(&t2, func2, NULL);
gtthread_create(&t3, func3, NULL);
void *msg;
gtthread_join(t2, &msg);
printf("%s\n", (char*) msg);
free(msg);
printf("main thread exiting...\n");
gtthread_exit(NULL);
return 0;
}
void *thrX(void *in)
{
int ndx;
int th = (int)(long)in;
int dur = (int)hold[th];
printf("thrX: enter\n"); fflush(stdout);
for(ndx=0; ndx<10; ++ndx) {
gtthread_mutex_lock(&m[0]);
printf("thrX: lock %d\n",th); fflush(stdout);
gtthread_yield();
usleep(dur*1000);
printf("thrX: unlock %d\n",th); fflush(stdout);
gtthread_mutex_unlock(&m[0]);
gtthread_yield();
}
printf("thrX: exit\n"); fflush(stdout);
gtthread_exit(in);
return in;
}
main()
{
int i;
gtthread_init(100);
gtthread_t philosopher_thread[CHOPSTICKS];
int dn[CHOPSTICKS];
void *diner();
// intializing all the locks
for (i=0;i<CHOPSTICKS;i++){
gtthread_mutex_init(&chopstick_mutex[i]);
philosopher_status[i]=INITIAL;
}
// creating the philosphers
for (i=0;i<CHOPSTICKS;i++){
dn[i] = i;
gtthread_create(&philosopher_thread[i],diner,&dn[i]);
}
gtthread_exit(0);
// while(1)
}
void *diner(int *i)
{
int philId, eat, think, tTime, eTime;
//int eating = 0;
printf("I'm Philosopher %d\n",*i);
philId = *i;
int forwardCycle=0;
if(philId%2==0){
forwardCycle=1;
}
while (1) {
philosopher_status[philId]=THINKING;
printf("Philosopher %d is thinking\n", philId);
think=rand()%10000000;
for(tTime=0;tTime<think;tTime++);
philosopher_status[philId]=HUNGRY;
printf("Philosopher %d is hungry\n", philId);
while(philosopher_status[philId+CHOPSTICKS-1]==EATING || philosopher_status[philId+1]==EATING);
if(forwardCycle){
gtthread_mutex_lock(&chopstick_mutex[philId]);
gtthread_mutex_lock(&chopstick_mutex[(philId+1)%CHOPSTICKS]);
} else{
gtthread_mutex_lock(&chopstick_mutex[(philId+1)%CHOPSTICKS]);
gtthread_mutex_lock(&chopstick_mutex[philId]);
}
philosopher_status[philId]=EATING;
printf("Philosopher %d is eating\n", philId);
eat=rand()%10000000;
for(eTime=0;eTime<eat;eTime++);
printf("Philosopher %d is done eating\n", philId);
if(forwardCycle){
gtthread_mutex_unlock(&chopstick_mutex[(philId+1)%CHOPSTICKS]);
gtthread_mutex_unlock(&chopstick_mutex[philId]);
} else{
gtthread_mutex_unlock(&chopstick_mutex[philId]);
gtthread_mutex_unlock(&chopstick_mutex[(philId+1)%CHOPSTICKS]);
}
}
gtthread_exit(NULL);
}
/*
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() {
printf("gtthread_init\n");
fflush(stdout);
gtthread_t t1,t2,t3;
fflush(stdout);
gtthread_init(1);
int a = 1;
int b = 2;
int c = 3;
gtthread_create( &t1, thr1, &a);
gtthread_create( &t2, thr1, &b);
gtthread_create( &t3, thr1, &c);
printf("create finish\n");
//fflush(stdout);
int j = 0;
long i;
while(j != 10){
i = 0;
while(i<100000){
i++;
//printf("***\n");
}
printf ("main\n");
fflush(stdout);
//printf("self id = %d\n",gtthread_self().id);
j++;
//gtthread_yield();
}
gtthread_cancel(t1);
printf("main finish\n");
gtthread_exit(0);
//gtthread_yield();
//return EXIT_SUCCESS;
}
/**
* Applies the function pointed to by func to arg, and stores the return
* value in retval. Inspired by the apply() method in Python.
*/
static void apply(void *(*func) (void *), void *arg, gtthread_t *runner_thread) {
runner_thread->retval = (void *) func(arg);
gtthread_exit(NULL);
}
void* worker(void* arg)
{
long i = (long) arg;
gtthread_exit((void*) g_return_values[i]);
return NULL;
}
