Due to increasing complexity of software in embedded systems, performance aspects become much more important this days. This should happen early in the development process. Often execution times and events are not easily countable or measurable due to a lack of functionality in these systems. Execution time monitoring is also relevant in terms of reacting to internal and external events dynamically. Especially for systems using multiple tasks with internal or external resource dependencies, this is a major discipline. Another problem is that measurements during the development process are often done by interfering the system as a whole. This method leads to biases in the measurement results, because the finalized system gets deployed without these interfering functionalities and can therefore work more efficiently than the development system. The scope of the present work is to develop a module in a hardware description language (HDL) which is able to measure execution times and events task-aware and unaware without interfering the system. The measurements of this module must be handed to the programmer through an easy accessible interface. The main focuses of the project are the scalability, platform independency concerning processor and operating system (OS), as well as easy extendibility. Also, reusability of counters during runtime is included in this work.

Smart, connected, and automated vehicles will have a significant impact on the safety, efficiency, and convenience of future transportation and mobility. However, most of the related services and technological features will be implemented in millions of lines of code running on hundreds of computers, embedded into each car. While classic automotive hardware and software are mainly designed statically and with just safety and real-time capability in mind, future systems also have to consider security and flexible maintenance aspects: Wireless communication across car boundaries requires solid protection against attackers and dynamic update mechanisms are required to reflect changing customer requirements and legal regulations throughout the entire lifetime of the cars. This article discusses specific challenges on embedded operating systems and processor architectures for highly dependable and compositional computing platforms in future vehicles. Intelligente, vernetzte und automatisierte Fahrzeuge werden erhebliche Auswirkungen auf die Sicherheit, Effizienz und den Komfort zukünftiger Verkehrsmittel und unsere Mobilität im Allgemeinen haben. Die meisten zugehörigen Dienste und Funktionen werden jedoch in Millionen von Codezeilen implementiert, die auf Hunderten von Computern ausgeführt werden, die in jedes Fahrzeug sowie die Infrastruktur eingebettet sind. Während klassische Fahrzeughardware und -software hauptsächlich statisch und mit Blick auf funktionale Sicherheit und Echtzeitfähigkeit konzipiert ist, müssen zukünftige Systeme auch die Systemsicherheit und flexible Wartungsaspekte berücksichtigen: Drahtlose Kommunikationskanäle über Fahrzeuggrenzen hinweg erfordern einen soliden Schutz gegen Angreifer, und dynamische Aktualisierungsmechanismen sind erforderlich, um ständig wechselnde Kundenanforderungen und gesetzliche Vorschriften während der gesamten Nutzungsdauer der Fahrzeuge zu berücksichtigen. Dieser Artikel zeigt spezifische Herausforderungen an eingebettete Hardware und Software für hochzuverlässige und kompositorische Computerplattformen zukünftiger Fahrzeuge.

As the number of embedded systems continues to grow, so does the amount of disposed electronic devices. This is mainly due to partially or fully outdated hardware, caused by new legal regulations in jurisdiction or cutting-edge features within a new generation of devices or hardware components. As most devices are designed without having long-term maintainability in mind and can be easily replaced without much monetary effort, it is often easier to dispose of them. This throw-away mentality, however, increases the carbon footprint enormously. Within this work, we propose a platform that can be used to design future embedded systems in a more sustainable way by preparing them for long-term hardware adaptations. To do so, we aim to make logic updatable and re-usable while the device stays operational. This is achieved by carefully co-designing an operating system and a microcontroller platform with reconfigurable logic. In this paper, we use a RISC-V-based microcontroller running on a field-programmable gate array. The said microcontroller is designed to feature a modular pipeline and replaceable on-chip peripherals alongside a partial reconfiguration controller that can hot-swap parts of the microcontroller while it is running. It is supported by an operating system that handles the reconfiguration as well as functionality emulation, in case it is not (yet) available in hardware. Both the hardware and the software are aware of each other and can manipulate shared data structures for the management of the reconfiguration concept. The experimental evaluation that was carried out on a Artix-7 device shows the proper operation alongside performance measurements and resource utilization of the on-the-fly reconfiguration of a proof-of-concept system without affecting the execution of the remainder of the system.

Embedded systems are built from various hardware components and execute software on one or more microcontroller units (MCU). These MCUs usually contain a fixed integrated circuit, thus disallowing modifications to their logic at runtime. While this keeps the instruction set architecture (ISA) fixed as well, it leaves the software as the only flexible part in the system. But what if the MCU logic could be easily changed at runtime in order to fix bugs or if the ISA could be extended on-the-fly in order to introduce application-specific instructions and features on demand?This work demonstrates a concept for introducing more hardware flexibility through application-specific MCU modifications. Therefore, the MCU is implemented as a soft core on a field-programmable gate array (FPGA) and we reconfigure its logic with support of the operating system (OS) running on it. The reconfiguration happens on-the-fly, so no interruption of the application code or even a system restart is required. Therefore, (i) the MCU pipeline is specially designed for extensibility by new instructions, and (ii) the FPGA is selected to support partial self-reconfiguration of its logic cells at runtime. As long as an instruction is not yet part of the ISA, the OS supports its emulation to provide a consistent interface for applications. Apart, no special compiler support is required, but the application must provide either the emulation code or a hardware description for adding the required logic. For a proof of concept, we use a RISC-V based MCU on a Xilinx Artix-7 FPGA and for evaluating the general benefit of our approach we use an algorithm that is costly when executed with the original ISA but fast with application-specific instructions added at runtime. The experimental evaluation also shows that the on-the-fly hardware update does not disrupt or compromise the software execution flow.

This paper presents an open-source approach to automatically stitch FPGA fabrics generated by FABulous. We use the Python API provided by OpenLane 2 to programmatically place pins and macros. The tiles of the fabric are arranged and stitched together depending on their size and the geometry of the FPGA. Thus, much faster design iterations can be achieved for various homogeneous FPGA fabrics. We compare fabric stitching with a simple, non-hierarchical approach, so-called sea of gates, in terms of time required for the physical implementation, maximum RAM usage and area demand. Our findings show that the sea of gates approach yields the best results in terms of area, but also requires significant runtime for large fabrics. For an FPGA with the size of 10×10 Configurable Logic Blocks, fabric stitching takes 12 times less runtime and consumes only 21% of the maximum RAM compared to the sea of gates approach for the same target density of 50%, as the tiles only need to be hardened once and are then stitched together. Fabric stitching with higher-density tiles (70%) reduces the area overhead to -4.17%, meaning less area demand than the sea of gates approach for just a small runtime increase. The physical implementation is performed using the open-source SKY130 PDK.