In the SYSNAP master project we will deal with system-oriented programming of concurrency platforms in the summer semester 2023.
A concurrency platform is a combination of a parallel programming language and an associated runtime system. Since parallel programming is a necessary prerequisite to efficiently run current and especially future many-core systems (cf. "Free Lunch is Over", Dennard Scaling), concurrency platforms are essential. Prominent examples of concurrency platforms include Google's Go programming language (and its associated runtime system). In research, OpenCilk (MIT) or X10 (IBM) are to be mentioned here, for example. But also established languages with good support for parallel programming are undergoing a transformation to be modernize towards becoming a concurrency platform, e.g., Java's Project Loom.
In this project, we will first look at the basic building blocks of concurrency. Then we will learn about the typical programming interfaces of concurrency platforms, such as fork/join parallelism, and use them practically. In the next step, we will dive one level deeper into the runtime system and will deal in particular with scheduling, that is the core of the runtime system and is largely responsible for its efficiency. Thereby, we will look at "work-stealing scheduling", the predominant scheduling approach of concurrency platforms.
In the last third of the project, we will dive down another level and look at the interaction between the runtime system and the operating system. Although modern concurrency platforms can run without problems under current operating systems, we will see that these parallel runtime systems can only be operated optimally to a limited extent. This is partly due to the traditional synchronous operating system interface, but also due to a lack of functionality in the operating system. As part of the project, we are considering alternative approaches to improve the interaction between runtime system and operating system.
The master project is supervised by Florian Schmaus.
- Moderator/in: Michael Engel
- Moderator/in: Florian Schmaus
The system software master seminar this summer will be organized as a paper reading group with regular (weekly or bi-weekly) meetings.
In a paper reading group, a specific paper related to the overall topic of the seminar is proposed for each of the meetings (by the lecturers or also by request of the students). All students are expected to familiarize themselves with the paper and prepare a list of questions and/or discussion topics about that paper.
This implies that presence and active participation in the seminar meetings is mandatory.
Based on the papers discussed so far, each student has to select a paper that is related to the overall topic of the seminar (and not discussed in the reading sessions, of course). In addition to that one paper which will form the focus of the student's seminar presentation and report, students are also expected to actively search for (and find!) related work. Ideally, the seminar report and presentation will not only cover the contents of the papers, but also the participant's ideas on how to apply or adapt the chosen topic to current systems.
Deliverables for the seminar are a written report paper (organized like a scientific publication) of about 10 pages (LaTeX, ACM style) as well as a presentation. All presentations will be given towards the end of the semester in a one- or two-day session (with pizza and drinks!); in addition, there will be weekly meetings to discuss your progress and current topics/questions.
The topic of this semester's system software seminar is:
Concurrency and Parallelism in Operating Systems
Lecturers: Prof. Dr. Michael Engel, Florian Schmaus
- Moderator/in: Michael Engel
- Moderator/in: Florian Schmaus
SYSNAP-OSE-M: Operating Systems Engineering
This summer, you will have the choice of either using C as the implementation language or to learn Rust, a new memory-safe programming language especially suited for system programming. We will offer an additional course on Rust in case you are interested.
Operating systems and related system software such as hypervisors form the basis of today's computer systems. The design and implementation of the core parts of system software can have significant impact not only on the performance of a computer system, but also on other aspects such a safety, security, and energy efficiency. Thus, the design and implementation of operating systems is a highly relevant topic for students working in all areas of computer science, from small embedded systems to large virtualized Cloud infrastructures.
This module concentrates on the central part ("kernel") of an operating system, i.e. the part of the system running in a privileged processor mode that interacts directly with hardware. Based on seminal publications, students will investigate different architectures of kernels, such as monolithic, micro- and exokernels, hypervisors and also unikernels. Mechanisms and policies of operating systems will be analyzed with respect to their functional as well as non-functional properties. The analysis of mechanisms dependent on a specific processor architecture will be explained using the modern and open RISC-V processor architecture.
A central part of this module will consist of code reading and the development of pieces of code for a small operating system. Different aspects of operating system functionality will be demonstrated through existing code. Constraints of, extension possibilities for, as well as alternative approaches to implement a given functionality will be discussed; this discussion will then form the basis for the implementation of a given feature in the practical exercises. An example for this is the discussion of file systems; here, features of a given traditional inode-based file system will be discussed and analyzed and alternative implementations, such as log-structured file systems, will be investigated and implemented in a basic form.
- Moderator/in: Michael Engel
- Moderator/in: Leonhard Kohn
- Moderator/in: Timo Renk
- Moderator/in: Florian Schmaus
Das Bachelorprojekt befaßt sich in diesem Sommersemester mit der Struktur, dem Entwurf und der Implementierung eines Emulators für Computersysteme. Damit verbindet das Projekt Kenntnisse der Rechnerarchitektur, der systemnahen Programmierung und auch von Datenformaten, Audio/Video und auch Echtzeitverhalten.
Ziel des Projekts ist die Entwicklung eines Emulators für einen der ersten Spiele-Handhelds der Welt, den Nintendo GameBoy. Die Entwicklung soll dabei in einer Gruppe testgetrieben in einzelnen Stufen anhand existierender Spezifikationen stattfinden.
In diesem Projekt besteht die Möglichkeit, optional die moderne Programmiersprache Rust kennenzulernen. Hierzu bieten wir (gemeinsam mit Operating Systems Engineering) eine zusätzliche Einführung in Rust an. Das Projekt kann aber auch "traditionell" in C realisiert werden.
Als Einstieg in die Thematik empfiehlt sich der "Ultimate Gameboy Talk" vom 33. Chaos Communication Congress: https://www.youtube.com/watch?v=HyzD8pNlpwI
- Moderator/in: Michael Engel
- Moderator/in: Leonhard Kohn
- Moderator/in: Timo Renk