Course Calendar

presentation:small Slides, [PDF]
document:small Handout: CS110 Course Information

document:small Handout: CS110 Course Syllabus

book_1:small Reading: Skim S & K Chapter 2

Introductions, course administration and expectations. We will introduce Unix file systesms today, as well.

We'll then discuss a few things as a way of transitioning to multiprocessing: how open file sessions are maintained by the OS on a per-process basis, and how system calls differ from traditional function calls. And time permitting, we'll introduce a new system call that's used to spawn new processes.

This past Monday we introduced fork in the final minutes of lecture. Today we need to work through a collection of etudes so that we master the nuances of how fork works. We'll then introduce related functions, waitpid and execvp, which are used to synchronize multiple processes and transform processes to run a new executable instead of the one it inherited as part of the fork call.

Your first lab will have you discuss the various ways you can exploit a file system design to implement other functions. You'll also get a chance to play with the stat command line utility and learn some new valgrind tricks.

Lab / Discussion 02: Multiprocessing Experimentation
notepad:small Lab 02: Multiprocessing Experimentation

notepad:small Lab 02 Solution

This week we'll investigate the use of fork, execvp, and waitpid to build a command line utility called exargs. We'll then blend in some file descriptor and multiprocessing work to better understand how the two work together, and time permitting, we'll work through some short answer questions to prompt you to think more holistically about how fork and multiprocessing work.

The lab handout includes a collection of laptop exercises to elevate your gdb and valgrind acumen, though the CA who leads your discussion section may opt to focus on the whiteboard problems and leave the laptop experimentation to you.

notepad:small Lab 03 Solution

We'd like you to spend the 80 minutes studying a parallel implementation of mergesort so you understand its architecture and ultimately believe that it works. Time permitting, we'd like you to work through a collection of short answer questions to solidify your understanding of virtual memory and process scheduling.

presentation:small Slides, [PDF]
book_1:small Reading: Continue reading: Bryant & O'Hallaron, Chapters 4, skipping section 4.2. Chapter 4 refers to Chapter 12 of the full textbook.
code:small Code
We will spend some time explaining the various OS components that allow multiple processes to be (seemingly) running at the same time, even when there's just one CPU. We also want to discuss how each process can operate as if it owns all of memory, even though it clearly doesn't. We'll be discussing virtual memory and the process scheduler to advance our understanding of how these things might work.

We'll then move on to our discussion of mutlithreading and begin to work through the lecture examples We've provided today.

notepad:small Lab 04 Solution

We'd like to spend this week's lab reviewing everything about Assignment 3 that made it challenging. By now, you're well aware how difficult multiprocessing and concurrency can be, and we want to take time to review some of the most important concepts. Problem 1 has you revisit those programs and work through why they needed to be written the way they were.

The remaining three questions all deal with multithreading. We think all three questions are instructive, but it's probably more important to work through problems 2 and 3. Problem 4 is a coding question, and that can be managed independently, outside of lab time.

We'll then move on to the dining philosophers simulation to illustrate how a system can arrive at deadlock and forever starve all threads of from CPU time. That'll be our opportunity to introduce the condition variable and the semaphore as a means of preventing deadlock from ever happening.

presentation:small Slides, [PDF]
book_1:small Reading: Finish Reading: Bryant & O'Hallaron, Chapters 4, skipping section 4.2. Chapter 4 refers to Chapter 12 of the full textbook.
code:small Code
We'll continue our discussion of the semaphore by re-implementing it, and then using it to implement our final version of the dining philosophers simulation. We'll then move on to a new collection of examples that relies on the mutex and the semaphore to support a few different inter-thread communication patterns you've not seen prior.

Lab / Discussion 05: rwlocks and Event Barriers
notepad:small Lab 05: rwlocks and Event Barriers

notepad:small Lab 05 Solution

We'll work through the implementation of a rwlock class, which is like a traditional mutex, except that it allows multiple threads to be in a critical region, provided none of them need to change any shared data structures.

Once we work through that, we'll move on to another threading construct, called an Event Barrier, for modeling lifting a barrier for threads to continue.

notepad:small Lab 06: Networking

notepad:small Lab 06 Solution

This week's lab will invest some time understanding more about networking. And then we'll work together to implement a collection of simple servers.

notepad:small Assignment 8 released (not graded)

notepad:small Lab 07 Solution

We'll spend some time talking about aspects of the ThreadPool assignment and the Proxy assignment, specifically how things for the proxy could have been implemented differently.

This is the last week of section!