Reconfigurable Operating System Research Articles

The Adaptive Avionics Platform

Current avionics systems are composed of standardized components. Configuring these components requires millions of configuration parameters. The creation of configurations requires a lot of time and effort in the avionics development process. The AAP consists of standardized modules for computing and peripheral interaction that are self-configuring and fault tolerant. During an organizational phase, the actual topology is detected, the applications are distributed, and all message routes are configured. With an ACMS, the feasibility of the AAP is shown. The ACMS utilizes COTS components, POSIX-API, and Ethernet. In 2.5 min., it is able to configure itself. Moreover, it can withstand a single hardware fault in CPMs, I0Ms, and the network without extra effort. Due to the lack of a reconfigurable certifiable operating system, missing hard real-time capabilities and certifiability are the greatest drawback that will be addressed in the future. The aim is to enable self-configuring and self-fault-tolerant avionics in the safety-critical domain up to DAL A.

An Efficient Evolutionary Task Scheduling/Binding Framework for Reconfigurable Systems

Several embedded application domains for reconfigurable systems tend to combine frequent changes with high performance demands of their workloads such as image processing, wearable computing, and network processors. Time multiplexing of reconfigurable hardware resources raises a number of new issues, ranging from run-time systems to complex programming models that usually form a reconfigurable operating system (ROS). In this paper, an efficient ROS framework that aids the designer from the early design stages all the way to the actual hardware implementation is proposed and implemented. An efficient reconfigurable platform is implemented along with novel placement/scheduling algorithms. The proposed algorithms tend to reuse hardware tasks to reduce reconfiguration overhead, migrate tasks between software and hardware to efficiently utilize resources, and reduce computation time. A supporting framework for efficient mapping of execution units to task graphs in a run-time reconfigurable system is also designed. The framework utilizes an Island Based Genetic Algorithm flow that optimizes several objectives including performance, area, and power consumption. The proposed Island Based GA framework achieves on average 55.2% improvement over a single-GA implementation and an 80.7% improvement over a baseline random allocation and binding approach.

Efficient integration of online model checking into a small‐footprint real‐time operating system

SummaryFor highly safety‐critical applications, rigorous offline verification should be complemented by online verification. One promising technique is Online Model Checking (OMC). The basic approaches on how to design and implement OMC have been discussed in a couple of papers. As OMC is a run‐time‐provided service, it seems to be natural providing it by an operating system (OS) service like any other service offered by the OS. In this paper, we study the feasibility of this approach, that is, whether OMC can be integrated efficiently into an OS. As we are dealing with real‐time systems, the OS in our case is a real‐time operating system (RTOS). This study makes use of a specific OMC system, implemented in our group. We also have implemented a highly efficient RTOS with an extremely small footprint, called ORCOS (Organic ReConfigurable Operating System). Therefore, we use ORCOS as an example RTOS to investigate the feasibility of integrating OMC as an RTOS service. The correctness of the RTOS is not subject to be verified in this case; it is just the service provider. In order to ease understanding the approach, the paper contains a brief introduction into the fundamental concepts of OMC and the way to provide it as an integrated RTOS service. Additionally, basic principles of ORCOS are presented. Based on these foundations, we discuss various integration methods. OMC may become an integral part of the RTOS; it may become a separate task running on the same host as the RTOS, or it may be implemented on a remote host as a kind of service‐oriented architecture. In all three cases, OMC runs concurrently to the application task to be online model checked. We argue that the second approach turns out to be the most appropriate one. It is well suited to state‐of‐the‐art hypervisor‐based mixed criticality architectures, running on a multi‐core hardware platform. In addition, the service‐oriented architecture is discussed as well, however only marginally. To test the feasibility of the approach, an analytical investigation of the implied overhead is carried out. This investigation is complemented by experiments based on a prototype implementation. The promising results obtained by these two studies then are further underpinned by a realistic case study. We use the resolution advisory component of traffic alert and collision avoidance system for this purpose. Copyright © 2015 John Wiley & Sons, Ltd.

Use of Extended Adaptive Decision Tables on Reconfigurable Operating Systems

Throughout the last decades, many reconfigurable operating systems have been developed in order to let users and programmers make decisions upon the configuration of some of the innermost kernel's aspects. These decisions, however, require an advanced level of skill in order to obtain some performance advantage. Furthermore, they can be detrimental to the system's performance if they are not careful taken. Letting the kernel itself do the decision-making upon the implementation of its aspects is a safe and powerful way to manage re-configurability that does not require interaction with the user nor the need of advanced skills to take advantage of. In this article, we propose the usage of Extended Adaptive Decision Tables as a mean for the kernel to achieve the capability of taking intelligent decisions based solely on the users' process creation behavior.

Self-Awareness as a Model for Designing and Operating Heterogeneous Multicores

Self-aware computing is a paradigm for structuring and simplifying the design and operation of computing systems that face unprecedented levels of system dynamics and thus require novel forms of adaptivity. The generality of the paradigm makes it applicable to many types of computing systems and, previously, researchers started to introduce concepts of self-awareness to multicore architectures. In our work we build on a recent reference architectural framework as a model for self-aware computing and instantiate it for an FPGA-based heterogeneous multicore running the ReconOS reconfigurable architecture and operating system. After presenting the model for self-aware computing and ReconOS, we demonstrate with a case study how a multicore application built on the principle of self-awareness, autonomously adapts to changes in the workload and system state. Our work shows that the reference architectural framework as a model for self-aware computing can be practically applied and allows us to structure and simplify the design process, which is essential for designing complex future computing systems.

Efficient On-Chip Task Scheduler and Allocator for Reconfigurable Operating Systems

This letter presents efficient and modular task scheduler and allocator support for dynamically and partially reconfigurable electronic systems. This enables hardware tasks to be preempted and arbitrarily placed at an optimal position on the chip on-the-fly. In particular, we present a novel fault-tolerant allocating algorithm called “best-fit empty area compact (BF-EAC),” and its on-chip implementation on a Xilinx Virtex-4 field-programmable gate array (FPGA), which circumvents emerging faults while maintaining more compact empty areas for emerging tasks. We also present an implementation of the early deadline first (EDF) scheduling heuristic used to optimize the chronological order of execution of hardware tasks to meet real time constraints. Put together, the placement and scheduling architecture efficiently exploits chip resources with a μs-grade computing speed and a lightweight footprint (less than 500 slices).

Configuration Reusing in On-Line Task Scheduling for Reconfigurable Computing Systems

Reconfigurable computing systems can be reconfigured at runtime and support partial reconfigurability which makes us able to execute tasks in a true multitasking manner. To manage such systems at runtime, a reconfigurable operating system is needed. The main part of this operating system is resource management unit which performs on-line scheduling and placement of hardware tasks at runtime. Reconfiguration overhead is an important obstacle that limits the performance of on-line scheduling algorithms in reconfigurable computing systems and increases the overall execution time. Configuration reusing (task reusing) can decrease reconfiguration overhead considerably, particularly in periodic applications or the applications in which the probability of tasks recurrence is high. In this paper, we present a technique called reusing-based scheduling (RBS), for on-line scheduling and placement in which configuration reusing is considered as a main characteristic in order to reduce reconfiguration overhead and decrease total execution time of the tasks. Several experiments have been conducted on the proposed algorithm. Obtained results show considerable improvement in overall execution time of the tasks.

Architecting reconfigurable component-based operating systems

Dynamic reconfiguration allows modifying a system during its execution, and can be used to apply patches and updates, to implement adaptive systems, dynamic instrumentation, or to support third-party modules. Dynamic reconfiguration is important in embedded systems, where one does not necessarily have the luxury to stop a running system. While several proposals have been presented in the literature supporting dynamic reconfiguration in operating system kernels, these proposals in general hardwire a fixed reconfiguration mechanism, which may be far from optimal in certain configurations. In this paper, we present a software-architecture-based approach to the construction of reconfigurable operating systems, and we show that it allows us (i) to support different mechanisms for dynamic reconfiguration, and (ii) to select between them at build time, with little or no changes in operating system and application components. Our approach relies on the use of a reflective component model and of its associated architecture description language.

SmartApps

One general avenue to obtain optimized performance on large and complex systems is to approach optimization from a global perspective of the complete system in a customized manner for each application, i.e., application-centric optimization . Lately, there have been encouraging developments in reconfigurable operating systems and hardware that will enable customized optimization. For example, machines built with PIM's and FPGA's can be quickly reconfigured to better fit a certain application and operating systems, such as IBM's K42, can have their services customized to fit the needs and characteristics of an application. While progress in operating system and hardware and hardware has made re-configuration possible, we still need strategies and techniques to exploit them for improved application performance.In this paper, we describe the approach we are using in our smart application (SMARTAPPS) project. In the SMARTAPP executable, the compiler embeds most run-time system services and a feedback loop to monitor performance and trigger run-time adaptations. At run-time, after incorporating the code's input and determining the system's state, the SMARTAPP performs an instance specific optimization. During execution, the application continually monitors its performance and the available resources to determine if restructuring should occur. The framework includes mechanisms for performing the actual restructuring at various levels including: algorithmic adaptation, tuning reconfigurable OS services (scheduling policy, page size, etc.), and system configuration (e.g., number of processors). This paper concentrates on the techniques for providing customized system services for communication, thread scheduling, memory management, and performance monitoring and modeling.