Multithreading Patterns

System Calls

Multiprocessing

execvp

Interprocess Communication

Virtual memory

Thread (computing)

Mutexes (Mutual exclusion)

Semaphores

Thread Pools

Parallel Compilation

Clients

Networking

API (Application Programming Interface)

MapReduce

Filesystems

File Descriptors

waitpid

Pipeline (Unix)

Signals

Multithreading

Race condition

Condition variables

Read-Write Locks

Networks

Servers

HTTP

Networking Functions

CS 110: Principles of Computer Systems Stanford University Winter 2022 CS 110 delves into advanced computer systems and program construction, focusing on designing large systems, software that spans multiple machines, and parallel computing. This course builds upon CS107 and requires good knowledge of C, C++, Unix, GDB, Valgrind, and Make. It covers Linux filesystems, multiprocessing, threading, networking, and more. CS107 took you behind the scenes:

- how things work inside C++/Python/Java, and how your programs map onto the components of computer systems
- understanding of program behavior and execution
 
CS110 uses this as a foundation to build complex programs that maximally take advantage of the hardware and operating system software available to us:

- How can we understand the designs and tradeoffs of large systems?
- How can we write software that spans multiple machines?
- How can we write software that runs tasks in parallel on a single machine? ### Course Topics Overview

1. **Overview of Linux Filesystems** - How can we design filesystems to store and manipulate files on disk?
1. **Multiprocessing and Exceptional Control Flow** - How can our program create and interact with other programs?
1. **Threading and Concurrency** - How can a single instance of our program perform multiple coordinated tasks at the same time?
1. **Networking and Distributed Computing** - How can we write programs that communicate over a network with other programs, and tackle large tasks using many machines?
1. **Additional Topics**: MapReduce, Caching, and Non-Blocking I/O **CS107 or equivalent -**

- Each of you should know C and C++ reasonably well so that you can...
    - write moderately complex programs (e.g. pointers, **malloc/realloc/free**, C strings, C++ classes, methods, references, templates, **new/delete**)
    - read and understand portions of large code bases
    - trace memory diagrams and always win!
- Each of you should be ﬂuent with **Unix, GDB, Valgrind**, and **Make** to the extent they're covered in CS107 or its equivalent.

The first assignment is meant to give you a sense of the scope of CS110 programs and refresh your memory on relevant prerequisites.  If you feel ok about it, you're all set! Second half of CS107 Textbook: *Computer Systems: A Programmer's Perspective by Bryant & O'Hallaron, 3rd Edition*

- Can purchase full copy, or Stanford Bookstore custom edition with just CS110 chapters
 
*Principles of Computer System Design: An Introduction* by Jerome H. Saltzer and M. Frans Kaashoek

- Free Stanford online access [here](https://www.sciencedirect.com/book/9780123749574/principles-of-computer-system-design)​ (also linked on course homepage)
- Fewer readings from this book vs. first one
- You're welcome to buy a physical copy if you'd like

CS 110: Principles of Computer Systems

Computer Systems

Concurrency pattern

Multithreading Patterns

1 courses cover this concept

CS 110: Principles of Computer Systems