Locks and Condition Variables

Lecture Notes for CS 140
Spring 2014
John Ousterhout

  • Readings for this topic from Operating Systems: Principles and Practice: Sections 5.2-5.4.
  • Needed: higher-level synchronization mechanism that provides
    • Mutual exclusion: easy to create critical sections
    • Scheduling: block thread until some desired event occurs

Locks

  • Lock: an object that can only be owned by a single thread at any given time. Basic operations on a lock:
    • acquire: mark the lock as owned by the current thread; if some other thread already owns the lock then first wait until the lock is free. Lock typically includes a queue to keep track of multiple waiting threads.
    • release: mark the lock as free (it must currently be owned by the calling thread).
  • Too much milk solution with locks (using Pintos APIs):
    struct lock l;
    ...
    lock_acquire(&l);
    if (milk == 0) {
      buy_milk();
    }
    lock_release(&l);
    
  • A more complex example: producer/consumer.
    • Producers add characters to a buffer
    • Consumers remove characters from the buffer
    • Characters will be removed in the same order added
    • Version 1:
      char buffer[SIZE];
      int count = 0, putIndex = 0, getIndex = 0;
      struct lock l;
      lock_init(&l);
      
      void put(char c) {
          lock_acquire(&l);
          count++;
          buffer[putIndex] = c;
          putIndex++;
          if (putIndex == SIZE) {
              putIndex = 0;
          }
          lock_release(&l);
      }
      
      char get() {
          char c;
          lock_acquire(&l);
          count--;
          c = buffer[getIndex];
          getIndex++;
          if (getIndex == SIZE) {
              getIndex = 0;
          }
          lock_release(&l);
          return c;
      }
      
    • Version 2 (handle empty/full cases):
      char buffer[SIZE];
      int count = 0, putIndex = 0, getIndex = 0;
      struct lock l;
      lock_init(&l);
      
      void put(char c) {
          lock_acquire(&l);
          while (count == SIZE) {
              lock_release(&l);
              lock_acquire(&l);
          }
          count++;
          buffer[putIndex] = c;
          putIndex++;
          if (putIndex == SIZE) {
              putIndex = 0;
          }
          lock_release(&l);
      }
      
      char get() {
          char c;
          lock_acquire(&l);
          while (count == 0) {
              lock_release(&l);
              lock_acquire(&l);
          }
          count--;
          c = buffer[getIndex];
          getIndex++;
          if (getIndex == SIZE) {
              getIndex = 0;
          }
          lock_release(&l);
          return c;
      }
      

Condition Variables

  • Synchronization mechanisms need more than just mutual exclusion; also need a way to wait for another thread to do something (e.g., wait for a character to be added to the buffer)
  • Condition variables: used to wait for a particular condition to become true (e.g. characters in buffer).
    • wait(condition, lock): release lock, put thread to sleep until condition is signaled; when thread wakes up again, re-acquire lock before returning.
    • signal(condition, lock): if any threads are waiting on condition, wake up one of them. Caller must hold lock, which must be the same as the lock used in the wait call.
    • broadcast(condition, lock): same as signal, except wake up all waiting threads.
    • Note: after signal, signaling thread keeps lock, waking thread goes on the queue waiting for the lock.
    • Warning: when a thread wakes up after cond_wait there is no guarantee that the desired condition still exists: another thread might have snuck in.
  • Producer/Consumer, version 3 (with condition variables):
    char buffer[SIZE];
    int count = 0, putIndex = 0, getIndex = 0;
    struct lock l;
    struct condition dataAvailable;
    struct condition spaceAvailable;
    
    lock_init(&l);
    cond_init(&dataAvailable);
    cond_init(&spaceAvailable);
    
    void put(char c) {
        lock_acquire(&l);
        while (count == SIZE) {
            cond_wait(&spaceAvailable, &l);
        }
        count++;
        buffer[putIndex] = c;
        putIndex++;
        if (putIndex == SIZE) {
            putIndex = 0;
        }
        cond_signal(&dataAvailable, &l);
        lock_release(&l);
    }
    
    char get() {
        char c;
        lock_acquire(&l);
        while (count == 0) {
            cond_wait(&dataAvailable, &l);
        }
        count--;
        c = buffer[getIndex];
        getIndex++;
        if (getIndex == SIZE) {
            getIndex = 0;
        }
        cond_signal(&spaceAvailable, &l);
        lock_release(&l);
        return c;
    }
    

Monitors

  • When locks and condition variables are used together like this, the result is called a monitor :
    • A collection of procedures manipulating a shared data structure.
    • One lock that must be held whenever accessing the shared data (typically each procedure acquires the lock at the very beginning and releases the lock before returning).
    • One or more condition variables used for waiting.
  • There are other synchronization mechanisms besides locks and condition variables. Be sure to read about semaphores in the book or in the Pintos documentation.