Operating systems
Download as PPT, PDF0 likes293 views
The document discusses two solutions to classic concurrency problems: 1) An unbounded buffer problem is solved using locks on an array to control a producer and consumer thread. The array tracks items and locks ensure only one thread accesses it at a time. 2) The dining philosophers problem is solved by having philosophers randomly wait before acquiring both forks, to avoid deadlock. Locks ensure at most two philosophers can try to acquire forks at once.
![CODE Philosophers[N]; //Array to store the philosophers Lock *L1 // Only two philosophers can try to get 2 forks Lock *L2 void philosopher (i){ WHILE(true){ think(); //All the philosophers start waiting take_forks(i); }//End of while }//End of function void take_forks(int i){ Look_for_Locks(); Get_Forks(); Eat(); Drop_Forks(); L1->release() || L2 ->release(); //release the lock that the philosophers has philosopher return to the queue }//End of function](https://image.slidesharecdn.com/operatingsystems-110912095215-phpapp02/85/Operating-systems-10-320.jpg)
Operating systems
- 1. Operating Systems Team: Jonathan Arturo Alvarado Mata 1441616 Obed David Guevara Ibarra 1447478 Carlos Eduardo Triana Sarmiento 1412573 Blog: http://os-ocj.blogspot.com/
- 2. First Point Explain how to solve unbounded-buffer producer-consumer with locks. Discuss the quality of the proposed solution.
- 3. what we did?... We use an array as global variable, this array contain the number of items. We use this array to control the producer and the consumer, because if the array is full the producer stops producing and if the array is empty the consumer stops consuming Also we use two threads, one for the consumer and the other for the producer.
- 4. what we did?... The assignment consists in implementing locks to the producer consumer problem. So we have to declare a lock as a global variable, which controls the threads activity. This is important to remember.... Only the thread that acquired the lock can release it
- 5. CODE LOCK *L1; CONDITION *C PRODUCER(){ WHILE(1){ try to aquire the lock IF(L1->TRYAQUIRE()){ if the array is full, lets wait if it isn’t, continue... WHILE(ARRAY == FULL){ C->WAIT(L1) } increase the number of items in the array C-> SIGNAL(); Enables the waiting threads L1->RELEASE(); }end of if }end of while } end of the function producer
- 6. CONSUMER(){ while(1){ try to aquire the lock if(l1->TRYAQUIRE()){ if the array is empty, wait if it isn’t, continue... WHILE(ARRAY == EMPTY){ C->WAIT(L1); }decrease the number of items in the array CONSUME(); C-> SIGNALl(); Enables the waiting thread L1->RELEASE(); }end of if }end of while }//end of function consumer
- 7. void main(){ L1 = new lock(“L1”); C = new condition(“C”); Thread *t = new Thread(“producer”); t->Fork(producer, 1); Thread * t= new Thread(“consumer”); t->Fork(consumer, 1); }end main
- 8. Second Point Explain how to detect and eliminate deadlock in the dinning philosophers problem.
- 9. The solution... * This is the solution When a philosopher has a fork waits a random time to get the second fork. If in that time is not free the second fork, release the one he has and go back to the queue If a philosopher "A" release a fork (because he has eaten or because he waited too long with a fork in hand) but still want to eat, getting back on line to the fork. Basically we follow this concept and that's how we make the code
- 10. CODE Philosophers[N]; //Array to store the philosophers Lock *L1 // Only two philosophers can try to get 2 forks Lock *L2 void philosopher (i){ WHILE(true){ think(); //All the philosophers start waiting take_forks(i); }//End of while }//End of function void take_forks(int i){ Look_for_Locks(); Get_Forks(); Eat(); Drop_Forks(); L1->release() || L2 ->release(); //release the lock that the philosophers has philosopher return to the queue }//End of function
- 11. void Look_for_Locks(){ IF(L1->tryaquire() || L2 -> tryaquire()){ if one is available return to take_forks }ELSE{ // if not wait some time look if one lock is available and try to get it if no lock is available L1-> release() || L2 -> release() philosopher return to the queue }//end else }
- 12. void Get_Forks(){ Look for forks; if(fork == 1 || fork == 0) // if no Lock is available or if only got one wait some time look if forks are available and try to get one or two if (fork == 2){ return to take_forks }else{ // if doesn’t get the fork it need drop fork L1-> release() || L2 -> release() // release the lock that the philosophers has philosopher return to the queue }else{ return to take_forks } }
- 13. Bibliography *Operating Systems-Design and Implementation, Second Edition Author: Andrew S. Tanenbaum and Albert S. Woodhull * http://www.isi.edu/~faber/cs402/notes/lecture7.html *http://www.4coders.com/index.php?modulo=contenido&op=detalle&tipo=c&id=83http://www.4coders.com/index.php?modulo=contenido&op=detalle&tipo=c&id=83 *http://es.wikipedia.org/wiki/Problema_de_la_cena_de_los_fil%C3%B3sofos