Video

In this lecture, we discuss distributed storage and challenges for caching in NFS and AFS network file systems. We then discuss the advantages of Key-Value storage systems as well as architectural challenges for providing scalability, reliability, and consistency. We will pick up in Lecture 26 with a discussion of Chord.

In this lecture, we continue our discussion of TCP/IP with a focus to providing clean abstractions for applications. With also discuss system-independent communication and RPC. We begin our discussion of Distributed File Systems to be finished next lecture.

In this lecture, we finish our discussion of distributed decision making by discussing two-phase commit and Byzantine Agreement. We also begin our discussion of networking with a discussion of IP, DNS, and TCP.

In this lecture, we finish our discussion of the use of transactions to enhance the reliability of file systems. We also discuss the F2FS filesystem for flash. Next, we discuss the End-To-End argument for networking and begin a discussion of distributed decision making.

In this lecture, we continue discussing the design of file systems by considering the BSD Fast File System (FFS) and NTFS. We then turn to performance and reliability by discussing the buffer cache and erasure codes. We will continue next lecture with a discussion of transactions and journalled file systems.

In this lecture, we examine the design issues that drive filesystem design. We then examine several real filesystems, including the FAT filesystem and the Fast File System (FFS). We will continue examining filesystems next lecture.

In this lecture, we discuss metrics of performance and queueing theory. We also start the discussion of filesystem design. Next time, we will examine some actual filesystems.

In this lecture, we continue our discussion of generic I/O interface mechanisms in the kernel (including device drivers). We then proceed to discuss two particular classes of storage devices: HDDs and SSDs. We then start a discussion of performance measurement.

In this lecture, we finish up our discussion of demand paging with a discussion of paging policies. We also talk about the Meltdown flaw. We then move on to a discussion of I/O mechanisms, buses, and ways in which processors communicate with devices. We will continue next lecture with a discussion of devices.

In this lecture, we discuss the need for demand paging replacement polices. We investigate simplistic policies such as FIFO, RANDOM, and MIN. We then present a variety of Clock algorithms and the Second Chance algorithm.

In this lecture, we continue our discussion of caching and TLBs in the context of virtual memory translation. We also start the process of discussing demand paging mechanisms.

In this lecture, we continue our discussion of virtual memory mapping techniques, including multi-level page tables. We examine the x86 page-table mapping mechanisms and use of segment registers in modern operating systems. We continue our discussion by examining the need for caching of translations using the TLB.

In this lecture, we begin talking about address translation and virtual memory. We start with simple segmentation, then proceed to basic page tables.

In this lecture, we finish up our discussion of the Linux CFS scheduler and then proceed with a general discussion of Deadlock. After giving some examples of deadlock, we develop an algorithm for detecting deadlock and finish with the Banker's algorithm for avoiding deadlock.

CS162 Lecture 11: Scheduling 2: Case Studies, Real Time, and Forward Progress

CS162 Lecture 10: Scheduling 1: Concepts and Classic Policies

CS162 Lecture 9: Synchronization 4: Monitors and Readers/Writers (Con't), Process Structure

CS162 Lecture 8: Synchronization 3: Atomic Instructions (Con't), Monitors, Readers/Writers

CS162 Lecture 7: Synchronization 2: Semaphores (Con't), Lock Implementation, Atomic Instructions

CS162: Lecture 6.5: Concurrency and Mutual Exclusion (Supplemental)

CS162: Lecture 6: Synchronization 1: Concurrency and Mutual Exclusion

CS162 Lecture 5: Abstractions 3: IPC, Pipes and Sockets

CS162 Lecture 4: Abstractions 2: Files and I/O

CS162 Lecture 3: Abstractions 1: Threads and Processes

CS162 Lecture 2: Four Fundamental OS Concepts

CS162 Lecture 1: What is an Operating System?

CS162 Lecture 24 (4/28/2020): Distributed File Systems (Finished), Key-Value Stores, and Chord

CS162 Lecture 23 (4/23/2020): Networking (Con't), Distributed File Systems, Key-Value Stores

CS162 Lecture 22 (4/21/2020): Distributed Decision Making (Finished), TCP/IP Networking