Advanced Operating Systems

Previous year (in Czech): 2022/23

Course Overview

The Advanced Operating Systems course offers a detailed look at the advanced software architectures, features and implementation techniques of state-of-the-art operating systems. The course consists of a series of consecutive lectures, but some of the lectures might be substituted by invited talks by experts (depending on their immediate availability) from leading companies that develop operating systems.

In the summer semester of 2023/2024, the lectures take place in the lecture room S10 each Thrusday at 2 p.m. The lectures are taught either in English or in Czech (depending on the preference of the enrolled students). The supplementary study materials are typically provided in English.

The course is a follow-up to the Operating Systems course from winter semester. Therefore this course assumes a reasonable degree of prior understanding of the basics taught in the winter semester course.

This web site serves as the primary source of information about the course. Urgent matters might be also announced via e-mails (sent to the e-mail addresses registered in SIS). For technical and organizational inquiries, please create an issue in the GitLab forum. It is also possible to subscribe to the notifications of this course repository and follow the questions asked by others.

In case of a question or a comment that you do not wish to discuss publicly, please feel free to approach either the lecturer Martin Děcký or the course guarantor Petr Tůma directly.

News

If you need a written exam date (or potentially a reparative attempt), please approach the lecturer (by e-mail) and we will agree on the next exam date to be scheduled.

Course Topics

Since the domain of operating systems is very broad and it is not possible to cover everything in the time given in fine detail, the actual focus of the individual lectures should be strongly influenced by the preferences of the enrolled students.

Below is the list of the supplementary study materials for the topics that have been covered during the semester.

1. Introduction (2024-02-22)

2. Programming languages and techniques (2024-02-29)

3. Interfaces, abstractions and portability (2024-03-21)

4. Virtualization (2024-04-18)

5. File systems (2024-04-25)

6. Observability, performance, debugging, tracing and instrumentation (2024-05-02)

7. Lea Schmierer (Heidelberg University): Microkernel Architecture and Operating Systems Security (2024-05-16)

8. Vlastimil Babka (SUSE): Advanced Linux Memory Management (2024-05-23)

Consultations

Should you need individual consultations, please approach the lecturer or the guarantor via e-mail to arrange an ad-hoc meeting. For practical reasons, we usually prefer times just before or just after the lecture, but other times are also possible.

Grading

There are several alternative ways of passing the course:

• A traditional written exam based on the topics taught.

  The exam is scored on a point scale and the final grade is derived from the total number of points achieved. To successfully pass the exam, one needs to achieve at least half of the maximal number of points. The very good grade requires at least 60 % of the maximal number of points and the excellent grade requires at least 80 % of the maximal number of points.

  N.B.: The supplementary study materials alone might not be sufficient for passing the written exam. If you plan on taking the written exam, we strongly encourage you to actually attend the lectures.

• An individual or team implementation project related to operating systems.

  The actual project assignment and evaluation criteria need to be agreed upon with the lecturer and the guarantor. The sooner you approach us with your proposal the better.

• A presentation of a lecture or a demonstration related to operating systems.

  It is possible to pass the course by having a lecture on or a practical demonstration of a specific topic related to operating systems. The course topics listed above should not be considered a limiting constrant, on the contrary. However, the actual topic, level of details and evaluation criteria need to be agreed upon with the lecturer and the guarantor. The sooner you approach us with your proposal the better.

Exam

N.B.: If you need a written exam date (or potentially a reparative attempt), please approach the lecturer (by e-mail) and we will agree on the next exam date to be scheduled.

The written exam consists of a certain number of questions/tasks randomly selected from the list below

As usual, the purpose of the written exam is not to probe on the encyclopedic knowledge per se, but rather to examine the actual level of understanding. Therefore we strongly encourage to approach each question/task both broadly and deeply, to explain the context and to formulate your reply in a systematic, coherent and unambiguous way that clearly demonstrates your level of understanding. The replies should focus on the why more than on the what.

• Describe schematically the typical bootstrap phases of a typical operating system. Explain the motivation and purpose of the individual phases.

• What are the typical and desired properties of programming languages suitable for operating system implementation? Explain the motivation for the properties and illustrate on examples of such programming languages.

• Describe which parts of an operating system are typically implemented in assembly and what is the motivation for that.

• What are the properties of the freestanding environment in the C language? How is the freestanding environment used in the context of operating systems?

• Define the term undefined behavior in C (and C++). Describe at least three specific examples of undefined behavior in detail and explain their impact on the implementation of a typical operating system.

• For the implementation of an operating system kernel in C++, why it might be useful to replace class inheritance with class composition? Illustrate on a specific example.

• What is the purpose of guarded objects in C++? Illustrate on an example in the context of operating systems.

• Define the term Non-Uniform Memory Access (NUMA) and describe its relevance for operating systems.

• What is the purpose of IOMMU in general and in the context of operating systems?

• Define the term capability (as it is understood notably in the context of microkernel-based operating systems). Describe the purpose of capabilities and how do they compare to related operating systems abstractions.

• Describe the terms capability derivation tree and capability mapping database. Describe their purpose for operating systems resource management.

• Describe the typical design and purpose of a system call (syscall) interface. What are the usual mechanisms that make this interface safe and secure?

• Describe how do the solid-state drives compare from rotational drives. How are the different properties reflected in the design and implementation of operating systems?

• What are the benefits and drawbacks of storing directory entries and file entries (i-nodes) as separate data structures by certain file system implementations? Describe the reasons for other file system implementations to keep them combined.

• What are the usual properies of the copy-on-write file system implementations? What are their benefits and drawbacks for specific use cases?

• Describe at least three distinct mechanisms of interactive debugging, describe their properties and illustrate on specific use cases when and why are they employed.

• What are the desired properties of operating systems tracing mechanisms? Illustrate on specific use cases when and why are they employed.

• Describe how does the exact profiling compare to statistical profiling. Illustrate on specific use cases when and why are they employed.

• Describe at least two distinct IPC mechanisms, describe their properties and illustrate on specific use cases when and why are they employed.

• Describe the general behavior of synchronous, asynchronous, blocking and non-blocking IPC mechanisms. Illustrate on specific use cases when and why are these types of IPC mechanisms employed.

• Describe how does paravirtualization differ from transparent virtualization. Illustrate on specific use cases when and why are these types of virtualization mechanisms employed.

• Define the term virtual CPU (vCPU). Describe the typical use of this abstraction for implementing different types of virtualization mechanisms.

• What are the typical design principles of a microkernel-based operating system? What are the motivations for these design principles?

Literature

• Baumann A. et al.: The Multikernel: A New OS Architecture for Scalable Multicore Systems, Proc. ACM SOSP 2009.
• Bonwick J.: The Slab Allocator: An Object-Caching Kernel Memory Allocator, Proc. USENIX Summer Technical Conference 1994.
• Bonwick J. et al.: Magazines and Vmem: Extending the Slab Allocator to Many CPUs and Arbitrary Resources, Proc. USENIX ATC 2001.
• Härtig H. et al.: The Performance of μ-Kernel-Based Systems, Proc. ACM SOSP 1997.
• Heiser G. et al.: L4 Microkernels: The Lessons from 20 Years of Research and Deployment, ACM TOCS Vol. 34 Issue 1, 2016.
• Herder J. et al.: Fault Isolation for Device Drivers, Proc. IEEE DSN 2009.
• Hunt G. et al.: Singularity: Rethinking the Software Stack, ACM SIGOPS OS Review Vol. 41 Issue 2, 2007.
• Levy H.: Capability-Based Computer Systems, Butterworth-Heinemann Newton, 1984.
• Nutt G. J.: Operating Systems: A Modern Perspective, Addison Wesley, 2002.
• Stallings W.: Operating Systems: Internals and Design Principles, Prentice Hall, 2012.
• Tanenbaum A. S. et al.: Operating Systems Design and Implementation, Prentice Hall, 2006.