Architectural Support

File system

Journaling File Systems

Lock Performance

Log-structured Sile Systems

Memory Consistency

OS Functionality and Structure

RAID (Redundant Array of Inexpensive Disks)

Readers/Writers Locks

Storage

Synchronization (computer science)

Threads & Processes

Windows Memory Management

ZFS (Zettabyte File System)

CSE 451 Operating Systems University of Washington Spring 2022 This course focuses on practical implementation of operating system concepts using the 'xk' OS. Students will learn about system software and get acquainted with the source code of operating systems through team-based labs. Key concepts covered include threads & processes, memory consistency, file systems, RAID, ZFS, and others. CSE 451 is an undergraduate course on operating systems. During the course you will complete several labs, working in teams of two. Each lab will add a new feature to a primitive operating system called `xk`. At the end of this class you will be able to find your way around the source code of most operating systems, and more generally, be comfortable with systems software.   - [Operating Systems: Principles and Practice](http://ospp.cs.washington.edu/) (2nd Edition), by Tom Anderson and Mike Dahlin.
- [xv6: a simple, Unix-like teaching operating system](http://pdos.csail.mit.edu/6.828/2014/xv6/book-rev8.pdf), by Russ Cox, Frans Kaashoek, and Robert Morris.
Exams

CSE 451 Operating Systems

Operating System is the bridge between computer hardware and software. It is the key to understand how computers represent data, execute programs, and control peripherals. Common subtopics includes System Programming, Hardware / Software Interface etc.

Operating Systems

Computer Science

CS240 Advanced Topics in Operating Systems Stanford University Winter 2023 This is an advanced level course delving into in-depth topics in operating systems. The course revolves around the study of classical and recent research papers, with focuses on virtual memory management, synchronization and communication, file systems, and OS security among others. Its intent is to promote active discussions and deep comprehension of the material. Students will study advanced operating system topics and be exposed to recent developments in operating systems research. This course involves readings and lectures on classic and new papers. Topics include virtual memory management, synchronization and communication, file systems, protection and security, operating system structure and extension techniques, fault tolerance, and history and experience of systems programming. ## Course Outline

This course makes no attempt to cover all the interesting topics in operating systems. Instead, we will cover a few topics in depth.

The course is divided into the following general topic areas.

- Concurrent Execution: threads, event systems, async/sync I/O, etc.
- Memory Management: virtual memory, NUMA machines, memory allocators, etc.
- Scalability: multicore processing, locking, lock-free data structures, etc.
- File Systems: file system interfaces, networked file systems, etc.
- OS Architecture: the structure and design of an operating system
- Virtualization: machine virtualization, binary instrumentation, etc.
- Security: data security and integrity, authentication, authorization, etc.
- History/Experience: historically important papers and experience reports The prerequisite for this class is CS140 or the equivalent. It is necessary to have this background before taking the class as we’ll read a lot papers quickly without much time for catching up on the basics. The course assumes an understanding of topics in operating systems such as synchronization, virtual memory management, scheduling, and file systems. ## Reading List

There is no textbook for this course. The course is based on a collection of journal and conference papers that describe the history and state of the art in operating systems. Lectures will be live Tuesday and Thursday, 3:15-4:45 PM in Huang 18. They will also be recorded and available on Canvas.

You are required to read the papers listed in each class slot **before** lecture.
The papers are subject to change, and information about the labs will be added later in the quarter.

## Course Organization and Workload

The course consists of prerecorded lectures, readings, reading questions, and two exams, and at least two labs. There is a also a discussion section/office hours during the normal class period. It is optional but you are encouraged to come and discuss the papers. The two most important things to know about the class: (1) the main goal is to have interesting discussions (either in discussion section or on google groups) and (2) we recommend you read each paper at least two times: once very carefully, then once more, focusing on the hard parts. For any artifact the paper describes you should draw a picture. This should all be done more than a day in advance so that it sinks in.

Most of the work in this course consists of reading journal and conference papers. We will cover one paper for each class meeting. This class will be primarily discussion based rather than organized around lectures. Active discussion will (hopefully) give you a non-trivial understanding of the material. The only way this approach can work is if you read the papers carefully. Class time will not be used to rehash the material in the papers. Instead, it will be used to highlight the important points and discuss some of the more interesting features. There will be as much as 10 to 15 hours of reading per week. Do not take this course unless you are willing and able to do a lot of reading.

CS240 Advanced Topics in Operating Systems

CS 140: Operating Systems Stanford University Spring 2020 This course provides an in-depth understanding of the basic facilities provided by modern operating systems. It's structured into three major sections: concurrency, memory management, and file systems, followed by some smaller topics like virtual machines. The class includes one problem set and four programming projects based on the Pintos kernel, requiring a significant commitment of time. This class introduces the basic facilities provided by modern operating systems. The course divides into three major sections. The first part of the course discusses concurrency: how to manage multiple tasks that execute at the same time and share resources. Topics in this section include processes and threads, context switching, synchronization, scheduling, and deadlock. The second part of the course addresses the problem of memory management; it will cover topics such as linking, dynamic memory allocation, dynamic address translation, virtual memory, and demand paging. The third major part of the course concerns file systems, including topics such as storage devices, disk management and scheduling, directories, protection, and crash recovery. After these three major topics, the class will conclude with a few smaller topics such as virtual machines.

The class work consists of one problem set and a series of four programming projects based on the Pintos kernel. You will learn a lot from these projects, but be prepared to spend a significant amount of time working on them.   There is no required textbook for this class: the material of the course is defined by the lectures and does not exactly correspond to any existing book. However, I recommend the following book if you would like an additional source of material to supplement lectures:

- [Operating Systems: Principles and Practice (2nd Edition)](http://www.amazon.com/Operating-Systems-Principles-Thomas-Anderson/dp/0985673524/ref=pd_sim_14_2?ie=UTF8&dpID=51SFTQvZ7zL&dpSrc=sims&preST=_AC_UL160_SR123%2C160_&refRID=0ZR0KTC2DWEZCFFVAR26), by Thomas Anderson and Michael Dahlin.

Each page of lecture notes lists related readings in this book at the front of the notes page. Most students find that the material from lecture is sufficient for their course needs, so I recommend that you start the course without the book and only purchase the book if you are having difficulties understanding the lectures.

CS 140: Operating Systems

CSE 333 Systems Programming University of Washington Summer 2022 This course provides an understanding of systems in computing, focusing on operating systems, networking, and C/C++ languages. Students learn about low-level data representation, memory management, system interactions, and efficient programming workflows. It delves into C++ idioms, network protocols, and concurrency. Prior knowledge of C programming and Linux tools is required. Systems Programming is the exploration of the composition and interface of systems in computing looking through the lens of operating systems, networking, and C/C++ languages. Through peeling levels of abstraction, students will view practices of low-level data representation (e.g. C, C++); explicit memory management; interacting with operating-system services; and cache-aware programming. Course Learning objectives are the goals that are set out for you to accomplish in this course:

- Understand system theory of how a system interacts with its environment and controlling its input and output (feedback loops, input and output, deterioration, computation)
- Unravel layers of abstraction found within systems
- Describe multiple systems throughout the computing space (e.g. HTTP, Operating Systems, Threading, and Makefiles)
- Interpret and build an efficient workflow for programming in larger sized code bases
- Debug substantial C/C++ programs using debugging tools (GDB and Valgrind) - [CSE351 (The Hardware/Software Interface)](http://www.cs.washington.edu/education/courses/cse351): CSE 351 provides students with rudimentary knowledge of C programming; the ability to write, run, and debug programs; familiarity with Linux and the use of Linux compilation, editing, and debugging tools; a solid mental model of the relationship between high-level code (C) and assembly-level compiled code.
- [CSE 143 (Intro Programming II)](http://www.cs.washington.edu/education/courses/cse143): CSE 143 is not a direct prerequisite (CSE 351 prerequisite), but some of its topics are beneficial to review for CSE 333. This includes classes, inheritance, good style practices, and simple data structures such as linked lists, trees, hash tables, and queues. Further knowledge of Java and these data structures is not required, but could be helpful! ### Textbooks

There are no strictly required texts for this course. Most people will find it useful to have both a C and a C++ reference; suggestions are given below. The C++ Primer is strongly recommended as C++ is a big, complex language and it is hard to understand how it all fits together from just Google and Stack Overflow snippets and folklore.

#### Strongly Recommended:

C++ Primer (5th Edition), Lippman, Lajoie & Moo. ISBN 0-321-71411-3.

#### Suggested:

- [*C Programming Language (2nd Edition)*](http://www.amazon.com/Programming-Language-2nd-Brian-Kernighan/dp/0131103628/), Kernighan & Ritchie. ISBN 0-13-110362-8.
    - The definitive book on C from the people who created it. You will want to use an online reference for information about the latest libraries, but every serious programmer should study this book.
- [*Computer Systems: A Programmer's Perspective (3rd Edition)*](http://csapp.cs.cmu.edu/3e/home.html), Bryant & O'Hallaron, ISBN 0-13-409266-X.
    - Useful review of CSE 351 and background for many additional topics covered more extensively in CSE333.
- [*Effective C++: 55 Specific Ways to Improve Your Programs and Designs (3rd Edition)*](http://www.amazon.com/Effective-Specific-Improve-Programs-Designs/dp/tags-on-product/0321334876), Scott Meyers. ISBN 0321334879.
- [*Effective Modern C++: 42 Specific Ways to Improve Your Use of C++11 and C++14*](http://www.amazon.com/Effective-Modern-Specific-Ways-Improve/dp/1491903996), Scott Meyers. ISBN 1491903996.


### Proposed Topic List

- C Programming and idioms (Memory Management, cstdio, error handling, and structs)
- System Management Tools (Makefiles, Header Guards, GDB, and Valgrind)
- System Interfacing with Operating Systems (POSIX)
- C++ Programming and idioms (namespaces, templates, STL, smart pointers)
- C++ Classes and Inheritance (Classes, operator overloading, OOP)
- Network Programming and Protocols (POSIX, HTTP)
- Concurrency (pthreads)

CSE 333 Systems Programming

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

CS 140E: embedded operating systems Stanford University Winter 2023 This course focuses on providing an introduction to operating systems with a specific emphasis on embedded systems, interacting with hardware, and verification. Students will have hands-on experience through labs and will build their own simple, clean operating system for an ARM-based Raspberry Pi. The course offers opportunities to work with real hardware and primary-source documents, encouraging a deeper understanding of computation on real hardware. Tl;dr:

- It's a lab class, so jump right to the labs.
- If you find the material useful, please consider donating --- all donated funds go entirely to buy food and equipment for the 2023 lab students.

CS140E is an introductory operating systems course. It roughly covers the same high-level material as [CS 212](https://cs212.stanford.edu/) (formerly CS 140), but with a focus on embedded systems, interacting directly with hardware, and verification. Both courses cover concepts such as virtual memory, filesystems, networking, and scheduling, but take different approaches to doing so. By the end of 140E, you will have (hopefully) built your own simple, clean operating system for the widely-used, [ARM-based Raspberry Pi](https://www.raspberrypi.org/). ## Details

140e is a lab-based class with no explicit lectures. We will do two three-to-five hour labs each week. You should be able to complete almost all of the lab in one sitting. There will be several homeworks, that act as mini-capstone projects tying together the preceding labs. Since we are breaking new ground by having the class virtual only, we may add an additional discussion section to help people that need it.

By the end of the class you will have built your own simple, clean OS for the widely-used, ARM-based raspberry pi --- including interrupts, threads, virtual memory, and a simple file system. Your OS should serve as a good base for interesting, real, sensor-based / embedded projects.

We try to work directly with primary-sources (the Broadcom and ARM6 manuals, various datasheets) since learning to understand such prose is one of the super-powers of good systems hackers. It will also give you the tools to go off on your own after the course and fearlessly build sensor-based devices using only their datasheets.

This course differs from most OS courses in that it uses real hardware instead of a fake simulator, and almost all of the code will be written by you.

After this quarter, you'll know/enact many cool things your peers do not. You will also have a too-rare concrete understanding of how computation works on real hardware. This understanding will serve you in many other contexts. For what it is worth, everything you build will be stuff we found personally useful. There will be zero (intentional) busy-work.

### Who should take this class.

The goal of the class is to help students who are very motivated and/or very good to go far, quickly. We focus on building small, simple but real OS subsystems --- threading, virtual memory, etc --- that can be used to build many other things.

You should take this class if:

You write code well OR (you don't yet write code well AND have a lot of time to devote to the class);

AND you find these systems topics interesting.

The people that found the class valuable in the past were entirely drawn from this demographic. I would say that if you struggle building stuff and are not already interested in the topic, then it's probably better to take a different class. I would particularly advise against taking this class if you were looking for an easier way to satisfy a cs140 requirement.

It always helps, but you do not need any background in hardware or OS stuff to do well in the class. In fact, you don't even need to have been trained in CS: one of the best students from last year was a physics PhD student with fairly minimal background in coding, so we've had fantastic luck with non-CS folks :) With that said, the less background you have, the more motivation you might need.

By the end of the class you'll have learned how to comfortably do many things that may well seem like superpowers and could easily serve you well for the next few decades.

If you have background in the "embedded" space, it's worth taking b/c you'll learn a bunch of useful but not widely-known tricks (I'll pay for your supplies and a pitcher of beer if this claim turns out to be false!)

It's also super fun. The code you'll write can be used to as a basis for building many interesting systems.

As one measure: Last year, I taught two extra follow-on classes (cs240lx and cs340lx) ``for free'' because of all the interesting things that came up from cs140e. In addition, it's caused me to write more code than I have since grad school. At my age, that's an unusual result :)

### What this class is not

A quick skim might falsely pattern-match on a couple of things:

1. cs140e is NOT an easier version of cs140. In fact, it can be quite a bit harder, since we work with raw hardware, and primarily use raw datasheets and ARMv6 architecture manuals rather than pre-digested text books or simulators.

    I'd say about 1/3 of the teaching evals from last year explicitly stated "do not take cs140e as an easier cs140".

    On the plus side, this approach is the adult way to do things, so you will be better prepared after the class for operating autonomously in the real world without safety nets or help. Everything you'll build will be stuff we personally found useful. There is no (intentional) busywork.

1. Similarly, while we do use a raspberry pi for this class, and there are tons of blog posts/instructables/classes for novices showing how to use the r/pi to do simple things, this class is not that.

    You'll be writing virtual memory systems, SD card file systems, threads, i2c device drivers on raw hardware rather than cut-and-pasting some python on a library to blinky a light.

    We use the r/pi because its fairly cheap, holds up to electrical mistakes pretty well, runs a legit processor with legit hardware and is small enough to carry around easily.

With that said, I set aside the entire quarter to work on this course, so am happy to help people that need it --- some of the biggest success stories last year were from students that had an initially large gap between their understanding and the topic but started to really "get it" after some weeks of struggle.
 Note that nothing here is strictly required, as long as you're willing to learn it on-the-fly. However, the course material is designed assuming most students will have the following:

- CS 110 or CS 111
- Some knowledge of C and UNIX

No previous experience with operating systems, raspberry pis, or embedded programming is required.

If you want to take the course but are worried about any of these, talk to us! We can point you to resources to help catch up, should you need them. ## Why should I take CS 140E?

CS 140E is unlike many other Stanford CS classes in one major way: it isn't
simplified for a classroom setting. The hardware you're interacting with is the
same hardware the Linux kernel interacts with. When there's a bug in the
hardware, we have to work around it. When the documents are wrong, we have to
find the errors.

- If the freedom to design any embedded system you can imagine excites you, CS
  140E is one of the only places you can do it in a classroom setting.
- If you've never programmed in a completely baremetal system before, CS 140E
  will give you a taste of what it's like.
- If you want to get better at debugging, CS 140E will give you plenty of
  opportunities to do so.
- If you want to get better at real-world systems programming, CS 140E gives
  you the chance to work on raw hardware and documents, rather than
  a simplified simulation.

## Who should take CS 140E?

This is a tricky question, since there's no one particular set of factors which
is correlated with success in this class. There's a subset of people who love
it, and a subset who don't.

In general, the people who enjoy CS 140E tend to fit the following:

1.  One of:
    - You write code well
    - You want to learn to write code well, and have a lot of time to devote to
      the class
2.  You find systems topics interesting

However, since the class is fairly unusual in a lot of ways, it also tends to
appeal to people from atypical backgrounds. Some of our most successful
students in the past have been from non-CS majors. As mentioned below, we don't
have any hard prerequisites; this is specifically because we want the course to
be accessible to anyone who's interested in learning the material, regardless
of background.

## What are the differences between CS 212 and CS 140E?

CS 140E can count as a substitute for CS 212 (including for PhD students who
need to fulfill an OS breadth requirement). It is approximately 80% of the
_coding_ work of CS 212, but will probably require a more strenuous type of
thinking at some points. The main differences are:

1.  We work with raw hardware (the Raspberry Pi A+), not a simulator.
2.  Most of the reading involves primary hardware documents, rather than
    high-level discussions.
3.  Most of the code at the end will (hopefully) be written by you, rather than
    you having to deal with a large, complicated codebase.
4.  We focus much more on checking and somewhat-verifying your code,
    rather than passing an autograder.

With that said, you are strongly encouraged to sit in on the CS 212 lectures if
you can; Mazières is incredibly knowledgable, and will serve as a great
counterpoint to what we do.

The flip side of working with raw hardware and documentation is that this class
is much less structured than other CS classes you might have taken before. If
you're the kind of person who loves figuring things out and exploring, great!
If you prefer more structured assignments and lectures, you might want to
consider CS 212 instead.

CSE 451 Operating Systems

Overview

Prerequisites

Learning objectives

Textbooks and other notes

Other courses in Operating Systems

CS240 Advanced Topics in Operating Systems

CS 140: Operating Systems

CSE 333 Systems Programming

CS 111 Operating Systems Principles

CS 140E: embedded operating systems

Courseware availability

Covered concepts