It seems that your browser is not supported by our application.

Introduction to CPU Scheduling

Quiz on Direct Execution

Virtualization: CPU Scheduling

12 Lessons

Map out the steps for CPU scheduling, including FIFO, SJF, STCF, RR, and I/O integration.

Workload Assumptions and Scheduling Metrics

First In, First Out (FIFO)

Shortest Job First (SJF)

Shortest Time-to-Completion First (STCF)

A New Metric: Response Time

Quiz on CPU Scheduling

Virtualization: Multi-Level Feedback

10 Lessons

See how it works to adapt scheduling with Multi-Level Feedback Queue for optimal performance.

Introduction to Multi-Level Feedback

MLFQ: Basic Rules

Attempt #1: How To Change Priority

Attempt #2: The Priority Boost

Attempt #3: Better Accounting

Tuning MLFQ And Other Issues

Quiz on Multi-level Feedback

Virtualization: Lottery Scheduling

13 Lessons

Build on lottery scheduling, its probabilistic fairness, implementation, and comparison to deterministic and fair schedulers.

Introduction to Lottery Scheduling

Basic Concept: Tickets Represent Your Share

Ticket Mechanisms

Implementation

An Example

Why Not Deterministic?

The Linux Completely Fair Scheduler (CFS)

Weighting (Niceness)

How is CFS efficient?

Quiz on Lottery Scheduling

Virtualization: Multi-CPU Scheduling

12 Lessons

Step through multi-CPU scheduling techniques, addressing performance, cache affinity, and load balancing.

Introduction to Multi-CPU Scheduling

Background: Multiprocessor Architecture

Don’t Forget Synchronization

One Final Issue: Cache Affinity

Single-Queue Scheduling

Multi-Queue Scheduling

Linux Multiprocessor Schedulers

Quiz on Multi-CPU Scheduling

Summary Dialogue on CPU Virtualization

Virtualization: Address Space

8 Lessons

Explore the evolution of operating systems, focusing on memory management and virtualization.

A Dialogue on Memory Virtualization

Early Systems

Multiprogramming and Time Sharing

Quiz on Address Space

10.

Virtualization: Memory API

10 Lessons

Master the steps to manage and allocate memory efficiently using UNIX/C memory APIs.

Introduction to Memory API

Underlying OS Support

11.

Virtualization: Address Translation

10 Lessons

Grasp the fundamentals of address translation, memory management, and hardware support.

Introduction to Address Translation

Assumptions

An Example

Dynamic (Hardware-based) Relocation

Hardware Support: A Summary

Operating System Issues

Quiz on Address Translation

12.

Virtualization: Segmentation

11 Lessons

Map out the steps for efficient memory management using segmentation and address translation.

Introduction to Segmentation

Segmentation: Generalized Base/Bounds

Which Segment Are We Referring To?

What About The Stack?

Support for Sharing

Fine-Grained vs. Coarse-Grained Segmentation

13.

Virtualization: Free Space Management

9 Lessons

Investigate free space management, allocation strategies, memory allocators, and practical simulations.

Introduction to Free Space Management

Quiz on Free Space Management

14.

Virtualization: Introduction to Paging

10 Lessons

Build on paging as a memory management technique addressing fragmentation and exploring translation challenges.

Introduction to Paging

A Simple Example And Overview

Where Are Page Tables Stored?

What’s Actually In The Page Table?

Paging: Also Too Slow

Quiz on Introduction to Paging

15.

Virtualization: Translation Lookaside Buffers

11 Lessons

Learn how to use Translation Lookaside Buffers (TLBs) for efficient virtual memory management.

Introduction to Translation Lookaside Buffers

TLB Basic Algorithm

Example: Accessing An Array

Who Handles The TLB Miss?

TLB Contents: What’s In There?

TLB Issue: Context Switches

Issue: Replacement Policy

A Real TLB Entry

Quiz on Translation Lookaside Buffer

16.

Virtualization: Advanced Page Tables

10 Lessons

Get started with advanced page tables to enhance memory management and optimize usage.

Introduction to Advanced Page Tables

Simple Solution: Bigger Pages

Hybrid Approach: Paging and Segments

Multi-level Page Tables

Inverted Page Tables

Swapping the Page Tables to Disk

Quiz on Advanced Page Tables

17.

Virtualization: Swapping: Mechanisms

11 Lessons

Master the steps to efficient memory management using virtual memory and swapping.

Introduction to Swapping: Mechanisms

Swap Space

The Present Bit

The Page Fault

What If Memory Is Full?

Page Fault Control Flow

When Replacements Really Occur

Instructions for Exercise

Quiz on Swapping: Mechanisms

18.

Virtualization: Swapping: Policies

16 Lessons

Grasp the fundamentals of virtual memory management policies, optimization, and performance trade-offs.

Introduction to Swapping: Policies

Cache Management

The Optimal Replacement Policy

A Simple Policy: FIFO

Another Simple Policy: Random

Using History: LRU

Workload Examples

Implementing Historical Algorithms

Approximating LRU

Considering Dirty Pages

Quiz on Swapping: Policies

19.

Virtualization: Complete VM Systems

14 Lessons

Deepen your knowledge of virtual memory systems, focusing on VAX/VMS and Linux architectures.

Introduction to Complete VM Systems

VAX/VMS Virtual Memory: Memory Management Hardware

VAX/VMS Virtual Memory: A Real Address Space

VAX/VMS Virtual Memory: Page Replacement

VAX/VMS Virtual Memory: Other Neat Tricks

The Linux Virtual Memory System: The Linux Address Space

The Linux Virtual Memory System: Page Table Structure

The Linux Virtual Memory System: Large Page Support

The Linux Virtual Memory System: The Page Cache

The Linux Virtual Memory System: Security And Buffer Overflows

The Linux Virtual Memory System: Other Security Problems

Quiz on Complete VM Systems

Summary Dialogue on Memory Virtualization

20.

Concurrency: Concurrency and Threads

12 Lessons

Simplify complex topics of concurrency, threads, race conditions, mutual exclusion, and atomicity.

A Dialogue on Concurrency

Introduction to Concurrency and Threads

Why Use Threads?

An Example: Thread Creation

Why It Gets Worse: Shared Data

The Heart Of The Problem: Uncontrolled Scheduling

The Wish For Atomicity

One More Problem: Waiting For Another

Summary: Why in OS Class?

Quiz on Concurrency and Threads

21.

Concurrency: Thread API

10 Lessons

Master the steps to create and manage threads using POSIX Thread API and synchronization methods.

Introduction to Thread API

Compiling and Running

22.

Concurrency: Locks

20 Lessons

Step through locks and synchronization techniques for efficient concurrency in programming.

Introduction to Locks

Locks: The Basic Idea

Pthread Locks

Building a Lock

Evaluating Locks

Controlling Interrupts

A Failed Attempt: Just Using Loads/Stores

Building Working Spin Locks with Test-And-Set

Evaluating Spin Locks

Compare-And-Swap

Load-Linked and Store-Conditional

Fetch-And-Add

Too Much Spinning: What Now?

A Simple Approach: Just Yield, Baby

Using Queues: Sleeping Instead of Spinning

Different OS, Different Support

23.

Concurrency: Locked Data Structures

8 Lessons

Get started with concurrent data structures, lock management, and performance optimization techniques.

Introduction to Locked Data Structures

Concurrent Counters

Concurrent Linked Lists

Concurrent Queues

Concurrent Hash Table

Quiz on Locked Data Structures

24.

Concurrency: Conditional Variables

10 Lessons

Break apart the implementation and challenges of conditional variables for effective synchronization.

Introduction to Conditional Variables

Definition and Routines

The Producer/Consumer (Bounded Buffer) Problem

Better, But Still Broken: While, Not If

The Single Buffer Producer/Consumer Solution

Covering Conditions

Instructions For Exercise

Quiz on Condition Variables

25.

Concurrency: Semaphores

13 Lessons

Explore semaphores for synchronization, event ordering, and solving classic concurrency problems.

Introduction to Semaphore

Semaphores: A Definition

Binary Semaphores (Locks)

Semaphores for Ordering

The Producer/Consumer (Bounded Buffer) Problem

Extending The Solution for Multiple Producers And Consumers

Reader-Writer Locks

The Dining Philosophers

Thread Throttling

How to Implement Semaphores

Introduction to Concurrency Bugs

Quiz on Semaphores

26.

Concurrency: Concurrency Bugs

11 Lessons

Map out the steps for understanding and handling concurrency bugs, focusing on deadlocks and prevention.

What Types of Bugs Exist?

Non-Deadlock Bugs

Deadlock Bugs

Prevention

Deadlock Avoidance via Scheduling

Detection And Recovery

Instructions for Exercise

Introduction to Event-Based Concurrency

Quiz on Concurrency Bugs

27.

Concurrency: Event-Based Concurrency

12 Lessons

Focus on event-based concurrency, event loops, select() API, asynchronous I/O, and state management.

The Basic Idea: An Event Loop

An Important API: select() or poll()

Using select()

A Problem: Blocking System Calls

A Solution: Asynchronous I/O

Another Problem: State Management

What Is Still Difficult With Events

Quiz on Event-based Concurrency

Summary Dialogue on Concurrency

28.

Persistence: I/O Devices

13 Lessons

Build on efficient interaction between operating systems and I/O devices for optimal performance.

A Dialogue on Persistence

Introduction to I/O Devices

System Architecture

A Canonical Device

The Canonical Protocol

Lowering CPU Overhead with Interrupts

More Efficient Data Movement with DMA

Methods of Device Interaction

Fitting into the OS: The Device Driver

Case Study: A Simple IDE Disk Driver

Historical Notes

Introduction to Hard Disk Drives

Quiz on I/O Devices

29.

Persistence: Hard Disk Drives

13 Lessons

Learn how to use HDDs for data storage, including operations, interfaces, and scheduling.

The Interface

Basic Geometry

A Simple Disk Drive

A Disk Drive with Multiple Tracks: Seek Time

More Details About Hard Drives

I/O Time: Doing the Math

Disk Scheduling

Some Other Scheduling Issues

Interface and RAID Internals

Quiz on Hard Disk Drives

30.

Persistence: Redundant Disk Arrays (RAID)

14 Lessons

Unpack the core of RAID technology, including performance, reliability, and best RAID levels.

Introduction to RAID

Fault Model

How to Evaluate a RAID

RAID Level 0: Striping

RAID Level 1: Mirroring

RAID Level 4: Saving Space With Parity

RAID Level 5: Rotating Parity

RAID Comparison: A Summary

Other Interesting RAID Issues

Quiz on Redundant Disk Arrays (RAID)

31.

Persistence: Files and Directories

19 Lessons

Examine persistent storage management, file system interfaces, and key UNIX operations for data reliability and access.

Introduction to Files and Directories

Files and Directories

The File System Interface

Reading and Writing Files

Reading and Writing, but not Sequentially

Shared File Table Entries: fork() and dup()

Writing Immediately With fsync()

Renaming Files

Getting Information About Files

Removing Files

Making Directories

Reading and Deleting Directories

Hard Links

Symbolic Links

Permission Bits and Access Control Lists

Making and Mounting a File System

Quiz on Files and Directories

32.

Persistence: File System Implementation

12 Lessons

Find out about implementing and managing file systems through data structures and access methods.

Introduction to File System Implementation

The Way to Think

Overall Organization

File Organization: The Inode

Directory Organization

Free Space Management

Access Paths: Reading and Writing

Caching and Buffering

Quiz on File System Implementation

33.

Persistence: Fast File System

11 Lessons

Take a closer look at optimizing file system performance through the Fast File System.

Introduction to Fast File System

The Problem: Poor Performance

FFS: Disk Awareness Is The Solution

Policies: How to Allocate Files and Directories

Measuring File Locality

The Large-File Exception

A Few Other Things About FFS

Introduction to FSCK and Journaling

Quiz on Fast File System

34.

Persistence: FSCK and Journaling

10 Lessons

Follow the process of ensuring file system crash consistency through fsck, journaling, and other techniques.

A Detailed Example

Solution #1: The File System Checker

Solution #2: Journaling (or Write-Ahead Logging)

Metadata Journaling

Solution #3: Other Approaches

Quiz on FSCK and Journaling

35.

Persistence: Log-Structured File System

17 Lessons

Master the steps to improve disk performance through log-structured write optimization and garbage collection.

Introduction to Log-Structured File System

Writing to Disk Sequentially

Writing Sequentially and Effectively

How Much to Buffer?

Problem: Finding Inodes

Solution Through Indirection: The Inode Map

Completing the Solution: The Checkpoint Region

Reading a File from Disk: A Recap

What About Directories?

A New Problem: Garbage Collection

Determining Block Liveness

A Policy Question: Which Blocks to Clean, and When?

Crash Recovery and the Log

Quiz on Log-Structured File System

36.

Persistence: Flash-based SSDs

16 Lessons

Step through SSD technology fundamentals, performance, reliability, and optimization techniques for efficient flash storage.

Introduction to Flash-based SSDs

Storing a Single Bit

From Bits to Banks/Planes

Basic Flash Operations

Flash Performance and Reliability

From Raw Flash to Flash-Based SSDs

FTL Organization: A Bad Approach

SSD Performance and Cost

Introduction to Data Integrity and Protection

Quiz on Flash-based SSDs

37.

Persistence: Data Integrity and Protection

14 Lessons

Ensure data integrity with checksum techniques to handle errors, corruption, and failures effectively.

Disk Failure Modes

Handling Latent Sector Errors

Detecting Corruption: The Checksum

Using Checksums

A New Problem: Misdirected Writes

One Last Problem: Lost Writes

Scrubbing

Overheads of Checksumming

Quiz on Data Integrity and Protection

Summary Dialogue on Persistence

38.

Distribution: Distributed Systems

10 Lessons

Work your way through distributed systems communication, focusing on reliability, RPC, and handling failures.

A Dialogue on Distribution

Introduction to Distributed Systems

Communication Basics

Unreliable Communication Layers

Reliable Communication Layers

Communication Abstractions

Remote Procedure Call (RPC)

Quiz on Distributed Systems

39.

Distribution: Network File System (NFS)

14 Lessons

Grasp the fundamentals of NFS, focusing on stateless protocols, caching, and efficient crash recovery.

Introduction to Network File System (NFS)

A Basic Distributed File System

On to NFS

Key to Fast Crash Recovery: Statelessness

The NFSv2 Protocol

From Protocol to Distributed File System

Handling Server Failure with Idempotent Operations

Improving Performance: Client-side Caching

The Cache Consistency Problem

Implications on Server-Side Write Buffering

Instructions For Exercise

Quiz on Network File System (NFS)

40.

Distribution: Andrew File System (AFS)

13 Lessons

Take a look at the Andrew File System's scalability, caching, consistency, performance, and simulations.

Introduction to Andrew File System (AFS)

AFS Version 1

Problems with Version 1

AFS Version 2

Cache Consistency

Crash Recovery

Scale and Performance of AFSv2

AFS: Other Improvements

Quiz on Andrew File System (AFS)

Summary Dialogue on Distribution

Course Author

Remzi Arpaci-Dusseau and

Andrea C Arpaci-Dusseau

Trusted by 2.5 million developers working at companies

"These are high-quality courses. Trust me. I own around 10 and the price is worth it for the content quality. EducativeInc came at the right time in my career. I'm understanding topics better than with any book or online video tutorial I've done. Truly made for developers. Thanks"

Anthony Walker

@_webarchitect_

"Just finished my first full #ML course: Machine learning for Software Engineers from Educative, Inc. ... Highly recommend!"

Evan Dunbar

ML Engineer

"You guys are the gold standard of crash-courses... Narrow enough that it doesn't need years of study or a full blown book to get the gist, but broad enough that an afternoon of Googling doesn't cut it."

Carlos Matias La Borde

Software Developer

"I spend my days and nights on Educative. It is indispensable. It is such a unique and reader-friendly site"

Souvik Kundu

Front-end Developer

"Your courses are simply awesome, the depth they go into and the breadth of coverage is so good that I don't have to refer to 10 different websites looking for interview topics and content."

Vinay Krishnaiah

Software Developer

"I've tried probably 5-7 different sites and Educative is easily the best. It perfectly blends explanation with interactivity"

Eric Downs

Musician/Entrepeneur

Hands-on Learning Powered by AI

See how Educative uses AI to make your learning more immersive than ever before.

Instant Code Feedback

Evaluate and debug your code with the click of a button. Get real-time feedback on test cases, including time and space complexity of your solutions.

AI-Powered Mock Interviews

Put your skills to the test in a simulated interview setting. Receive personalized feedback based on your performance. Available in Premium & Premium Plus plans.

Adaptive Learning

At various checkpoints throughout Educative courses, you will be prompted to take a quick assessment. Receive a condensed curriculum tailored to your strengths and skill gaps.

Explain with AI

Select any text within any Educative course, and get an instant explanation — without ever leaving your browser.

AI Code Mentor

AI Code Mentor helps you quickly identify errors in your code, learn from your mistakes, and nudge you in the right direction — just like a 1:1 tutor!

Recommended before starting this course

Course

A Guide to Vagrant and Virtual Machines

beginner

30 mins

Course

Mastering Concurrency in Go

Gain insights into implementing concurrency in Go, explore common patterns, and learn to write efficient, practical applications leveraging Go's outstanding support for concurrency.

intermediate

6 hours

Course

The All-in-One Guide to C++20

Gain insights into C++20's flagship features: concepts, modules, range library, and coroutines. Delve into standard library updates, concurrency, example code, and practical case studies.

intermediate

13 hours

Course

Java Multithreading for Senior Engineering Interviews

The only guide you’ll need on concurrency & multithreading for senior engineers. Pressure test your skills with real-world practice problems from top companies.

beginner

15 hours

A Guide to Vagrant and Virtual Machines

beginner

30 min

Mastering Concurrency in Go

6 hour

The All-in-One Guide to C++20

13 hour

Java Multithreading for Senior Engineering Interviews

beginner

15 hour

Related Courses and Skill Paths

Course

The All-in-One Guide to C++20

Gain insights into C++20's flagship features: concepts, modules, range library, and coroutines. Delve into standard library updates, concurrency, example code, and practical case studies.

intermediate

13 hours

Course

Mastering Concurrency in Go

Gain insights into implementing concurrency in Go, explore common patterns, and learn to write efficient, practical applications leveraging Go's outstanding support for concurrency.

intermediate

6 hours

Course

Modern C++ Concurrency: Get the most out of any machine

Explore modern C++ concurrency, from C++11 to C++20, combining theory with practice. Gain insights into parallel algorithms, co-routines, and best practices through interactive examples and real-world scenarios.

advanced

14 hours

The All-in-One Guide to C++20

13 hour

Mastering Concurrency in Go

6 hour