Lecture 010

Error

Three Kinds of Errors Solution:

1. solve the error (doubling the memory)
2. report the error (return -1)
3. prevent the error to damage the system (reboot)
4. redesign your system

Paradise Lost

There are issues when you write worker threads:

1. When queue is temporarily empty, it doesn't mean it will be empty forever
2. cond_wait() might not return to the same thread

mutex_lock(&m);
if (out_of_work) {
  w = (item_t*) NULL;
} else {
  if (!(w = (item_t*) dequeue(q))) {
    cond_wait(cvar, &lock);
    w = (item_t*) dequeue(q);
  }
}
mutex_unlock(&m);
return w;

Above code is wrong. The following code is more correct, but still wrong:

mutex_lock(&m);
if (out_of_work) {
  w = (item_t*) NULL;
} else {
  // change 'if' to 'while'
  while (!(w = (item_t*) dequeue(q))) {
    cond_wait(cvar, &lock);
  }
}
mutex_unlock(&m);
return w;

This is not a standard "time of check to time of use" (TOCTTOU) bug.

Yield

The below content assumes "user thread" (single process, no parallism)

To implement yield():

• save general purpose registers, save %ebp, %esp, (we don't need to save %eip since it will be correct once we jump back)

• restore to "switch to" thread's registers

Yield between process: INT 50 syscall

• since they don't share memory, we need to make sure they don't see each other's secret

• so kernel (instead of user code) is in charge of saving and restoring registers

  • stack switch from user to kernel
  • top-of-kernel-stack specified by %esp0
  • trap frame: stuff we need to save for the process (e.g., %cs & %eip, %eflags, %ss & %esp, etc.)

Process switch is more than conditional variable: it execute when

• yield()

• message passing from P1 to P2

• P1 blocked by disk I/O

• CPU preemption by clock interrupt

I/O Example:

• P1: read() -> cond_wait() -> process_switch(P2)

• P2: ... -> interrupt into kernel -> cond_signal()

• (at least two things can be designed here)

  • cond_signal() mark P1 runnable, interrupt handler launched by P2 returns to P2 program
  • cond_signal() calls process_switch(P1)... although this is morally correct, P2 interrupt handler WILL EXECUTE FOR A LONG TIME, WHICH IS BAD