static void cat_simulation(void * unusedpointer, unsigned long catnumber) { int i; unsigned int bowl; time_t before_sec, after_sec, wait_sec; uint32_t before_nsec, after_nsec, wait_nsec; /* avoid unused variable warnings. */ (void) unusedpointer; (void) catnumber; for(i=0;i<NumLoops;i++) { /* make the cat sleep */ cat_sleep(CatSleepTime); /* choose bowl. legal bowl numbers range from 1 to NumBowls */ bowl = ((unsigned int)random() % NumBowls) + 1; gettime(&before_sec,&before_nsec); cat_before_eating(bowl); /* student-implemented function */ gettime(&after_sec,&after_nsec); /* make the cat eat */ cat_eat(bowl, CatEatTime, catnumber); cat_after_eating(bowl); /* student-implemented function */ /* update wait time statistics */ getinterval(before_sec,before_nsec,after_sec,after_nsec,&wait_sec,&wait_nsec); P(perf_mutex); cat_total_wait_secs += wait_sec; cat_total_wait_nsecs += wait_nsec; if (cat_total_wait_nsecs > 1000000000) { cat_total_wait_nsecs -= 1000000000; cat_total_wait_secs ++; } cat_wait_count++; V(perf_mutex); } /* indicate that this cat simulation is finished */ V(CatMouseWait); }
static void cat_simulation(void * unusedpointer, unsigned long catnumber) { int i; unsigned int bowl; /* avoid unused variable warnings. */ (void) unusedpointer; (void) catnumber; /* your simulated cat must iterate NumLoops times, * sleeping (by calling cat_sleep() and eating * (by calling cat_eat()) on each iteration */ for(i=0;i<NumLoops;i++) { /* do not synchronize calls to cat_sleep(). Any number of cats (and mice) should be able sleep at the same time. */ cat_sleep(); /* for now, this cat chooses a random bowl from * which to eat, and it is not synchronized with * other cats and mice. * * you will probably want to control which bowl this * cat eats from, and you will need to provide * synchronization so that the cat does not violate * the rules when it eats */ #if OPT_A1 (void)bowl; //suppress warning eat(0); #else /* legal bowl numbers range from 1 to NumBowls */ bowl = ((unsigned int)random() % NumBowls) + 1; cat_eat(bowl); #endif // OPT_A1 } /* indicate that this cat simulation is finished */ V(CatMouseWait); }
void eat(const int creature_type) { /* * Convention: creature_type=0 -> cat. creature_type=1 -> mouse. */ // Try to enter kitchen and potentially get blocked/grouped enter_kitchen(creature_type); // Choose a random initial bowl index unsigned int bowl = ((unsigned int)random() % NumBowls); int i = 0; for (i = 0; i < NumBowls; i++) { // Try to acquire it, but don't block if it is occupied if (lock_tryacquire(k->bowl_locks[bowl])) break; // Try another bowl bowl = (bowl+1) % NumBowls; } // If all the bowls are occupied if (i == NumBowls) { // Just wait to acquire the initially chosen one bowl %= NumBowls; lock_acquire(k->bowl_locks[bowl]); } assert(lock_do_i_hold(k->bowl_locks[bowl])); // Eat if (creature_type) { mouse_eat(bowl+1); } else { cat_eat(bowl+1); } // Release this bowl's lock lock_release(k->bowl_locks[bowl]); exit_kitchen(); }
static void cat_simulation(void * unusedpointer, unsigned long catnumber) { init(); int i; unsigned int bowl; /* avoid unused variable warnings. */ (void) unusedpointer; (void) catnumber; /* your simulated cat must iterate NumLoops times, * sleeping (by calling cat_sleep() and eating * (by calling cat_eat()) on each iteration */ for(i=0;i<NumLoops;i++) { cat_sleep(CatSleepTime); /* do not synchronize calls to cat_sleep(). Any number of cats (and mice) should be able sleep at the same time. */ lock_acquire(bowlLock); while(numMouseEating > 0){ //kprintf("%d",numCatsEating); cv_wait(cats,bowlLock); } bowl = ((unsigned int)random() % NumBowls) + 1; while(bowlTaken[bowl] == true){ //kprintf("c"); bowl = ((unsigned int)random() % NumBowls) + 1; } bowlTaken[bowl] = true; lock_acquire(catEatLock); numCatsEating = numCatsEating+1; lock_release(catEatLock); lock_release(bowlLock); cat_eat(bowl, CatEatTime); bowlTaken[bowl] = false; lock_acquire(catEatLock); numCatsEating = numCatsEating - 1; lock_release(catEatLock); if (numCatsEating == 0){ cv_broadcast(mouse,bowlLock); } } /* indicate that this cat simulation is finished */ V(CatMouseWait); }
static void cat_simulation(void * unusedpointer, unsigned long catnumber) { int i; unsigned int bowl; /* avoid unused variable warnings. */ (void) unusedpointer; (void) catnumber; /* your simulated cat must iterate NumLoops times, * sleeping (by calling cat_sleep() and eating * (by calling cat_eat()) on each iteration */ for(i=0;i<NumLoops;i++) { /* do not synchronize calls to cat_sleep(). Any number of cats (and mice) should be able sleep at the same time. */ cat_sleep(); #if OPT_A1 lock_acquire(turnDecision); bowl = nextBowlCatCanUse; nextBowlCatCanUse = (nextBowlCatCanUse % NumBowls) + 1; while (mice_eating > 0 || ((int)cats_eating >= NumBowls && mice_waiting > 0)) { cats_waiting++; cv_wait(CatsAreWelcome, turnDecision); cats_waiting--; } cats_eating++; lock_release(turnDecision); lock_acquire(BowlLocks[bowl]); cat_eat(bowl); lock_release(BowlLocks[bowl]); lock_acquire(turnDecision); cats_eating--; if (cats_eating == 0) { cv_broadcast(MiceAreWelcome, turnDecision); } lock_release(turnDecision); #else /* for now, this cat chooses a random bowl from * which to eat, and it is not synchronized with * other cats and mice. * * you will probably want to control which bowl this * cat eats from, and you will need to provide * synchronization so that the cat does not violate * the rules when it eats */ /* legal bowl numbers range from 1 to NumBowls */ bowl = ((unsigned int)random() % NumBowls) + 1; cat_eat(bowl); #endif } /* indicate that this cat simulation is finished */ V(CatMouseWait); }