Operating Systems: Virtualization, Concurrency & Persistence
Course Overview
When it comes to operating systems, there are three main concepts: virtualization, concurrency, and persistence. These concepts lay the foundation for understanding how an operating system works. In this extensive course, you'll cover each of those in its entirety. You'll start by cov...
How You'll Learn
Hands-on coding environments
You don’t get better at swimming by watching others. Coding is no different. Practice as you learn with live code environments inside your browser.
Faster than videos
Videos are holding you back. The average video tutorial is spoken at 150 words per minute, while you can read at 250. That‘s why our courses are text-based.
No set-up required
Start learning immediately instead of fiddling with SDKs and IDEs. It‘s all on the cloud.
Progress you can show
Built-in assessments let you test your skills. Completion certificates let you show them off.
Hands-on coding environments
You don’t get better at swimming by watching others. Coding is no different. Practice as you learn with live code environments inside your browser.
Faster than videos
Videos are holding you back. The average video tutorial is spoken at 150 words per minute, while you can read at 250. That‘s why our courses are text-based.
No set-up required
Start learning immediately instead of fiddling with SDKs and IDEs. It‘s all on the cloud.
Progress you can show
Built-in assessments let you test your skills. Completion certificates let you show them off.
Course Contents
A Dialogue on the CourseIntroduction to Operating SystemsVirtualizing The CPUVirtualizing MemoryConcurrencyPersistenceDesign GoalsSome HistorySummary
A Dialogue on VirtualizationIntroduction to ProcessesThe Abstraction: A ProcessProcess APIProcess Creation: A Little More DetailProcesses StatesData StructuresSummarySimulatorExerciseQuiz on Processes
Introduction to Process APIThe fork() System CallThe wait() System CallFinally, The exec() System CallWhy? Motivating the APIProcess Control and UsersUseful ToolsSummaryExerciseQuiz on Process API
Introduction to Direct ExecutionBasic Technique: Limited Direct ExecutionProblem #1: Restricted OperationsProblem #2: Switching Between ProcessesWorried About Concurrency?SummaryExerciseQuiz on Direct Execution
Introduction to CPU SchedulingWorkload Assumptions and Scheduling MetricsFirst In, First Out (FIFO)Shortest Job First (SJF)Shortest Time-to-Completion First (STCF)A New Metric: Response TimeRound RobinIncorporating I/OSummarySimulatorExerciseQuiz on CPU Scheduling
Introduction to Multi-Level FeedbackMLFQ: Basic RulesAttempt #1: How To Change PriorityAttempt #2: The Priority BoostAttempt #3: Better AccountingTuning MLFQ And Other IssuesSummarySimulatorExerciseQuiz on Multi-level Feedback
Introduction to Lottery SchedulingBasic Concept: Tickets Represent Your ShareTicket MechanismsImplementationAn ExampleWhy Not Deterministic?The Linux Completely Fair Scheduler (CFS)Weighting (Niceness)How is CFS efficient?SummarySimulatorExerciseQuiz on Lottery Scheduling
Introduction to Multi-CPU SchedulingBackground: Multiprocessor ArchitectureDon’t Forget SynchronizationOne Final Issue: Cache AffinitySingle-Queue SchedulingMulti-Queue SchedulingLinux Multiprocessor SchedulersSummarySimulatorExerciseQuiz on Multi-CPU SchedulingSummary Dialogue on CPU Virtualization
A Dialogue on Memory VirtualizationEarly SystemsMultiprogramming and Time SharingThe Address SpaceGoalsSummaryExerciseQuiz on Address Space
Introduction to Memory APITypes of MemoryThe malloc() CallThe free() CallCommon ErrorsUnderlying OS SupportOther CallsSummaryExerciseQuiz on Memory API
Introduction to Address TranslationAssumptionsAn ExampleDynamic (Hardware-based) RelocationHardware Support: A SummaryOperating System IssuesSummarySimulatorExerciseQuiz on Address Translation
Introduction to SegmentationSegmentation: Generalized Base/BoundsWhich Segment Are We Referring To?What About The Stack?Support for SharingFine-Grained vs. Coarse-Grained SegmentationOS SupportSummarySimulatorExerciseQuiz on Segmentation
Introduction to Free Space ManagementAssumptionsLow-level MechanismsBasic StrategiesOther ApproachesSummarySimulatorExerciseQuiz on Free Space Management
Introduction to PagingA Simple Example And OverviewWhere Are Page Tables Stored?What’s Actually In The Page Table?Paging: Also Too SlowA Memory TraceSummarySimulatorExerciseQuiz on Introduction to Paging
Introduction to Translation Lookaside BuffersTLB Basic AlgorithmExample: Accessing An ArrayWho Handles The TLB Miss?TLB Contents: What’s In There?TLB Issue: Context SwitchesIssue: Replacement PolicyA Real TLB EntrySummaryExerciseQuiz on Translation Lookaside Buffer
Introduction to Advanced Page TablesSimple Solution: Bigger PagesHybrid Approach: Paging and SegmentsMulti-level Page TablesInverted Page TablesSwapping the Page Tables to DiskSummarySimulatorExerciseQuiz on Advanced Page Tables
Introduction to Swapping: MechanismsSwap SpaceThe Present BitThe Page FaultWhat If Memory Is Full?Page Fault Control FlowWhen Replacements Really OccurSummaryInstructions for ExerciseExerciseQuiz on Swapping: Mechanisms
Introduction to Swapping: PoliciesCache ManagementThe Optimal Replacement PolicyA Simple Policy: FIFOAnother Simple Policy: RandomUsing History: LRUWorkload ExamplesImplementing Historical AlgorithmsApproximating LRUConsidering Dirty PagesOther VM PoliciesThrashingSummarySimulatorExerciseQuiz on Swapping: Policies
Introduction to Complete VM SystemsVAX/VMS Virtual Memory: Memory Management HardwareVAX/VMS Virtual Memory: A Real Address SpaceVAX/VMS Virtual Memory: Page ReplacementVAX/VMS Virtual Memory: Other Neat TricksThe Linux Virtual Memory System: The Linux Address SpaceThe Linux Virtual Memory System: Page Table StructureThe Linux Virtual Memory System: Large Page SupportThe Linux Virtual Memory System: The Page CacheThe Linux Virtual Memory System: Security And Buffer OverflowsThe Linux Virtual Memory System: Other Security ProblemsSummaryQuiz on Complete VM SystemsSummary Dialogue on Memory Virtualization
A Dialogue on ConcurrencyIntroduction to Concurrency and ThreadsWhy Use Threads?An Example: Thread CreationWhy It Gets Worse: Shared DataThe Heart Of The Problem: Uncontrolled SchedulingThe Wish For AtomicityOne More Problem: Waiting For AnotherSummary: Why in OS Class?SimulatorExerciseQuiz on Concurrency and Threads
Introduction to Thread APIThread CreationThread CompletionLocksCondition VariablesCompiling and RunningSummarySimulatorExerciseQuiz on Thread API
Introduction to LocksLocks: The Basic IdeaPthread LocksBuilding a LockEvaluating LocksControlling InterruptsA Failed Attempt: Just Using Loads/StoresBuilding Working Spin Locks with Test-And-SetEvaluating Spin LocksCompare-And-SwapLoad-Linked and Store-ConditionalFetch-And-AddToo Much Spinning: What Now?A Simple Approach: Just Yield, BabyUsing Queues: Sleeping Instead of SpinningDifferent OS, Different SupportTwo-Phase LocksSummaryExerciseQuiz on Locks
Introduction to Locked Data StructuresConcurrent CountersConcurrent Linked ListsConcurrent QueuesConcurrent Hash TableSummaryExerciseQuiz on Locked Data Structures
Introduction to Conditional VariablesDefinition and RoutinesThe Producer/Consumer (Bounded Buffer) ProblemBetter, But Still Broken: While, Not IfThe Single Buffer Producer/Consumer SolutionCovering ConditionsSummaryInstructions For ExerciseExerciseQuiz on Condition Variables
Introduction to SemaphoreSemaphores: A DefinitionBinary Semaphores (Locks)Semaphores for OrderingThe Producer/Consumer (Bounded Buffer) ProblemExtending The Solution for Multiple Producers And ConsumersReader-Writer LocksThe Dining PhilosophersThread ThrottlingHow to Implement SemaphoresSummaryExerciseQuiz on Semaphores
Introduction to Concurrency BugsWhat Types of Bugs Exist?Non-Deadlock BugsDeadlock BugsPreventionDeadlock Avoidance via SchedulingDetection And RecoverySummaryInstructions for ExerciseExerciseQuiz on Concurrency Bugs
Introduction to Event-Based ConcurrencyThe Basic Idea: An Event LoopAn Important API: select() or poll()Using select()A Problem: Blocking System CallsA Solution: Asynchronous I/OAnother Problem: State ManagementWhat Is Still Difficult With EventsSummaryExerciseQuiz on Event-based ConcurrencySummary Dialogue on Concurrency
A Dialogue on PersistenceIntroduction to I/O DevicesSystem ArchitectureA Canonical DeviceThe Canonical ProtocolLowering CPU Overhead with InterruptsMore Efficient Data Movement with DMAMethods of Device InteractionFitting into the OS: The Device DriverCase Study: A Simple IDE Disk DriverHistorical NotesSummaryQuiz on I/O Devices
Introduction to Hard Disk DrivesThe InterfaceBasic GeometryA Simple Disk DriveA Disk Drive with Multiple Tracks: Seek TimeMore Details About Hard DrivesI/O Time: Doing the MathDisk SchedulingSome Other Scheduling IssuesSummarySimulatorExerciseQuiz on Hard Disk Drives
Introduction to RAIDInterface and RAID InternalsFault ModelHow to Evaluate a RAIDRAID Level 0: StripingRAID Level 1: MirroringRAID Level 4: Saving Space With ParityRAID Level 5: Rotating ParityRAID Comparison: A SummaryOther Interesting RAID IssuesSummarySimulatorExerciseQuiz on Redundant Disk Arrays (RAID)
Introduction to Files and DirectoriesFiles and DirectoriesThe File System InterfaceReading and Writing FilesReading and Writing, but not SequentiallyShared File Table Entries: fork() and dup()Writing Immediately With fsync()Renaming FilesGetting Information About FilesRemoving FilesMaking DirectoriesReading and Deleting DirectoriesHard LinksSymbolic LinksPermission Bits and Access Control ListsMaking and Mounting a File SystemSummaryExerciseQuiz on Files and Directories
Introduction to File System ImplementationThe Way to ThinkOverall OrganizationFile Organization: The InodeDirectory OrganizationFree Space ManagementAccess Paths: Reading and WritingCaching and BufferingSummarySimulatorExerciseQuiz on File System Implementation
Introduction to Fast File SystemThe Problem: Poor PerformanceFFS: Disk Awareness Is The SolutionPolicies: How to Allocate Files and DirectoriesMeasuring File LocalityThe Large-File ExceptionA Few Other Things About FFSSummarySimulatorExerciseQuiz on Fast File System
Introduction to FSCK and JournalingA Detailed ExampleSolution #1: The File System CheckerSolution #2: Journaling (or Write-Ahead Logging)Metadata JournalingSolution #3: Other ApproachesSummarySimulatorExerciseQuiz on FSCK and Journaling
Introduction to Log-Structured File SystemWriting to Disk SequentiallyWriting Sequentially and EffectivelyHow Much to Buffer?Problem: Finding InodesSolution Through Indirection: The Inode MapCompleting the Solution: The Checkpoint RegionReading a File from Disk: A RecapWhat About Directories?A New Problem: Garbage CollectionDetermining Block LivenessA Policy Question: Which Blocks to Clean, and When?Crash Recovery and the LogSummarySimulatorExerciseQuiz on Log-Structured File System
Introduction to Flash-based SSDsStoring a Single BitFrom Bits to Banks/PlanesBasic Flash OperationsFlash Performance and ReliabilityFrom Raw Flash to Flash-Based SSDsFTL Organization: A Bad ApproachA Log-Structured FTLGarbage CollectionMapping Table SizeWear LevelingSSD Performance and CostSummarySimulatorExerciseQuiz on Flash-based SSDs
Introduction to Data Integrity and ProtectionDisk Failure ModesHandling Latent Sector ErrorsDetecting Corruption: The ChecksumUsing ChecksumsA New Problem: Misdirected WritesOne Last Problem: Lost WritesScrubbingOverheads of ChecksummingSummarySimulatorExerciseQuiz on Data Integrity and ProtectionSummary Dialogue on Persistence
A Dialogue on DistributionIntroduction to Distributed SystemsCommunication BasicsUnreliable Communication LayersReliable Communication LayersCommunication AbstractionsRemote Procedure Call (RPC)SummaryExerciseQuiz on Distributed Systems
Introduction to Network File System (NFS)A Basic Distributed File SystemOn to NFSKey to Fast Crash Recovery: StatelessnessThe NFSv2 ProtocolFrom Protocol to Distributed File SystemHandling Server Failure with Idempotent OperationsImproving Performance: Client-side CachingThe Cache Consistency ProblemImplications on Server-Side Write BufferingSummaryInstructions For ExerciseExerciseQuiz on Network File System (NFS)
Join more than 1.7 million learners from companies like