Lock Implementation

Concurrency

Scheduling (computing)

Dynamic Storage Management

Magnetic Disks

Links

Virtual Machine Monitors

Threads & Processes

Lock (computer science)

Linkers

Virtual memory

File system

File System Crash Recovery

Dispatching

Condition variables

Deadlock

Dynamic Linking

Demand Paging

Directories

Flash Memory

CS 111 Operating Systems Principles Stanford University Autumn 2022 An introductory course to operating systems, CS 111 builds upon programming experience to explore how operating systems function. The course provides an understanding of OS design challenges, such as filesystems, system calls, concurrency, virtual memory, demand paging, and others. Knowledge in C/C++ and Unix/Linux environment is prerequisite. CS111 is Stanford's introductory operating systems course. The CS106 courses provide you with a solid foundation in programming methodology and abstractions, and CS107 builds up and expands your breadth and depth of programming experience and techniques, working from the C programming language down to the microprocessor to de-mystify the machine. CS111 leverages this programming experience to introduce operating systems and how they work. With an understanding of both how to leverage operating system functionality in your own programs as well as how operating systems manage tasks behind the scenes, you will have a better understanding of how operating systems work, the kinds of design challenges present in operating systems and other large systems, and key computing ideas such as virtualization that are applicable in many different areas. Topics covered include: filesystems, system calls, concurrency, multiprocessing, multithreading, race conditions, synchronization primitives, virtual memory, demand paging and operating system design challenges.  The prerequisite for CS111 is CS107 (or equivalent). You should have practical C/C++ skills and be able to write programs with complex use of memory and pointers and dynamic memory allocation (`malloc`/`realloc`/`free`/`new`/`delete`). You should understand C++ classes, methods, and be able to work with appropriate data structures (arrays, maps, etc.) and standard algorithms (searching, sorting, hashing). (There are C++ features you're not expected to know, but you should be comfortable picking those features up and consulting references as needed). You should be familiar with programming in a Unix/Linux environment using tools such as `make`, `gcc/g++`, `valgrind`, `gdb`, etc. and have a working understanding of the basics of computer architecture (x86-64 as it’s taught in CS107, or exposure to some other architecture and the ability to pick up x86-64 as we reference it). Come talk with us if you need help determining the right placement for you. ### CS111A

CS111A, also called Pathfinders (or ACE), is a supplementary instruction program that meets for a weekly section and holds Pathfinders-specific review sessions. CS111A is application-only; CS111A is done in addition to all the normal requirements for CS111. You will receive an extra unit of course credit for the work you do in this program. Enrollment in CS111A is by application, and you can find more information at this link: [click here](https://engineering.stanford.edu/students-academics/equity-and-inclusion-initiatives/undergraduate-programs/additional-calculus). Once enrollment decisions are made, students who are accepted will then be given a permission number to enroll in CS111A on Axess. If you have questions about CS111A, please email the ACE CA (contact information listed on the course homepage).

### Textbook

There is no required textbook for CS111: the material of the course is defined by the lectures and does not exactly correspond to any existing book. However, we recommend the following book if you would like an additional source of material to supplement lectures:

*Operating Systems: Principles and Practice (2nd Edition), by Thomas Anderson and Michael Dahlin.*

Each lecture lists related readings in this book on the first slide, where applicable. Most students find that the material from lecture is sufficient for their course needs, so we recommend that you start the course without the book and only purchase the book if you decide you would like additional material and explanations beyond what is in lecture.

CS 111 Operating Systems Principles

Operating Systems

Address Space

Atomic instructions

Monitors

Starvation

Address translation

Page table

TLB (Translation Lookaside Buffer)

General I/O

Queueing Theory

Reliability

Distributed Decision Making

Remote Procedure Call (RPC)

Key-Value Stores

Quantum Computing

Fork

Sockets

Synchronization (computer science)

Semaphores

Computer memory

Segments

Caching

Demand Paging Policies

Performance

Buffering

End-to-End Arguments

TCP/IP

NFS & AFS

DataCapsules

System Calls

Device Drivers

Mutual Exclusion

Readers/Writers

Paging

Storage Devices

Filesystem Design

Transactions

Networking

Distributed Storage

Chord

Inter-Process Communication (IPC)

Input/output

CS 162: Operating Systems and Systems Programming UC Berkeley Fall 2022 This course introduces operating systems design and related concepts. It covers topics like memory allocation, file systems, basic networking, transactions, and security. The course requires foundational knowledge in data structures, assembly language, C programming, and debugging. It aims to improve students' skills in debugging large programs and computational problem solving. The purpose of this course is to teach the design of operating systems and operating systems concepts that appear in other computer systems. Topics we will cover include concepts of operating systems, systems programming, networked and distributed systems, and storage systems, including multiple-program systems (processes, interprocess communication, and synchronization), memory allocation (segmentation, paging), resource allocation and scheduling, file systems, basic networking (sockets, layering, APIs, reliability), transactions, security, and privacy.  CS 61A, CS 61B, CS 61C, and CS 70, or equivalent courses. This means that you understand:

- Data structures: arrays, linked lists, binary trees, and hashing
- Assembly language programming
- The C programming language
- Debugging C using GDB
- CPU caches and memory hierarchy
- Virtual memory as covered in CS 61C
- CPU pipelines and basic digital logic design
- Basic knowledge of random variables and probability distributions as covered in CS 70


The TAs will spend a small amount of time reviewing some of the material you are less likely to remember. We will assume that you either know the material that is supposed to be covered in those courses, or that you are willing to learn the material as necessary. We will not spend time in lecture covering any of this material. **Perhaps more important than formal prequisites, however, is experience and maturity with debugging large programs, designing and implementing useful abstractions, and computational problem solving in general. This class will exercise your skills in these areas.**

If you feel that you would benefit from additional review of these prerequisites, we recommend using the following resources:

1. For a good review of probability as you’ll need it in this class, read through CS 70 Lecture Notes [15](https://inst.eecs.berkeley.edu/~cs70/sp14/notes/n15.pdf), [16](https://inst.eecs.berkeley.edu/~cs70/sp14/notes/n16.pdf), [17](https://inst.eecs.berkeley.edu/~cs70/sp14/notes/n17.pdf), [18](https://inst.eecs.berkeley.edu/~cs70/sp14/notes/n18.pdf), and [19](https://inst.eecs.berkeley.edu/~cs70/sp14/notes/n19.pdf).

1. Hennessy, John L. and Patterson, David A. *Computer Architecture: A Quantitative Approach*. 5th edition. **Although the main content of this book goes far more in-depth into computer architecture than you are expected to know for this class, the appendices provide an excellent overview of some of the prerequisites. Focus specifically on the sections below:**

- 2.1 and B.1 - B.4 (you can skip the sixth optimization in B.3) review caching, virtual memory, and memory hierarchies.
- C.1 - C.2 review CPU pipelines at the level of CS 61C. We are using the textbook “Operating Systems: Principles and Practice” by Anderson and Dahlin (A&D). The reading from this textbook is **strongly recommended**. There will be some additional readings that are not from this textbook that are freely available online. These will be linked on the course website in the "Readings" column for your viewing.

#### Strongly Recommended
[Operating Systems: Principles and Practice (2nd Edition)](http://ospp.cs.washington.edu/)
#### Recommended
[Operating Systems: Three Easy Pieces](http://pages.cs.wisc.edu/~remzi/OSTEP/)
#### Supplemental
[Linux Kernel Development (3rd Edition)](http://www.amazon.com/Linux-Kernel-Development-3rd-Edition/dp/0672329468)

CS 162: Operating Systems and Systems Programming

Lock Implementation

2 courses cover this concept

CS 111 Operating Systems Principles

CS 162: Operating Systems and Systems Programming