예제 #1
0
void giveUpForks(int i)
{
    int left, right;
    //gtthread_mutex_lock(&monitor);
      
    philosopherState[i] = THINKING;

    left = (i + NO_OF_PHILOSOPHERS - 1)% NO_OF_PHILOSOPHERS;
    right = (i) % NO_OF_PHILOSOPHERS;

	if(i % 2 == 0)
	{
		gtthread_mutex_unlock(&chopstickLock[right]);
		gtthread_mutex_unlock(&chopstickLock[left]);

	}
	else
	{
		gtthread_mutex_unlock(&chopstickLock[left]);
		gtthread_mutex_unlock(&chopstickLock[right]);
	}
    

    //gtthread_mutex_unlock(&monitor);  
    attemptToEat(left);
    attemptToEat(right);

    
}
예제 #2
0
파일: test6.c 프로젝트: rbs11/spring14
int main() {
	gtthread_t t1, t2, t3, t4, t5;

	gtthread_init(1000);
	gtthread_mutex_init(&gttm);

	gtthread_create(&t1, func1, (void*) 1);
	gtthread_create(&t2, func1, (void*) 2);
	gtthread_join(t1, NULL);
	gtthread_join(t2, NULL);

	gtthread_mutex_lock(&gttm);
	gtthread_create(&t3, func2, (void*) 3);
	gtthread_create(&t4, func2, (void*) 4);
	printf("This should print before threads 3 and 4 finish\n");
	gtthread_mutex_unlock(&gttm);
	gtthread_join(t3, NULL);
	gtthread_join(t4, NULL);

	printf("Testing yield with one schedulable thread... ");
	gtthread_yield();
	gtthread_yield();
	gtthread_yield();
	printf("done!\n");

	printf("Deadlocking with thread 5...\n");
	gtthread_mutex_lock(&gttm);
	gtthread_create(&t5, func3, NULL);
	gtthread_join(t5, NULL);
	gtthread_mutex_unlock(&gttm);
	printf("!!! ERROR !!! Failed to deadlock with thread 5\n");

	return 0;
}
예제 #3
0
파일: runner.c 프로젝트: ekawahyu/GTThreads
void *philosopher(void *arg){
	short i;
	gtthread_mutex_t f1,f2;
	switch((int)arg){
		case 1: f1=m5; f2=m1;break;
		case 2: f1=m2; f2=m1;break;
		case 3: f1=m3; f2=m2;break;
		case 4: f1=m4; f2=m3;break;
		case 5: f1=m5; f2=m4;break;
	}
	while(1){
		printf("Philosopher #%d tries to acquire fork %lu\n",(int)arg,f1);
		gtthread_mutex_lock(&f1);
		printf("Philosopher #%d tries to acquire fork %lu\n",(int)arg,f2);
		gtthread_mutex_lock(&f2);
		printf("Philosopher #%d eating with fork %lu and %lu\n",(int)arg,f1,f2);
		gtthread_yield();
		i=rand()%9999;
		while(--i>0);
		printf("Philosopher #%d releasing fork %lu\n",(int)arg,f2);
		gtthread_mutex_unlock(&f2);
		printf("Philosopher #%d releasing fork %lu\n",(int)arg,f1);
		gtthread_mutex_unlock(&f1);
		printf("Philosopher #%d thinking\n",(int)arg);
		gtthread_yield();
		i=rand()%9999;
		while(--i>0);
	}
}
예제 #4
0
void eat(int id) {
    int c[2];
    int r = rand() % 4;

    if(id == 0) {
        c[0] = gtthread_mutex_lock(chopstick[4]);
        c[1] = gtthread_mutex_lock(chopstick[0]);
    }
    else if(id % 2 == 1) {
        c[0] = gtthread_mutex_lock(chopstick[id]);
        c[1] = gtthread_mutex_lock(chopstick[(id - 1) % 5]);
    }
    else if(id % 2 == 0) {
        c[0] = gtthread_mutex_lock(chopstick[(id - 1) % 5]);
        c[1] = gtthread_mutex_lock(chopstick[id]);
    }

    if (c[0] == 0 && c[1] == 0) {
        printf("Philosopher %d is eating for %d seconds.\n", id, r);
        sleep(r);
    }
    if(id == 0) {
        c[0] = gtthread_mutex_unlock(chopstick[4]);
        c[1] = gtthread_mutex_lock(chopstick[0]);
    }
    else if(id % 2 == 1) {
        c[0] = gtthread_mutex_unlock(chopstick[id]);
        c[1] = gtthread_mutex_unlock(chopstick[(id - 1) % 5]);
    }
    else if(id % 2 == 0) {
        c[0] = gtthread_mutex_unlock(chopstick[(id - 1) % 5]);
        c[1] = gtthread_mutex_unlock(chopstick[id]);
    }
    printf("Philosopher %d is full.\n", id);
}
예제 #5
0
void
down_chopsticks (int c1,
			 int c2)
{
	gtthread_mutex_unlock (&chopstick[c1]);
	gtthread_mutex_unlock (&chopstick[c2]);
}
예제 #6
0
int main() {
  int i;
  gtthread_t t1, t2, t3, t6;
  void *ret;

  gtthread_mutex_init(&count_lock);

  gtthread_init(5);
  gtthread_create(&t1, thr1, (void *) 1);
  gtthread_create(&t2, thr2, (void *) 2);
  gtthread_create(&t3, thr3, (void *) 3);
  gtthread_create(&t6, thr6, (void *) 6);

  for (i = 0; i < LOOP_MAX; i++) {
    printf("Main thread!\n");
    fflush(stdout);

    gtthread_mutex_lock(&count_lock);
    count++;
    gtthread_mutex_unlock(&count_lock);

    if (i % YIELD_VAL == 0) {
      gtthread_yield();
    }
  }

  printf("main waiting for thr1...\n");
  fflush(stdout);
  gtthread_join(t1, &ret);
  printf("thr1 joined main with value %d!\n", (int) ret);
  fflush(stdout);

  gtthread_cancel(t2);
  printf("thr2 cancelled!\n");
  fflush(stdout);

  printf("main waiting for thr3...\n");
  fflush(stdout);
  gtthread_join(t3, &ret);
  printf("thr3 joined main with value %d!\n", (int) ret);
  fflush(stdout);

  printf("main waiting for thr6...\n");
  fflush(stdout);
  gtthread_join(t6, &ret);
  printf("thr6 joined main with value %d!\n", (int) ret);
  fflush(stdout);

  gtthread_mutex_lock(&count_lock);
  printf("Final count value: %lu\n", count);
  fflush(stdout);
  gtthread_mutex_unlock(&count_lock);

  gtthread_mutex_destroy(&count_lock);
  return EXIT_SUCCESS;
}
예제 #7
0
void* thr2(void *in) {
  gtthread_mutex_lock(&g_mutex);
  gtthread_mutex_unlock(&g_mutex);
  int k = 0;
  for (k = 0; k < 5; ++k) {
    gtthread_mutex_lock(&g_mutex);
    printf("thr2 hello\n");
    gtthread_mutex_unlock(&g_mutex);
    gtthread_yield();
  }
  return NULL;
}
예제 #8
0
파일: dining.c 프로젝트: ElFeo/GTThreads
void release_chopsticks (int id) {	
	if (id%2 == 0) {
	gtthread_mutex_unlock(&chopstick[(id+1)%5]);
	printf("Philosopher #%d released right chopstick.\n", id);
	gtthread_mutex_unlock(&chopstick[id]);
        printf("Philosopher #%d released left chopstick.\n", id);
	} else {
	gtthread_mutex_unlock(&chopstick[id]);
        printf("Philosopher #%d released left chopstick.\n", id);
	gtthread_mutex_unlock(&chopstick[(id+1)%5]);
	printf("Philosopher #%d released right chopstick.\n", id);
	}
}
예제 #9
0
void* worker(void* arg)
{
	gtthread_mutex_lock(&g_mutex);
	++g_num;
	gtthread_mutex_unlock(&g_mutex);
        return NULL;
}
예제 #10
0
void *thr4(void *in) {
  int i, j = 0;

  printf("thr4 started with parameter %d\n", (int) in);
  fflush(stdout);

  for (i = 0; i < LOOP_MAX; i++) { 
    printf("thr4!\n");
    fflush(stdout);
    j++;

    gtthread_mutex_lock(&count_lock);
    count++;
    gtthread_mutex_unlock(&count_lock);

    if (i % YIELD_VAL == 0) {
      gtthread_yield();
    }
  }

  printf("thr4 finished with parameter %d\n", (int) in);
  fflush(stdout);

  return (void *) j + 4;
}
예제 #11
0
void think(int phil) {
	gtthread_mutex_lock(&g_mutex);
	if(state[phil] == EATING) {
		printf("Philosopher %d is putting chopsticks %d and %d down \n", (phil+1), (phil+5)%N, (phil+1)%N);
	}
	state[phil] = THINKING;
	printf("Philosopher %d is thinking \n", phil+1);
	gtthread_mutex_unlock(&g_mutex);
}
예제 #12
0
void hungry(int phil) {
	
	gtthread_mutex_lock(&g_mutex);
	state[phil] = HUNGRY;
	printf("Philosopher %d is hungry \n", phil+1);
	for(i = 0; i<99999999; i++);

	eat(phil);
	gtthread_mutex_unlock(&g_mutex);
}
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);
}
예제 #14
0
void attemptToEat(int i)
{
    gtthread_mutex_lock(monitor);
   
    philosopherState[i] = HUNGRY;

    checkIfCanEat(i);

    gtthread_mutex_unlock(monitor);

    gtthread_mutex_lock(chopstickLock[i]);
}
예제 #15
0
void* worker(void* arg)
{
	int i;

	gtthread_mutex_lock(&g_mutex);
	for(i=0; i < 3; i++)
	{
		printf("thread %ld\n", (long)arg);
		gtthread_yield();
	}
	gtthread_mutex_unlock(&g_mutex);
        return NULL;
}
예제 #16
0
int
food_on_table ()
{
static int food = FOOD;
	int myfood;

	gtthread_mutex_lock (&food_lock);
	if (food > 0) {
		food--;
	}
	myfood = food;
	gtthread_mutex_unlock (&food_lock);
	return myfood;
}
예제 #17
0
파일: tc21.c 프로젝트: ChuckCottrill/cs6210
void *thrR(void *in)
{
    int ndx;
    int th = (int)(long)in;
    printf("thrR: enter\n"); fflush(stdout);
    for(ndx=0; ndx<100; ++ndx) {
        gtthread_mutex_lock(&m[0]);
printf("thrR: lock %d\n",th); fflush(stdout);
        usleep(100*1000);
printf("thrR: unlock %d\n",th); fflush(stdout);
        gtthread_mutex_unlock(&m[0]);
    }
    printf("thrR: exit\n"); fflush(stdout);
    return in;
}
예제 #18
0
void giveUpForks(int i)
{
    int left, right;
    gtthread_mutex_lock(monitor);
      
    philosopherState[i] = THINKING;

    left = (i + NO_OF_PHILOSOPHERS - 1)% NO_OF_PHILOSOPHERS;
    right = (i) % NO_OF_PHILOSOPHERS;

    checkIfCanEat(left);
    checkIfCanEat(right);

    gtthread_mutex_unlock(monitor);  
}
예제 #19
0
void checkIfCanEat(int i)
{
    int left, right;


     right =(i + 1) % NO_OF_PHILOSOPHERS;
     left = (i + NO_OF_PHILOSOPHERS - 1)% NO_OF_PHILOSOPHERS;

    if(philosopherState[i] == HUNGRY  && philosopherState[left] != EATING && philosopherState[right] != EATING)
    {
        philosopherState[i] == EATING;
        gtthread_mutex_unlock(chopstickLock[i]);
    }

}
예제 #20
0
파일: tc8.c 프로젝트: ChuckCottrill/cs6210
void *thr3(void *in)
{
    printf("Hello World! from thread 3\n");
    fflush(stdout);
    double sum;
    gtthread_mutex_lock(&g_mutex);
    g_count = g_count + 3;
    printf("global count from thread 3: %d\n", g_count);
    gtthread_mutex_unlock(&g_mutex);
    sum = killCycle(3, CYCLE_NUM);
    // gtthread_exit(NULL);
    printf("returning from thread 3 %f \n", sum);
    return NULL ;
    // gtthread_yield();
}
예제 #21
0
int main() {
    printf("test6b. Should print 'main hello' then 'thr1 hello' and 'thr2 hello' for 5 times interleaving (but no mixed up prints e.g. 'th1 thr2 hello hello')\n");

    gtthread_init(50000L);
    gtthread_mutex_init(&g_mutex);
    gtthread_mutex_lock(&g_mutex);

    gtthread_create( &t1, thr1, NULL);
    gtthread_create( &t2, thr2, NULL);
    gtthread_yield();
    printf("main hello\n");
    gtthread_mutex_unlock(&g_mutex);
    gtthread_join(t2, NULL);
    gtthread_join(t1, NULL);
    return EXIT_SUCCESS;
}
예제 #22
0
파일: test6.c 프로젝트: rbs11/spring14
void *func2(void *arg) {
	long x = (long) arg;
	volatile int y;
	for(int i = 5; i; --i) {
		gtthread_mutex_lock(&gttm);
		gtthread_yield();
		char *dst = buffer, *src = "\tThis is a locked message from thread ";
		while((*dst++ = *src++)) {
			y = 5000000;
			while(--y);
		}
		printf("%s%ld\n", buffer, x);
		memset(buffer, ' ', 50);
		gtthread_mutex_unlock(&gttm);
	}
	return NULL;
}
예제 #23
0
파일: tc21.c 프로젝트: ChuckCottrill/cs6210
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;
}
예제 #24
0
void pickChopsticks(int i)
{
    int left, right;

    left = (i+1)%NO_OF_PHILOSOPHERS;
    right = (i+NO_OF_PHILOSOPHERS - 1)%NO_OF_PHILOSOPHERS;

    if(i%2 == 1)
    {
      gtthread_mutex_unlock(&chopsticks[left]);
      gtthread_mutex_lock(&chopsticks[right]);
    }
    else
    {
        gtthread_mutex_lock(&chopsticks[right]);
        gtthread_mutex_lock(&chopsticks[left]);
    }

    fprintf(stderr, "\nPhilosopher %d is eating", i);
}
예제 #25
0
파일: tc23.c 프로젝트: ChuckCottrill/cs6210
void *thrH(void *in)
{
    int ndx;
    int th = (int)in;
    int dur = (int)hold[th];
    gtthread_mutex_t* mtx = m[0];
    printf("thrH: enter\n"); fflush(stdout);
    for(ndx=0; ndx<10; ++ndx) {
        gtthread_mutex_lock(mutex);
printf("thrH: lock %d\n",th); fflush(stdout);
        gtthread_yield();
        usleep(dur*1000);
        gtthread_yield();
printf("thrH: unlock %d\n",th); fflush(stdout);
        gtthread_mutex_unlock(mutex);
        gtthread_yield();
    }
    printf("thrH: exit\n"); fflush(stdout);
    return in;
}
예제 #26
0
파일: tc8.c 프로젝트: ChuckCottrill/cs6210
double* thr1(void *in)
{
    printf("Hello World! from thread 1\n");
    fflush(stdout);
    double sum;
    gtthread_mutex_lock(&g_mutex);
    printf("%p,%p\n",g_mutex,&g_mutex);
    g_count = g_count + 1;
    printf("global count from thread 1: %d\n", g_count);
    sum = killCycle(1, CYCLE_NUM);
    gtthread_mutex_unlock(&g_mutex);
    // gtthread_exit(NULL);
    printf("returning from thread 1 %f \n", sum);
    // gtthread_exit(NULL);
    double *ret_ptr = malloc(sizeof(double));
    *ret_ptr = sum;
    printf("returning from thread with value= %f \n", sum);
    return ret_ptr;
    // gtthread_yield();
    // return NULL;
}
예제 #27
0
파일: tc21.c 프로젝트: ChuckCottrill/cs6210
int main()
{
    int rc;
    int rep;
    int ndx;
    printf("test mutex init, lock, unlock, destroy\n");
    for( ndx=0; ndx<100; ++ndx ) {
        hold[ndx] = 100+(ndx%10)*10;
    }
    printf("main: enter\n");
    gtthread_init(period);
    for( ndx=0; ndx<10; ++ndx ) {
        rc = gtthread_mutex_init(&m[ndx]);
        printf("init %d\n",ndx); fflush(stdout);
        if(rc)printf("rc = %d\n",rc); fflush(stdout);
    }
    for( rep=0; rep<10; ++rep ) {
      for( ndx=0; ndx<10; ++ndx ) {
        rc = gtthread_mutex_lock(&m[ndx]);
        printf("lock(%d)\n",ndx); fflush(stdout);
        if(rc)printf("rc = %d\n",rc); fflush(stdout);
        usleep(10*1000);
        rc = gtthread_mutex_unlock(&m[ndx]);
        printf("unlock(%d)\n",ndx); fflush(stdout);
        if(rc)printf("rc = %d\n",rc); fflush(stdout);
      }
    }
    for( ndx=0; ndx<10; ++ndx ) {
        rc = gtthread_mutex_destroy(&m[ndx]);
        printf("destroy(%d)\n",ndx,rc); fflush(stdout);
        if(rc)printf("rc = %d\n",rc); fflush(stdout);
    }
    printf("main: exit\n");
    fflush(stdout);
    return EXIT_SUCCESS;
}
예제 #28
0
파일: test6.c 프로젝트: rbs11/spring14
void *func3(void *arg) {
	gtthread_mutex_lock(&gttm);
	printf("Printing from thread 5... which shouldn\'t happen\n");
	gtthread_mutex_unlock(&gttm);
	return NULL;
}