Here are some materials that will help you review for
the midterm or for a quiz.

1.  If your cache simulator in the homework correctly executes,
    then you can use that to test yourself on the cache concepts.
    If not, you can use the ./cache_sim  in this directory.
    (Use this cache_sim on Khoury login.  This 'cache_sim' executable
     requires certain files on Khoury login that may or may not
     exist on your laptop.)

EXAMPLES:
  Fully associative cache:
    16 cache lines, 8-byte data blocks, and therefore size: 128 bytes
  Try the trace:  0, 4, 6
    M, H, H
    (Data blocks are atomic.  After the first miss, you now have
     addresses 0,1,2,3,4,5,6,7 in the cache.)
  Try the trace:  4, 256, 0
    M, M, H
    There are now two data blocks in the cache.  The address 0
      is already part of the original data block for 4.

  Direct-mapped cache:
    16 cache lines, 8-byte data blocks, and therefore size: 128 bytes
  Try the trace:  0, 4, 6
    M, H, H
    (Data blocks are atomic.  After the first miss, you now have
     addresses 0,1,2,3,4,5,6,7 in the cache.)
  Try the trace:  4, 256, 0
    M, M, M
    There is only one data block in the cache.
    The address 4 placed a data block at index 4, with tag 0.
    The address 256 replaced the data block at index 0, with
      a data block with tag 2.  The previous data block was evicted.
    The address 0 replaced the data block at index 0, with
      a data block with tag 0 again.  (But the original
      data block was evicted during the address 256.)
    is already part of the original data block for 4.

2. Readings in ostep.og, and xv6:
   See: https://course.khoury.northeastern.edu/cs3650/parent/syllabus.pdf
   There are many aspects, but consider the example of fd's to pipes or inodes.
   EXAMPLE QUESTION A:
   Consider questions like:
     // Create in "foo.txt" the content "abcdefghijklmnop"
     int fd1 = open("foo.txt", O_RDONLY);
     int fd2 = open("foo.txt", O_RDONLY);
     int fd3 = dup(fd2);
     read(fd1, buf, 5); read(fd2, buf, 5); read(fd3, buf, 5);
     What will we read if we do one of:
       a. read(fd1, buf, 3);
       b. read(fd2, buf, 3);
       c. read(fd3, buf, 3);

     // How many 'struct file' (open files) now exist in the open file table?

     // Consider the ref field (reference count) for 'struct file'.
     // What is the value of 'ref' for each of the open files?

   EXAMPLE QUESTION B:
  Suppose a parent process calls 'int pipefd[2]; pipe(pipefd)' and then 'fork()'.
  Suppose no process writes into the write-end of the pipe.
  Suppose the child then closes the write-end of the pipe.
  Finally, the child reads from the pipe and it hangs (the 'read()' does not finish).
  Why does the child hang?

3. EXTERNAL SLIDES:
   ostep.org and xv6:
    fd, open file, v-node (inode):
    https://stackoverflow.com/questions/5256599/what-are-file-descriptors-explained-in-simple-terms#answer-17741176
    Section: "Hear it from the Horse's Mouth : APUE (Richard Stevens)."

   CPU cache (fully associative and direct-mapped):
    from the University of Washington:
      https://courses.cs.washington.edu/courses/cse378/09wi/lectures/lec15.pdf
      [ Try this first.  It's shorter. ]
    An alternative (longer) description is at:
      Direct-mapped cache:
        https://www.cs.emory.edu/~cheung/Courses/355/Syllabus/8-cache/dm.html
      Fully asociative cache:
        https://www.cs.emory.edu/~cheung/Courses/355/Syllabus/8-cache/assoc.html   

    Overview related to ostep.org: open/read/write/dup/close; fork/execvp/waitpid; pipe
      OVERVIEW:  https://web.stanford.edu/class/cs110/
      https://slides.com/troccoli/cs110-win2122-lecture-5/fullscreen
        "CS110 Topic 1: How can we design filesystems to store and
         manipulate files on disk, and how can we interact with the
         filesystem in our programs?"
      https://slides.com/troccoli/cs110-win2122-lecture-7/fullscreen
        "CS110 Topic 2: How can our program create and interact with other programs?"
      https://slides.com/troccoli/cs110-win2122-lecture-8/fullscreen
        "CS110 Lecture 8: Pipes and Interprocess Communication, Part 1"
      https://slides.com/troccoli/cs110-win2122-lecture-9/fullscreen
        "CS110 Lecture 9: Pipes and Interprocess Communication, Part 2"
        ( fork->change fd->execvp  (redirect I/O, etc.; many illustrations )
      https://slides.com/troccoli/cs110-win2122-lecture-10/fullscreen
        "CS110 Lecture 10: Signals, Part 1"  (But our course did not emphasize signals)

REVIEW FOR FINAL:
      FOR THIS COURSE, THERE IS AN EXTENSIVE REVIEW HERE ON MULTITHREADING:
        https://course.khoury.northeastern.edu/cs3650/parent/thread-synch/

      THIS COURSE USES C++ FOR MULTITHREADING.  YOU WILL NEED TO TRANSLATE
        TO OUR MUCH SIMPLER VERSION IN C.  OUR ostep.org USES C (not C++)
      https://slides.com/troccoli/cs110-win2122-lecture-13/fullscreen
        "CS110 Lecture 13: Introduction to Multithreading"
      https://slides.com/troccoli/cs110-win2122-lecture-14/fullscreen
        "CS110 Lecture 14: Threads and Mutexes"

      ADVANCED (only for the curious; not directly related to our course):
        https://slides.com/troccoli/cs110-win2122-lecture-15/fullscreen
          "CS110 Lecture 15: Mutexes and Condition Variables"
        https://slides.com/troccoli/cs110-win2122-lecture-19/fullscreen
          "CS110 Lecture 19: Thread Pool and Ice Cream Store"