Peter Ulbrich
Current Organizations / Institutes
The organizations/institutes from the scholar's latest article
Previous Organizations / Institutes
The organizations / institutes from the scholar's other articles in the past ten years
Research Subjects
Peter Ulbrich has a total of 40 co-authors. Here are the top co-authors by number of shared publications:
- Daniel Lohmann
Leibniz Universität Hannover, Hanover, Germany
6 shared publications Wolfgang Schroder-Preikschat
5 shared publicationsFlorian Franzmann
4 shared publicationsTobias Klaus
Chair of Distributed Systems and Operating Systems, Friedrich-Alexander-Universität Erlangen-Nürnberg
4 shared publicationsWolfgang Schröder-Preikschat
Friedrich-Alexander-Universität Erlangen-Nürnberg (FAU)
4 shared publicationsChristian Dietrich
Leibniz Universität Hannover (LUH)
3 shared publications
Latest Publications
- Open Access
- 13 October 2025
- Published by Association for Computing Machinery (ACM)
- p. 76-83
Path Expressions Revisited - Towards Compiler-enforced Reusable Synchronization Patterns
- 13 October 2025
- Published by Association for Computing Machinery (ACM)
- p. 76-83
Open AccessPath Expressions Revisited - Towards Compiler-enforced Reusable Synchronization Patterns
- Open Access
- 26 September 2025
- Published by Association for Computing Machinery (ACM) in ACM Transactions on Embedded Computing Systems
- Vol. 24 (5s) , 1-26
Wasm-IO: Enabling Low-Level Device Interaction in WebAssembly for Industry Automation
Certification on a component level is highly beneficial in industrial automation because it allows for independent verification and updates without compromising the reliability of the overall system. Containerization technologies naturally address this demand by providing isolation between software modules. In particular, WebAssembly-based (Wasm) containerization is gaining popularity in industrial automation due to its inherent advantages, including cross-platform interoperability and secure execution of untrusted third-party code. However, Wasm’s strict sandboxing poses a significant limitation as it severely limits interaction with hardware devices, making it difficult to interface with sensors and actuators. This is a substantial barrier to adoption in industrial automation, where real-time and low-level hardware interactions are critical. To address this challenge, we present Wasm-IO , a framework designed to facilitate peripheral Input/Output (I/O) operations within WebAssembly (Wasm) containers. Wasm-IO allows the development of isolated device drivers in Wasm, explicitly moving hardware interaction to the container level. Our architectural approach facilitates containers with hardware interaction to be independently certified, updated, and maintained without adversely affecting each other. This article elucidates foundational methodologies and practical implementations supporting synchronous and asynchronous I/O operations and methods for embedding platform-independent peripheral configurations within Wasm binaries. Additionally, we present an extended priority model enabling interrupt handling in Wasm while maintaining temporal isolation. Our evaluation demonstrates that Wasm-IO significantly reduces latency and overhead compared to existing methods and traditional user-level driver implementations, effectively addressing certification and functional requirements critical to industrial automation systems.
- 26 September 2025
- Published by Association for Computing Machinery (ACM) in ACM Transactions on Embedded Computing Systems
- Vol. 24 (5s) , 1-26
Open AccessWasm-IO: Enabling Low-Level Device Interaction in WebAssembly for Industry Automation
Certification on a component level is highly beneficial in industrial automation because it allows for independent verification and updates without compromising the reliability of the overall system. Containerization technologies naturally address this demand by providing isolation between software modules. In particular, WebAssembly-based (Wasm) containerization is gaining popularity in industrial automation due to its inherent advantages, including cross-platform interoperability and secure execution of untrusted third-party code. However, Wasm’s strict sandboxing poses a significant limitation as it severely limits interaction with hardware devices, making it difficult to interface with sensors and actuators. This is a substantial barrier to adoption in industrial automation, where real-time and low-level hardware interactions are critical. To address this challenge, we present Wasm-IO , a framework designed to facilitate peripheral Input/Output (I/O) operations within WebAssembly (Wasm) containers. Wasm-IO allows the development of isolated device drivers in Wasm, explicitly moving hardware interaction to the container level. Our architectural approach facilitates containers with hardware interaction to be independently certified, updated, and maintained without adversely affecting each other. This article elucidates foundational methodologies and practical implementations supporting synchronous and asynchronous I/O operations and methods for embedding platform-independent peripheral configurations within Wasm binaries. Additionally, we present an extended priority model enabling interrupt handling in Wasm while maintaining temporal isolation. Our evaluation demonstrates that Wasm-IO significantly reduces latency and overhead compared to existing methods and traditional user-level driver implementations, effectively addressing certification and functional requirements critical to industrial automation systems.
- Open Access
- 2 December 2024
- Published by Association for Computing Machinery (ACM)
- p. 19-24
NimbleNet: Serverless Computing for the Extreme Edge in Factory Environments
Modern factories are moving towards modular layouts with more generic production cells, allowing rapid production customization. Here, the cell's edge nodes exhibit considerable heterogeneity, ranging from simple microcontrollers to fully-fledged computing systems, which mandates that assembly-specific serverless functions used by Automated Guided Vehicles (AGVs) navigating through and linking the production cells are platform-independent. These moving manufacturing processes call for an adapted communication and distribution infrastructure to maintain low response times while minimizing network traffic. We present NimbleNet, a lightweight distribution and orchestration approach for serverless functions, specifically tailored for IoT devices in industrial factory settings. NimbleNet leverages lightweight sandboxing such as WebAssembly, dynamic dependency management, and a neighbor-first caching strategy to enable efficient, platform-independent deployment of tasks at the extreme edge. Our simulations and real-world evaluations demonstrate that our approach facilitates the dynamic deployment and execution of tasks on resource-constrained devices while optimizing the network load within a mesh network configuration.
- 2 December 2024
- Published by Association for Computing Machinery (ACM)
- p. 19-24
Open AccessNimbleNet: Serverless Computing for the Extreme Edge in Factory Environments
Modern factories are moving towards modular layouts with more generic production cells, allowing rapid production customization. Here, the cell's edge nodes exhibit considerable heterogeneity, ranging from simple microcontrollers to fully-fledged computing systems, which mandates that assembly-specific serverless functions used by Automated Guided Vehicles (AGVs) navigating through and linking the production cells are platform-independent. These moving manufacturing processes call for an adapted communication and distribution infrastructure to maintain low response times while minimizing network traffic. We present NimbleNet, a lightweight distribution and orchestration approach for serverless functions, specifically tailored for IoT devices in industrial factory settings. NimbleNet leverages lightweight sandboxing such as WebAssembly, dynamic dependency management, and a neighbor-first caching strategy to enable efficient, platform-independent deployment of tasks at the extreme edge. Our simulations and real-world evaluations demonstrate that our approach facilitates the dynamic deployment and execution of tasks on resource-constrained devices while optimizing the network load within a mesh network configuration.
- Open Access
- 11 April 2018
- Published by Association for Computing Machinery (ACM)
- p. 91-100
A New Perspective on Quality Evaluation for Control Systems with Stochastic Timing
- 11 April 2018
- Published by Association for Computing Machinery (ACM)
- p. 91-100
Open AccessA New Perspective on Quality Evaluation for Control Systems with Stochastic Timing
- Open Access
- 27 September 2017
- Published by Association for Computing Machinery (ACM) in ACM Transactions on Embedded Computing Systems
- Vol. 16 (5s) , 1-19
Demystifying Soft-Error Mitigation by Control-Flow Checking -- A New Perspective on its Effectiveness
Soft errors are a challenging and urging problem in the domain of safety-critical embedded systems. For decades, checking schemes have been investigated and improved to mitigate soft-error effects for the class of control-flow faults, with current industrial standards strongly recommending their use. However, reality looks different: Taking a systems perspective, we implemented four representative Control-Flow Checking (CFC) schemes and put them through their paces in 396 fault-injection campaigns. In contrast to previous work, which typically relied on probability-based vulnerability metrics, we accounted for the influence of memory and time overheads on the fault-space dimensions and applied those in full-scan fault injections. This change in procedure alone severely degraded the perceived effectiveness of CFC. In addition, we expanded the perspective to data-flow faults and their influence on the overall susceptibility, an aspect that so far has been largely ignored. Our results suggest that, without accompanying measures, any improvement regarding control-flow faults is dominated by the increase in data faults caused by the increased attack surface in terms of memory and runtime overhead. Moreover, CFC performance less depended on the detection capabilities than on general aspects of the concrete binary compilation and execution. In conclusion, incorporating CFC is not as straightforward as often assumed and the vulnerability of systems with hardened control-flow may in many cases even be increased by the schemes themselves.
- 27 September 2017
- Published by Association for Computing Machinery (ACM) in ACM Transactions on Embedded Computing Systems
- Vol. 16 (5s) , 1-19
Open AccessDemystifying Soft-Error Mitigation by Control-Flow Checking -- A New Perspective on its Effectiveness
Soft errors are a challenging and urging problem in the domain of safety-critical embedded systems. For decades, checking schemes have been investigated and improved to mitigate soft-error effects for the class of control-flow faults, with current industrial standards strongly recommending their use. However, reality looks different: Taking a systems perspective, we implemented four representative Control-Flow Checking (CFC) schemes and put them through their paces in 396 fault-injection campaigns. In contrast to previous work, which typically relied on probability-based vulnerability metrics, we accounted for the influence of memory and time overheads on the fault-space dimensions and applied those in full-scan fault injections. This change in procedure alone severely degraded the perceived effectiveness of CFC. In addition, we expanded the perspective to data-flow faults and their influence on the overall susceptibility, an aspect that so far has been largely ignored. Our results suggest that, without accompanying measures, any improvement regarding control-flow faults is dominated by the increase in data faults caused by the increased attack surface in terms of memory and runtime overhead. Moreover, CFC performance less depended on the detection capabilities than on general aspects of the concrete binary compilation and execution. In conclusion, incorporating CFC is not as straightforward as often assumed and the vulnerability of systems with hardened control-flow may in many cases even be increased by the schemes themselves.
- 1 September 2017
- Published by Institute of Electrical and Electronics Engineers (IEEE)
- p. 1-6
The best of both: High-performance and deterministic real-time executive by application-specific multi-core SoCs
Embedded multi-core processors improve performance significantly and are desirable in many application-fields. This in particular includes safety-critical real-time systems, which typically require a deterministic temporal behavior. However, even tasks without dependencies running on different cores can interfere due to, sometimes hidden, shared hardware resources, such as common memories or buses. Consequently, only a pessimistic assumption of the worst-case execution time (WCET) that incorporates interference can be given. Hence, the aspired performance gain fizzles out in the poor temporal analyzability. Based on the fact that in safety-critical systems all tasks and their dependencies are known at compile-time, this paper presents an approach to generate application-specific, deterministic multi-core processor architectures for these systems. Thereby safety-critical tasks are executed on dedicated Deterministic Execution Units (DEUs) including lightweight, deterministic processor cores, bus systems, memories and peripherals. The remaining soft real-time tasks are executed on a general purpose multi-core processor that offers performance over determinism. Consequently, timing analysis for hard real-time tasks is significantly simplified, since interferences caused by shared resources and scheduling are effectively eliminated. To show the benefits of our approach, an application-specific architecture for a flight controller was generated and compared to an ARM Cortex-A9 dual-core as reference. Overall, we were able to significantly improve temporal properties of safety-critical tasks while preserving the overall performance for soft real-time tasks.
- 1 September 2017
- Published by Institute of Electrical and Electronics Engineers (IEEE)
- p. 1-6
The best of both: High-performance and deterministic real-time executive by application-specific multi-core SoCs
Embedded multi-core processors improve performance significantly and are desirable in many application-fields. This in particular includes safety-critical real-time systems, which typically require a deterministic temporal behavior. However, even tasks without dependencies running on different cores can interfere due to, sometimes hidden, shared hardware resources, such as common memories or buses. Consequently, only a pessimistic assumption of the worst-case execution time (WCET) that incorporates interference can be given. Hence, the aspired performance gain fizzles out in the poor temporal analyzability. Based on the fact that in safety-critical systems all tasks and their dependencies are known at compile-time, this paper presents an approach to generate application-specific, deterministic multi-core processor architectures for these systems. Thereby safety-critical tasks are executed on dedicated Deterministic Execution Units (DEUs) including lightweight, deterministic processor cores, bus systems, memories and peripherals. The remaining soft real-time tasks are executed on a general purpose multi-core processor that offers performance over determinism. Consequently, timing analysis for hard real-time tasks is significantly simplified, since interferences caused by shared resources and scheduling are effectively eliminated. To show the benefits of our approach, an application-specific architecture for a flight controller was generated and compared to an ARM Cortex-A9 dual-core as reference. Overall, we were able to significantly improve temporal properties of safety-critical tasks while preserving the overall performance for soft real-time tasks.
- 1 April 2017
- Published by Institute of Electrical and Electronics Engineers (IEEE)
- p. 37-48
SysWCET: Whole-System Response-Time Analysis for Fixed-Priority Real-Time Systems (Outstanding Paper)
The worst-case response time (WCRT) - the time span from release to completion of a real-time task - is a crucial property of real-time systems. However, WCRT analysis is complex in practice, as it depends not only on the realistic examination of worst-case execution times (WCET), but also on system-level overheads and blocking/preemption times. While the implicit path enumeration technique (IPET) has greatly improved automated WCET analysis, the resulting values still need to be aggregated manually with the system-level overheads - an errorprone and tedious process that yields overly pessimistic results. With SysWCET, we provide an integrated approach for the automated WCRT analysis across multiple threads of execution, locks, interrupt service routines, and the real-time operating system (RTOS) in particular. Our approach spans a single IPET formulation over the whole system and exploits RTOS and scheduler semantics to derive cross-kernel flow facts in order to significantly reduce pessimism in the WCRT analysis. We evaluate our approach with a fully functional implementation of SysWCET for the automotive OSEK-OS standard (ECC1), including threads, alarms, interrupt-service routines, events, and PCP-based resource management.
- 1 April 2017
- Published by Institute of Electrical and Electronics Engineers (IEEE)
- p. 37-48
SysWCET: Whole-System Response-Time Analysis for Fixed-Priority Real-Time Systems (Outstanding Paper)
The worst-case response time (WCRT) - the time span from release to completion of a real-time task - is a crucial property of real-time systems. However, WCRT analysis is complex in practice, as it depends not only on the realistic examination of worst-case execution times (WCET), but also on system-level overheads and blocking/preemption times. While the implicit path enumeration technique (IPET) has greatly improved automated WCET analysis, the resulting values still need to be aggregated manually with the system-level overheads - an errorprone and tedious process that yields overly pessimistic results. With SysWCET, we provide an integrated approach for the automated WCRT analysis across multiple threads of execution, locks, interrupt service routines, and the real-time operating system (RTOS) in particular. Our approach spans a single IPET formulation over the whole system and exploits RTOS and scheduler semantics to derive cross-kernel flow facts in order to significantly reduce pessimism in the WCRT analysis. We evaluate our approach with a fully functional implementation of SysWCET for the automotive OSEK-OS standard (ECC1), including threads, alarms, interrupt-service routines, events, and PCP-based resource management.
- 1 November 2016
- Published by Institute of Electrical and Electronics Engineers (IEEE)
- p. 363
Closing the loop: towards control-aware design of adaptive real-time systems
This paper proposes a continuous toolchain from the original control system model to the resulting schedules. As a first step towards control-aware yet adaptive system design, we focused on a global, context-sensitive analysis of control and data flow across control-application layers and threads of execution. This step is of vital importance as these dependencies manifest differently on the various levels of abstraction. Consequently, we extract semantics and internal dependencies directly from control-system models by an extended version of the Real-Time Systems Compiler (RTSC), which is capable of analyzing and transforming real-time applications on the source code level.
- 1 November 2016
- Published by Institute of Electrical and Electronics Engineers (IEEE)
- p. 363
Closing the loop: towards control-aware design of adaptive real-time systems
This paper proposes a continuous toolchain from the original control system model to the resulting schedules. As a first step towards control-aware yet adaptive system design, we focused on a global, context-sensitive analysis of control and data flow across control-application layers and threads of execution. This step is of vital importance as these dependencies manifest differently on the various levels of abstraction. Consequently, we extract semantics and internal dependencies directly from control-system models by an extended version of the Real-Time Systems Compiler (RTSC), which is capable of analyzing and transforming real-time applications on the source code level.
- 1 May 2016
- Published by Institute of Electrical and Electronics Engineers (IEEE)
- p. 134-141
From Intent to Effect: Tool-Based Generation of Time-Triggered Real-Time Systems on Multi-core Processors
Although the manual creation of time-triggered schedules for multi-core real-time systems can be a daunting task, state-of-the-art scheduling algorithms are far from being widely used. This suggests that the availability of sound algorithms is only one side of the story: real-time systems have to be groomed substantially before they can serve as input to available algorithms. Moreover, systems engineers struggle with the temporal effects of their design decisions, in addition to the intended timing properties. Therefore, we believe that appropriate tools are the other side of the story. In this paper, we present the multicore extension of the Real-Time Systems Compiler, a compiler-based tool that analyses given event-triggered real-time systems and transforms them into time-triggered equivalents. We focus on the challenges and pitfalls in the transition from theory to practical implementation and present concrete solutions to resolve them. Existing algorithms need to be adapted for performance and, at model level, bound together appropriately to be applicable, for example. Our experiments substantiate the effectiveness and scalability of our approach, even for large tasks sets. Finally, lessons learned give an insight into implementation and hardware details and their impact on schedulability.
- 1 May 2016
- Published by Institute of Electrical and Electronics Engineers (IEEE)
- p. 134-141
From Intent to Effect: Tool-Based Generation of Time-Triggered Real-Time Systems on Multi-core Processors
Although the manual creation of time-triggered schedules for multi-core real-time systems can be a daunting task, state-of-the-art scheduling algorithms are far from being widely used. This suggests that the availability of sound algorithms is only one side of the story: real-time systems have to be groomed substantially before they can serve as input to available algorithms. Moreover, systems engineers struggle with the temporal effects of their design decisions, in addition to the intended timing properties. Therefore, we believe that appropriate tools are the other side of the story. In this paper, we present the multicore extension of the Real-Time Systems Compiler, a compiler-based tool that analyses given event-triggered real-time systems and transforms them into time-triggered equivalents. We focus on the challenges and pitfalls in the transition from theory to practical implementation and present concrete solutions to resolve them. Existing algorithms need to be adapted for performance and, at model level, bound together appropriately to be applicable, for example. Our experiments substantiate the effectiveness and scalability of our approach, even for large tasks sets. Finally, lessons learned give an insight into implementation and hardware details and their impact on schedulability.
- 6 November 2015
- Published by Springer Nature
- p. 89-98
React in Time: Ereignisbasierter Entwurf zeitgesteuerter verteilter Systeme
- 6 November 2015
- Published by Springer Nature
- p. 89-98
React in Time: Ereignisbasierter Entwurf zeitgesteuerter verteilter Systeme