SHARE
TWEET

Big brain

a guest Feb 20th, 2020 95 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. /*
  2.  * catsem.c
  3.  *
  4.  * Please use SEMAPHORES to solve the cat syncronization problem in
  5.  * this file.
  6.  */
  7.  
  8.  
  9. /*
  10.  *
  11.  * Includes
  12.  *
  13.  */
  14.  
  15. #include <types.h>
  16. #include <lib.h>
  17. #include <test.h>
  18. #include <thread.h>
  19. #include "catmouse.h"
  20.  
  21. // added this
  22. #include <synch.h>
  23.  
  24. // access controls
  25. struct semaphore *bowl_check;
  26. struct semaphore *bowl_access;
  27.  
  28. // is the bowl being eaten from (1 means yes, 0 means no)
  29. //int bowl1 = 1;
  30. //int bowl2 = 1;
  31.  
  32. // counters to keep track of cat and mouse
  33.  
  34. //int catCount = 0;
  35. //int mouseCount = 0;
  36.  
  37. struct type{
  38.         int cat;
  39.         int mouse;
  40.         int empty;
  41.        
  42. };  
  43.  
  44. struct type bowl1, bowl2;
  45. /*
  46.  *
  47.  * Function Definitions
  48.  *
  49.  */
  50.  
  51. /*
  52.  * catsem()
  53.  *
  54.  * Arguments:
  55.  *      void * unusedpointer: currently unused.
  56.  *      unsigned long catnumber: holds the cat identifier from 0 to NCATS - 1.
  57.  *
  58.  * Returns:
  59.  *      nothing.
  60.  *
  61.  * Notes:
  62.  *      Write and comment this function using semaphores.
  63.  *
  64.  */
  65.  
  66. static
  67. void
  68. catsem(void * unusedpointer,
  69.        unsigned long catnumber)
  70. {
  71.         /*
  72.          * Avoid unused variable warnings.
  73.          */
  74.  
  75. int bowl;
  76.         /*
  77.          * a thread was created/forked from catmousesem
  78.          * now let this thread try and access the food/semaphore
  79.          * if it can't (2 threads already eating), sleep
  80.          * else if a mouse thread is eating, sleep
  81.         */
  82.  
  83.         int meal = 0;
  84.         // while the thread has not eaten all its meals yet
  85.         while ( meal < NMEALS) {
  86.                 // If there are 2 things eating, it won't be able to acquire the other semaphore
  87.                 P(bowl_access);
  88.                 P(bowl_check);
  89.                 // if the mouse is eatiing the cat cant eat              
  90.                 if ((bowl1.mouse == 1)||(bowl2.mouse == 1)){
  91.                         meal--;
  92.                         V(bowl_check);
  93.                         V(bowl_access);
  94.                         continue;
  95.                 }
  96.                 //catCount++;
  97.                 assert (bowl1.mouse == 0 && bowl2.mouse == 0)
  98.                // if (catCount == 1){
  99.                       //  P(cat_or_mouse);
  100.                         // critical region
  101.                         if (bowl1.cat == 1) {
  102.                                 bowl2.cat = 1;
  103.                                 catmouse_eat("cat", catnumber, 2, meal);
  104.                                // bowl2 = 1;
  105.                                bowl = 2;
  106.                         }
  107.                         else {
  108.                                 bowl1.cat = 1;
  109.                                 catmouse_eat("cat", catnumber, 1, meal);
  110.                                 //bowl1 = 1; // bowl1 now occupied
  111.                                  bowl = 1;
  112.                         }
  113.                         meal++;
  114.                         V(bowl_check);
  115.                // }
  116.                
  117.                 P(bowl_check);
  118.                // catCount--;
  119.                // if(catCount == 0)// all cats finished eating
  120.                  //       V(cat_or_mouse);
  121.                 if(bowl == 1)
  122.                         bowl1.empty = 1;
  123.                 else
  124.                         bowl2.empty = 1;
  125.                 V(bowl_check);
  126.                 V(bowl_access);
  127.         }
  128.  
  129.  
  130.         (void) unusedpointer;
  131.         (void) catnumber;
  132. }
  133.        
  134.  
  135. /*
  136.  * mousesem()
  137.  *
  138.  * Arguments:
  139.  *      void * unusedpointer: currently unused.
  140.  *      unsigned long mousenumber: holds the mouse identifier from 0 to
  141.  *              NMICE - 1.
  142.  *
  143.  * Returns:
  144.  *      nothing.
  145.  *
  146.  * Notes:
  147.  *      Write and comment this function using semaphores.
  148.  *
  149.  */
  150.  
  151. static
  152. void
  153. mousesem(void * unusedpointer,
  154.          unsigned long mousenumber)
  155. {
  156.         /*
  157.          * Avoid unused variable warnings.
  158.          */
  159. int bowl = 0;
  160.         // if no one is there, go ahead
  161.         // or if there is one mouse eating, go ahead
  162.         // if there is one cat eating, wait
  163.         // or if there are two things eating (no matter what they are), wait
  164.  
  165.         int meal = 0;
  166.  
  167.         // while the thread has not eaten all its meals yet
  168.         while (meal < NMEALS) {
  169.                  // If there are 2 things eating, it won't be able to acquire the other semaphore
  170.                 P(bowl_access);
  171.                 P(bowl_check);
  172.  
  173.                 if ((bowl1.cat == 1) || (bowl2.cat == 1)){
  174.                         meal--;
  175.                         V(bowl_check);
  176.                         V(bowl_access);
  177.                         continue;
  178.                 }        
  179.                 // If a cat is eating, it won't be able to acquire the semaphore
  180.               //  mouseCount++;
  181.                  assert (bowl1.cat == 0 && bowl2.cat == 0)
  182.                // if (mouseCount == 1){
  183.                        
  184.                  //       P(cat_or_mouse);
  185.                        
  186.                         // critical region
  187.                        
  188.                         if (bowl1.mouse == 1) {
  189.                                 bowl2.mouse = 1;
  190.                                 catmouse_eat("mouse", mousenumber, 2, meal);
  191.                                 bowl = 2;
  192.                         }
  193.                         else  {
  194.                                 bowl1.mouse =1;
  195.                                 catmouse_eat("mouse", mousenumber, 1, meal);
  196.                                 bowl = 1; // bowl1 now occupied
  197.                         }
  198.                         meal++;
  199.                         V(bowl_check);
  200.                 //}
  201.                
  202.                 P(bowl_check);
  203.                
  204.               //  mouseCount--;
  205.                
  206.               //  if(mouseCount == 0)// all cats finished eating
  207.                 //        V(cat_or_mouse);
  208.                
  209.                 if(bowl == 1)
  210.                         bowl1.empty = 1;
  211.                 else
  212.                         bowl2.empty = 1;
  213.                
  214.                 V(bowl_check);
  215.                 V(bowl_access);
  216.         }
  217.  
  218.         (void) unusedpointer;
  219.         (void) mousenumber;
  220. }
  221.  
  222.  
  223. /*
  224.  * catmousesem()
  225.  *
  226.  * Arguments:
  227.  *      int nargs: unused.
  228.  *      char ** args: unused.
  229.  *
  230.  * Returns:
  231.  *      0 on success.
  232.  *
  233.  * Notes:
  234.  *      Driver code to start up catsem() and mousesem() threads.  Change this
  235.  *      code as necessary for your solution.
  236.  */
  237.  
  238. int
  239. catmousesem(int nargs,
  240.             char ** args)
  241. {
  242.         int index, error;
  243.         bowl_check = sem_create("bowl_check", 2);
  244.         bowl_access = sem_create("bowl_access", 1);
  245.  
  246.  
  247.         /*
  248.          * Start NCATS catsem() threads.
  249.          */
  250.  
  251.         for (index = 0; index < NCATS; index++) {
  252.            
  253.                 error = thread_fork("catsem Thread",
  254.                                     NULL,
  255.                                     index,
  256.                                     catsem,
  257.                                     NULL
  258.                                     );
  259.                
  260.                 /*
  261.                  * panic() on error.
  262.                  */
  263.  
  264.                 if (error) {
  265.                  
  266.                         panic("catsem: thread_fork failed: %s\n",
  267.                               strerror(error)
  268.                               );
  269.                 }
  270.         }
  271.        
  272.         /*
  273.          * Start NMICE mousesem() threads.
  274.          */
  275.  
  276.         for (index = 0; index < NMICE; index++) {
  277.    
  278.                 error = thread_fork("mousesem Thread",
  279.                                     NULL,
  280.                                     index,
  281.                                     mousesem,
  282.                                     NULL
  283.                                     );
  284.                
  285.                 /*
  286.                  * panic() on error.
  287.                  */
  288.  
  289.                 if (error) {
  290.          
  291.                         panic("mousesem: thread_fork failed: %s\n",
  292.                               strerror(error)
  293.                               );
  294.                 }
  295.         }
  296.  
  297.         /*
  298.          * wait until all other threads finish
  299.          */
  300.  
  301.         while (thread_count() > 1)
  302.                 thread_yield();
  303.  
  304.         (void)nargs;
  305.         (void)args;
  306.         kprintf("catsem test done\n");
  307.  
  308.         return 0;
  309. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
Top