Informatik-Kolloquien
367. Informatik-Kolloquium
Vorträge im Rahmen des Berufungsverfahrens Programmiersprachen und -techniken
Donnerstag, 03.09.2026, Straße der Nationen 62, Böttcher-Bau, A12.336
3. September 2026
09:00 Uhr - Dr. Peter Wägemann
„Shared-Memory-Programmierung mit OpenMP auf NUMA-Architekturen“
Die Lehrprobe startet mit einer Wiederholung der grundlegenden Erkenntnisse und Modelle der vorangegangenen Vorlesungen. Anschließend wird die Programmierschnittstelle OpenMP für Shared-Memory-Programmierung grundlegend eingeführt. Das Problem der Speicherplatzierung bei Shared-Memory-Programmierung auf NUMA-Architekturen wird aufgezeigt. Um die folgenden Strategien der Platzierung zu verstehen, werden die relevanten Aspekte von NUMA-Architekturen eingeführt. Die Lehrprobe zeigt das Zusammenspiel aus Programmiermodell, Rechnerarchitektur, Compiler, Laufzeit- bzw. Betriebssystem. Neben der Zusammenfassung der Inhalte wird ein Ausblick auf die folgenden Übungsinhalte gegeben.
„Provably Safe and Efficient Embedded Systems Under Resource Limits“
Modern embedded systems must operate safely in environments where available resources (e.g., time and energy) are severely limited. For example, medical (implantable) devices need to meet real-time requirements while accounting for stringent energy constraints. Especially for highly safety-critical systems, provable operational guarantees are solely possible with ahead-of-runtime knowledge of the system's worst-case behavior. The central challenge, therefore, lies in determining accurate worst-case bounds while simultaneously achieving high resource efficiency. This talk presents novel program-code analysis techniques based on sound abstractions that span all relevant system layers, including the electronic circuit, the instruction-set architecture, the operating system, and the application layer. Building upon these worst-case analysis techniques, optimization methods are presented for modern embedded hardware platforms. These optimizations achieve mathematically provable resource minimization while maintaining safe runtime guarantees. Finally, the talk concludes with an approach to carbon-aware co-design aimed at advancing the sustainability of next-generation embedded systems.
11:00 Uhr - Prof. Ronald Leißa
„Programmiermodelle für Multicore-Systeme“
Seit dem Ende der Taktratensteigerung ist Parallelität keine Option mehr, sondern eine Voraussetzung für Rechenleistung. Damit wird eine Frage praktisch relevant, die viele Programmierende selten explizit stellen: "Wie viel von der Reihenfolge, die ich hinschreibe, garantiert mir das System überhaupt?" Die Sitzung entwickelt die Antwort anhand eines einfachen Protokolls für einen kritischen Abschnitt. Daran wird deutlich, dass die Ausführungsreihenfolge auf verschiedenen Ebenen verändert werden kann: Was im Programm als feste Reihenfolge erscheint, muss nicht der Reihenfolge entsprechen, in der Operationen tatsächlich ausgeführt oder für andere Kerne sichtbar werden. Am Store-Buffer, der einfachsten Form einer solchen Umordnung, wird die sequentielle Konsistenz als intuitive Referenz eingeführt und anschließend als zu teuer verworfen. An ihre Stelle tritt das Speichermodell als Vertrag: Es legt fest, welche Ordnung und Sichtbarkeit von Speicherzugriffen garantiert werden und welche Verantwortung damit bei den Programmierenden verbleibt. Damit wird zugleich eine zentrale Perspektive auf Programmiermodelle für Multicore-Systeme greifbar: Sie unterscheiden sich vor allem darin, wie viel dieses Vertrags sie den Programmierenden abnehmen. Der Vertrag verschwindet dabei nie, er wechselt nur den Vertragspartner.
„Compilers That Understand More“
Since clock frequencies stopped rising, performance is no longer something that hardware simply hands us. Programmers must explicitly target many cores, vector units, GPUs, and other accelerators, and repeat that effort for every new machine. My work asks how much of this labor can instead be handed back to the compiler. Consider a product of three matrices: one order of multiplication can require six times fewer operations than another. Yet no C++ compiler will exploit this difference, because it sees loops and array indices rather than matrices. The knowledge is not difficult; it is simply absent. Domain experts therefore build their own compilers, repeatedly rebuilding the same infrastructure and making their systems difficult to compose with one another. MimIR addresses this problem with an extensible, type-safe intermediate representation. Domain experts declare their own operations together with the rules that govern them, while a single dependently typed core calculus keeps every extension composable and type-checked. Regular expressions, tensor computations, and automatic differentiation all become plugins, and the code they generate matches or outperforms hand-written low-level implementations. Making a compiler extensible also requires a representation of programs that reflects how modern languages are structured. Virtually every production compiler organizes programs around dominance, a notion rooted in control flow, which makes it imprecise. Higher-order functions, polymorphism, and dependent types introduce structure that control flow alone does not capture. MimIR instead organizes programs through free-variable nesting. We prove that nesting is a relaxation of dominance and verify the proofs in Lean. Computing free variables, building the nesting tree, our relaxed alternative to dominance, and specializing code all run in log-linear time in practice.
Alle interessierten Personen sind herzlich eingeladen!
