Using reference counting is a popular approach when working with dynamically allocated memory in C programs to improve the memory safety properties of a system. As C has no facilities to insert the required reference counting operations automatically, the programmer remains responsible for inserting them at the appropriate places. Relying on humans for this task continues to be error-prone, as missing or duplicated operations can lead to memory leaks or use-after-free anomalies. To aid the programmer in handling reference-counted objects correctly, we propose a static analyzer that detects inconsistent reference counters and potential use-after-free anomalies. Our approach does not use conventions or heuristics for its analysis; instead, we introduced source code annotations that codify the intended behavior of functions. The analysis was implemented as part of the FAUCCC static analyzer and is used to check the source code of the JITTY operating system. Only 220 function annotations were required for a code base of 180k lines of C code. Additional annotations on function parameters, non-local variables, and struct members enable the use-after-free anomaly detection.

Operating systems are crucial for the performance of the overall system. Any inefficiency leads to a suboptimal use of the available resources and causes performance loss. The wide range of processors in use today makes it challenging to generate the most efficient code for the current hardware ahead of time. Just-in-time compilation, on the other hand, is able to generate efficient code tailored to the current execution context going beyond the processor, also including operating-system configuration or application demands. Moreover, its configuration can even be adapted at runtime to match the current external and internal requirements. Unfortunately, on-demand compilation of operating-system code has not found widespread use due to inherent difficulties stemming from the fact that any just-in-time approach requires extensive runtime support (e.g., for memory allocation for the generated code) usually provided by the operating system itself. A chicken-and-egg problem is found.

As computer processors and their hardware designs continuously evolve, operating systems provide many different assembly-level implementations for the same functionality. This enables support for new platforms and ensures backward compatibility for older ones at the same time. However, the source code of operating systems grows more complex and becomes much harder to maintain.

Energy-neutral real-time systems harvest the entire energy they use from their environment. In such systems, energy must be treated as an equally important resource as time, which creates the need to solve a number of problems that so far have not been addressed by traditional real-time systems. In particular, this includes the scheduling of tasks with both time and energy constraints, the monitoring of energy budgets, as well as the survival of blackout periods during which not enough energy is available to keep the system fully operational. In this article, we address these issues presenting E n OS, an operating-system kernel for energy-neutral real-time systems. E n OS considers mixed time criticality levels for different energy criticality modes, which enables a decoupling of time and energy constraints when one is considered less critical than the other. When switching the energy criticality mode, the system also changes the set of executed tasks and is therefore able to dynamically adapt its energy consumption depending on external conditions. By keeping track of the energy budget available, E n OS ensures that in case of a blackout the system state is safely stored to persistent memory, allowing operations to resume at a later point when enough energy is harvested again.

Reliable and fine-grained cost-models are fundamental for real-time systems to statically predict worst-case execution time (WCET) estimates of program code in order to guarantee timeliness. Analogous considerations hold for energy-constrained systems where worst-case energy consumption (WCEC) values are mandatory to ensure meeting predefined energy budgets. These cost models are generally unavailable for commercial off-the-shelf (COTS) hardware platforms, although static worst-case analysis tools require those models in order to predict the WCET as well as the WCEC of program code. To solve this problem, we present NEO, an end-to-end toolchain to automate cost-model generation for both WCET and WCEC analyses. NEO exploits automatically generated benchmarks, which are input for 1) an instruction-level emulation and 2) automatically conducted execution-time and energy-consumption measurements on the target platform. The gathered values (i.e., occurrences per instruction, execution-time and energyconsumption per benchmark) are combined as mathematical optimization problems. The solutions to the formulated problems, which are designed to reveal the worst-case behavior, yield the respective cost models. To statically determine upper bounds of benchmarks, we integrated the cost models into the stateof-the-art WCET analyzer PLATIN. Our evaluations on COTS hardware reveal that our open-source, end-to-end toolchain NEO yields accurate worst-case bounds.

Energy-neutral real-time systems harvest the entire energy they use from their environment, making it essential to treat energy as an equally important resource as time. As a result, such systems need to solve a number of problems that so far have not been addressed by traditional real-time systems. In particular, this includes the scheduling of tasks with both time and energy constraints, the monitoring of energy budgets, as well as the survival of blackout periods during which not enough energy is available to keep the system fully operational. In this paper, we address these issues presenting ENOS, an operating-system kernel for energy-neutral real-time systems. ENOS considers mixed time criticality levels for different energy criticality modes, which enables a decoupling of time and energy constraints during phases when one is considered less critical than the other. When switching the energy criticality mode, the system also changes the set of tasks to be executed and is therefore able to dynamically adapt its energy consumption depending on external conditions. By keeping track of the energy budget available, ENOS ensures that in case of a blackout the system state is safely stored to persistent memory, allowing operations to resume at a later point when enough energy is harvested again.

FAUmachine is a virtual machine for the highly detailed simulation of standard PC hardware together with an environment. FAUmachine comes with fault injection capabilities and an automatic experiment controller facility. Due to its use of just-in-time compiler techniques, it offers good performance. This tool description introduces the new feature of FAUmachine to simulate systems deterministically. This will enable developers to design and test complex systems for fault tolerance by running identically reproducible automated tests in reasonable time and thus even allow testing for real time constraints.

Dependability benchmarking is performance benchmarking extended by dependability aspects. It is an essential feature of benchmarks of any kind, that they make possible the fair evaluation and comparison of a system’s attributes. To avoid biased benchmarking results, independent teams should be able to repeat the benchmark of a system and produce results similar to those of the original benchmark. A semantically unambiguous description of the benchmark setup is a major step towards the goal of reproducible benchmarking experiments. This paper introduces a VHDL-based method for semantically unambiguous benchmark setup description of both the static and dynamic aspects of benchmarks in general. The approach proposed uses VHDL only as unambiguous description and modeling language and does not place restrictions on the actual evaluation of the experiment in any way. A dependability benchmarking experiment using this method is presented.

The UMLinux [3] environment provides virtualmachines on top of which the Linux operating sys-temandoff-the-shelfsoftwareisinstalled. UsingUM-Linux, you can set up systems consisting of severalnetworked virtual machines.A userfriendly GUI guides you through the processof configuring the virtual hardware. Once the hard-ware is set up, you can proceed to boot the Linux op-eratingsystemandinstalloff-the-shelfsoftwarejustasyou would on a real machine. Thus popular Linux dis-tributions like RedHat or SuSE and software like theOracle database system run on top of the virtual ma-chines out of the box. The GUI allows you to controlvirtual machines interactively, just as though you weresitting in front of them. You have access to (virtual)keyboard, mouse, and monitor as well as the system’sdrivesandon/offbuttons. AUMLinuxvirtualmachineisfullynetworkcapableandyoucanconnectittoothervirtual machines as well as to real machines. The GUIwill guide you through the process of setting up thenetwork connections. To analyse a system’s behaviourin the presence of faults and to set up worst-case sce-narios,youcanusetheGUItoinjectfaultsinthehard-ware of a virtual machine.