Martin Děcký

The idea of the microkernel OS architecture is more that 50 years old and the term itself is just a few years younger. Over the years, it has been implemented in countless variants and modifications, it has served as a basis for intriguing OS experiments, it has gained strong position in the mission-critical and safety-critical areas and while it is still not the dominant architecture in the general-purpose desktop OS domain, it has had major influence on the "mainstream" operating systems as well.

This talk, however, is not about the history. Instead, we describe where are the microkernel-based operating systems today, who works on them and why, who uses them in production and why, where they aim for the future. The purpose of this talk is also to present the basic practical experiences with the existing microkernel-based operating systems — not to compare them, but to provide the potential users and contributors with an initial sorted list of operating systems they should look into in more detail depending on their needs.

Welcome talk and introduction to the Microkernel and Component-based OS devroom at FOSDEM 2022.

Other people: Sebastian Sumpf

Panel discussion and an extended Q&A session on the state of microkernel-based operating systems in 2021 and related topics. The panelists (in order of acceptance):

• Martin Decky (HelenOS, Huawei)
• Jakub Jermar (Kernkonzept, HelenOS)
• Norman Feske (Genode Labs)
• Julian Stecklina (Cyberus)
• Udo Steinberg (BedRock Systems)
• Matthias Lange (Kernkonzept)
• Gernot Heiser (seL4)

The discussion will smoothly evolve into the traditional and less formal "microkernel dinner". Please bring your own food and beverages.

Other people: Jakub Jermář Norman Feske Julian Stecklina Udo Steinberg Matthias Lange Gernot Heiser

Welcome talk and introduction to the Microkernel Devroom at FOSDEM 2021.

While the performance overhead of IPC in microkernel multiserver operating systems is no longer considered a blocker for their practical deployment (thanks to many optimization ideas that have been proposed and implemented over the years), it is undeniable that the overhead still does exist and the more fine-grained the architecture of the operating system is (which is desirable from the reliability, dependability, safety and security point of view), the more severe performance penalties due to the IPC overhead it suffers. A closely related issue is the overhead of handing hardware interrupts in user space device drivers. This talk discusses some specific hardware/software co-design ideas to improve the performance of microkernel multiserver operating systems.

One reason for the IPC overhead is the fact that current hardware and CPUs were never designed with microkernel multiserver operating systems in mind, but they were rather fitted for the traditional monolithic operating systems. This calls for an out-of-the-box thinking while designing instruction set architecture (ISA) extensions and other hardware features that would support (a) efficient communication between isolated virtual address spaces using synchronous and asynchronous IPC primitives, and (b) treating object references (e.g. capability references) as first-class entities on the hardware level. A good testbed for evaluating such approaches (with the potential to be eventually adopted as industry standard) is the still unspecified RV128 ISA (128-bit variant of RISC-V).

This talk discusses some specific hardware/software co-design ideas to improve the performance of microkernel multiserver operating systems.

HelenOS is an open source operating system based on the microkernel multiserver design principles. One of its goals is to provide excellent target platform portability. From the time of its inception, HelenOS already supported 4 different hardware platforms and currently it supports platforms as diverse as x86, SPARCv9 and ARM. This talk presents practical experiences and lessons learned from porting HelenOS to RISC-V.

While the unprivileged (user space) instruction set architecture of RISC-V has been declared stable in 2014, the privileged instruction set architecture is technically still allowed to change in the future. Likewise, many major design features and building blocks of HelenOS are already in place, but no official commitment to ABI or API stability has been made yet. This gives an interesting perspective on the pros and cons of both HelenOS and RISC-V. The talk also points to some possible research directions with respect to hardware/software co-design.

During the history of digital computers, the majority of mainstream computer systems we designed as CPU-centric. All the data that the computer processed always passed through the main memory in one way or the other and the code running on the CPU manipulated with the data, directly on indirectly. Even DMA controllers, co-processors, GPUs and intelligent NICs were used just as slave peripherals, although with some degree of computational off-loading in the recent years.

One of the reasons for keeping the same basic architecture despite its drawbacks such as the ever-widening memory barrier (i.e. the difference between the latency of the CPU and the RAM) was arguably its conceptual simplicity. However, trends for a major change in the status quo are finally emerging into the mainstream. These new architectures, often called data-centric computing or near-data processing, propose to turn an ordinary computer into a distributed system where the distinction between the CPU, main memory and peripherals is much more blurry. Components such as individual DRAM chips, flash memory chips and NICs should have autonomous computing capabilities and the possibility to interchange data between other components without the involvement of the main CPU.

This talk will present a brief overview of the concepts and discuss the consequences for operating system designs, especially regarding microkernels.

HelenOS is a portable microkernel-based multiserver operating system designed and implemented from scratch. It decomposes key operating system functionality such as file systems, networking, device drivers and graphical user interface into a collection of fine-grained user space components that interact with each other via message passing. HelenOS does not aim to be a clone of any existing operating system and trades compatibility with legacy APIs for cleaner design. Most of HelenOS components have been made to order specifically for HelenOS so that its essential parts can stay free of glue code, franken-components and the maintenance burden incurred by them. In this talk I will do the annual HelenOS project update.

Please note that the talk will be given by Martin Děcký instead of Jakub Jermář who, caused by illness, will not attend FOSDEM.

RISC-V is the most recent attempt (originally from UC Berkeley) to design a brand new instruction set architecture based on the reduced instruction set computing (RISC) principles. One of its goals is to be completely open and free (both as in free beer and as in free speech) for designers, users and manufacturers. HelenOS is an open source operating system designed and implemented from scratch based on the microkernel multiserver design principles. One of its goals is to provide excellent target platform portability and it currently supports 8 different hardware platforms.

Both projects are still in the process of maturing: While the unprivileged (user space) instruction set architecture of RISC-V has been declared stable in 2014, the privileged instruction set architecture is still in a stage of draft and is allowed to change in the future. Likewise, many major design features and building blocks of HelenOS are already in place, but no official commitment to ABI or API stability has been made yet.

This talk introduces both projects, presents the initial lessons learned from porting HelenOS to RISC-V and evaluates the portability of HelenOS on yet another porting effort.

Some developers of both microkernel and monolithic operating systems view the design of their system as absolutely superior to the other design. This black-white thinking and "holy war" attitude, while understandable to a certain degree, makes it hard to to acknowledge that one size does not necessarily fit all. Rather than striving for an unreachable goal of creating the best operating system design for all possible use cases it is vital to understand and reflect the trade-offs of the use cases at hand. This talk focuses on a few features and properties of the current monolithic operating systems that could be an inspiration for the current microkernel operating systems and vice versa. The talk should also initiate a discussion about some "non-goals" of microkernel operating systems that are nevertheless sometimes presented as goals of microkernel operating systems, to the detriment of its own cause.

This talk briefly introduces the RCU mechanism and the usual trade-offs that specific RCU implementations need to make. Furthermore, the talk also presents two novel RCU algorithms designed for a microkernel environment and implemented in HelenOS.

Read-Copy-Update (RCU) is a generic synchronization mechanism suitable for read-mostly shared data. There are many various implementations of the RCU mechanism, but their common goal is to provide non-blocking concurrent access with only a small overhead for the readers and also concurrent access for the updaters. Such an arrangement provides for excellent scalability compared to traditional mutual exclusion synchronization mechanisms while at the same time isolating the user of the RCU from the complexity of designing custom non-blocking algorithms.

The podium will consist of representatives of all the OS projects participating in the devroom. This is thought as an interactive event. The audience will have the opportunity to ask questions, which will be answered by all representatives.

Other people: Norman Feske Stefan Kalkowski Samuel Thibault Björn Döbel Nils Asmussen

The talk presents several research-driven and industry-driven hot topics, bleeding edge development and fresh new ideas from the operating systems domain. We focus primarily on microkernel-based systems and several of the presented topics are illustrated on HelenOS, but the talk is not strictly limited to this scope.

Since the famous [Tanenbaum-Torvalds debate](http://en.wikipedia.org/wiki/Tanenbaum–Torvalds_debate) the general public sticks to the golden rule of thumb: Microkernel systems, while nice and elegant, are just academic toys. Due to the infamous communication overhead and other self-imposed limitations, they are never going to be as useful for the general use (in terms of performance) as the good old monolithic systems. Since the 1990s many researchers (especially the people around L4) have struggled to lower the overhead using the most extraordinary tricks. Others have tried to apply the microkernel design to mission critical, safety critical and other niche targets, where the benefits of the microkernel design clearly outweights the drawbacks. And other folks spent years creating hybrid systems to get the best (and hopefully not the worst) of the both worlds. But are the drawbacks of the microkernels fundamental?

The way computers are designed, the way programmers think and the way the IT economy works have changed profoundly over the last 20 years. We no longer try hard to save every single CPU cycle and every single byte of RAM in every single routine. We acknowledge that spending 20 % more on a faster CPU and more RAM to run inteligebly designed software is a better idea than spending 20 % more each year on maintaing software with tons of ugly performance hacks and quirks. Our machines are massively concurrent and we tend to (or are forced to) think more in terms of effective parallel algorithms than just plain sequential throughput. So perhaps it is time to reconsider the true impact of the microkernel overhead given the present conditions and requirements. Key topics: - Reasons for the microkernel overhead - Qualitative and quantitative analysis of the overhead - Ways to minimize it - Ways to live with it - Ways to embrace it