Errata, 6.033 class notes

Here are corrections for some typographical errors and other minor problems in the currently distributed chapters of the 6.033 notes, release 1.16. Most of these errors have been reported by industrious readers (many thanks!). If you find others, please send an e-mail message describing them to:
<Saltzer@mit.edu> and <kaashoek@mit.edu>

Posted 18 April 2003: Chapter 10, page 10-84

Near the bottom of the page, the second argument to Seal should be Key rather than $key.

Posted 16 April 2003: Chapter 7, page 7-21

In equation 7-8, the coefficient of the exponential should be 1, rather than 1/MTTF.

Posted 13 March 2003: Chapter 4, page 4-68

In the procedure integrate_paths

Replace the if/else conditional with

  if(my_addr is not in new_path) {;            # Skip paths I'm in.
       if (my_vector[d_addr] == NULL)          # Is it a new destination?
            my_vector[d_addr] = new_path;      # Yes, add this one.
       else                                    # Not new; if better, use it.
            my_vector[d_addr] = choose_path(new_path, my_vector[d_addr]);
  }

Posted 3 March 2003: Chapter 3, page 3-16

In the program fragment

Change (pageTable[page].present) to (!pageTable[page].present)

Posted 1 March 2003: Chapter 3, page 3-20

In the blank space in the middle of the last complete paragraph, insert the following formula:

AverageAccessTime = S_primary
S_primary + S_secondary × T_primary + S_secondary
S_primary + S_secondary × T_secondary

Posted 25 February 2003:

Chapter 3, page 3-16.

In the line that introduces the pseudocode, change "virtual manager" to "virtual memory manager"

In the pseudocode fragment, replace the first two lines with

    page = virtual[0:19];  // bits are numbered from left to right.
    offset = virtual[20:31];

Posted 24 February 2003:

Chapter 2, page 2-15, bottom paragraph, third line.

change "consumer will return" to "provider will return"

Chapter 2, page 2-59, bottom paragraph, second line.

change "virtual virtual" to "virtual"

Posted 19 February 2003:

Chapter 2, page 2-28, second complete paragraph, first line:

change "simply" to "simplify"

Chapter 2, page 2-57, first line:

change "for often" to "for how often"

Chapter 2, page 2-68, first line:

change "A through C" to "1, 2, and 3"

Chapter 2, page 2-68, first line after the pseudocode fragment:

change "A through C" to "1, 2, and 3"

Posted 17 February 2003, with a correction later the same day:

Chapter 2, page 2-30:

In line 2, change "contatenation" to "concatenation".

In the pseudocode fragment, replace the first two lines with

    page = virtual[0:19];  // bits are numbered from left to right.
    offset = virtual[20:31];

In the paragraph that follows that pseudocode,
replace "top log-of-the page-size bits, 12 bits in our example," with "leftmost 20 bits"
and
replace "offset, 20 bits" with "offset, 12 bits"

Posted 16 February 2003:

Chapter 2, page 2-73, sidebar on Achieving atomicity...:

In the program TSL, change the statement flag[me] = FALSE; to read flag[me] <- FALSE;

In the program TSL, following the statement L <- TRUE; insert the statement flag[me] <- FALSE;

Replace the paragraph that begins with "If two threads..." with the following:

If two threads A and B call TSL at the same time, either A or B may acquire L, or both may retry, depending on how the shared memory system orders the accesses of A and B to the flag[i] array. There are three cases:

A sets flag[A], calls is_flagged and reads flags at least as far as flag[B] before B sets flag[B]. In this case A sees no other flags set and proceeds to acquire L; B discovers A's flag and tries again. On its next try B encounters no flags, but by the time B writes TRUE to L, L will already be set to TRUE, so B's write will have no effect.
B sets flag[B], calls is_flagged and reads flags at least as far as flag[A] before A sets flag[A]. In this case B sees no other flags set and proceeds to acquire L; A discovers B's flag and tries again. On its next try A encounters no flags, but by the time A writes TRUE to L, L will already be set to TRUE, so A's write will have no effect.
A sets flag[A] and B sets flag[B] before either of them gets far enough through is_flagged to discover that the other has set its flag[i]. In this case both A and B reset their own flag[i] entries, and try again. On the retry, all three cases are again possible.

Posted 12 February 2003:

Chapter 2, page 2-14, figure 2-4: Replace the code with

     100: store 112, (sp)
          sub 4, sp
          jmp 200
          print r0     // print return value
          add 4, sp    // pop return address
     200: load (clock), r0
          load (sp), r1
          jmp (r1)