CS 3733 Operating Systems, Fall 2007 Assignment 5 Comments

Comments on the bounded buffer of assignment 5.

• The buffer should be implemented as a queue, not a stack.
  This was specified in the assignment.
• It is not safe to test or modify shared variables unless they are in a protected critical section.
• You should use 3 semaphores, or two semaphores and a mutex lock. The general idea is the same as from the course lecture (see below), or from page 205 of the text (7th edition).
• It is the responsibility of this buffer to block the calling process if the operation cannot be completed right away because of a full or empty buffer.
• This buffer should not check for identical items.
  That is the responsibility of the solution_buffer.
• Here is the pseudocode for the putin and remove, basically from the course notes:

           get the item           wait(full)
           wait(empty)            wait(mutex)
           wait(mutex)            item = buffer[out]
           buffer[in] = item      out = (out + 1)%n;
           in = (in + 1)%n        signal(mutex)
           signal(mutex)          signal(empty)
           signal(full)           return item
  

• Your Part 2 should not require that there are an equal number of producers and consumers.
• Be sure to look through the entire assignment, even if there is nothing written on the front.
• A function that is used as a thread must return a pointer and have a single pointer parameter, even if that parameter is not used.
• For Part 2, when do the consumers stop consuming? There are 2 ways to do this.
  • Tell each consumer exactly how many items to consume.
    This is easy when the number of producers equals the number of consumers and most people assumed this, with each producer and consumer handling max items.
    If the number of producers and consumers is different, it is a little more difficult, and nobody did it right.
    The following does not work:
        nprod = number of producers
        ncon = number of consumers
        Each producer handles max/npord items
        Each consumer handles max/ncon items
    What happens when max = 8, nprod = 2, and ncon = 3?
  • Tell the consumers to stop when the producers have finished and the bounded_buffer is empty. This requires some tricky synchronization.
    • Need a protected shared flag, producersDone
    • remove in bounded_buffer needs to return if the buffer is empty and producersDone is true.
      This needs to be done before wait(full).