Uwe Brinkschulte

Real-time event-handling and scheduling on a multithreaded Java microcontroller

Abstract Our aim is to investigate the suitability of hardware multithreading for real-time event handling in combination with appropriate real-time scheduling techniques. We designed and evaluated a multithreaded microcontroller based on a Java processor core. Java threads are used as Interrupt Service Threads (ISTs) instead of the Interrupt Service Routines (ISRs) of conventional processors. Our proposed Komodo microcontroller supports multiple ISTs with zero-cycle context switching overhead. A so-called priority manager implements several real-time scheduling algorithms in hardware. We show the feasibility of a hardware real-time scheduler integrated deeply into the processor pipeline with a VHDL design and its synthesis. Evaluations with a software simulator and real-time applications as benchmarks show that hardware multithreading reaches a 1.2–1.4 performance increase for hard real-time applications (multithreading without latency utilization) and a 2.0–2.6 speedup by latency utilization for programs without hard real-time requirements. With respect to real-time scheduling on a multithreaded microcontroller, the Least Laxity First (LLF) scheme outperforms the Fixed Priority Preemptive (FPP), Earliest Deadline First (EDF), and Guaranteed Percentage (GP) schemes, but suffers from the highest implementation costs.

Real-time scheduling on multithreaded processors

This paper investigates real-time scheduling algorithms on upcoming multithreaded processors. As evaluation testbed we introduce a multithreaded processor kernel which is specifically designed as core processor of a micro-controller or system-on-a-chip. Handling of external real-time events is performed through multithreading. Real-time threads are used as interrupt service threads (ISTs) instead of interrupt service routines (ISRs). Our proposed micro-controller supports multiple ISTs with zero-cycle context switching overhead. We investigate the behavior of fixed priority preemptive, earliest deadline first, least laxity first and guaranteed percentage scheduling with respect to multithreaded processors. Our finding is that the strategies GP and LLF result in a good blending of instructions of different threads thus enabling a multithreaded processor to utilize latencies best. Assuming a zero-cycle context switch LLF performs best, however implementation cost context, are prohibitive.

A multithreaded Java microcontroller for thread-oriented real-time event-handling

We propose a multithreaded Java microcontroller (called Komodo microcontroller) with a new hardware event handling mechanism that allows handling of simultaneous overlapping events with hard real-time requirements. Real-time Java threads are used as interrupt service threads (ISTs) instead of interrupt service routines (ISRs). Our proposed Komodo microcontroller supports multiple ISTs with zero-cycle context switching overhead. We evaluate the basic architectural attributes using real-time event parameters of an autonomous guided vehicle. When calculating the maximum vehicle speed without violating the real-time constraints, ISTs dominate ISRs by a speed increase of 28%.

Towards an artificial hormone system for self-organizing real-time task allocation

This article presents the concept of an artificial hormone system for a completely decentralized realization of self-organizing task allocation. We show that tight upper bounds for the real-time behavior of self-configuration can be given. We also show two simulation results using the artificial hormone system demonstrating the operation of the artificial hormone system under different workloads.

The Komodo project: thread-based event handling supported by a multithreaded Java microcontroller

The Komodo project concerns the handling of multiple real-time events by Java threads that are supported by a multithreaded Java microcontroller. The architecture of the processor core and resulting implications are considered. The use of thread-based event handling is introduced and explained in combination with an Automatic Guided Vehicle (AGV) application. The advantages of thread-based event handling over a normal Interrupt Service Routine (ISR) strategy are demonstrated by the development of the AGV example.

Real-time garbage collection for a multithreaded Java microcontroller

We envision the upcoming of microcontrollers and systems-on-chip that are based on multithreaded processor kernels due to the fast context switching ability of hardware multithreading. Moreover we envision an extensive market for Java-based applications in embedded real-time systems. This paper introduces two new garbage collection algorithms that are dedicated to real-time garbage collection on a multithreaded Java microcontroller. Our garbage collector runs in a thread slot in parallel to real-time applications. We show that our algorithms require only about 5–10% of the processor time for an effective garbage collection concerning our real-time benchmarks.

Dynamic real-time reconfiguration in distributed systems: timing issues and solutions

Dynamic software reconfiguration is a useful tool to adapt and maintain software systems. In most approaches, the system has to be stopped while the reconfiguration is in progress. This is not suitable for real-time systems, even on small-embedded systems. Timing constraints must be met even while the system is reconfiguring. Our approach is based on the real-time middleware OSA+. Our main objective is to be able to reconfigure services during run-time, with a predictable and predefined blackout time (the time the systems does not react due to the reconfiguration). Three different approaches concerning the blocking or non-blocking state of a service are presented. These approaches can be used to realize a tradeoff between the reconfiguration time and the blackout time.

An Artificial Hormone System for Self-Organizing Real-Time Task Allocation in Organic Middleware

This article presents an artificial hormone system for a completely decentralized realization of self-organizing task allocation. We show that tight upper bounds for the real-time behavior of self-configuration, self-optimization and self-healing can be given. We also calculate the communication load produced by the hormone system and find it acceptable.

A microkernel middleware architecture for distributed embedded real-time systems

Today more and more embedded real-time systems are implemented in a distributed way. These distributed embedded systems consist of a few controllers up to several hundreds. Distribution and parallelism in the design of embedded real-time systems increase the engineering challenges and require new methodological framework based on middleware. Our research work focuses on the development of a middleware that supports the design of heterogeneous distributed real-time systems and allows the use of small microcontrollers as computation nodes. Our study is aimed to a new approach that led to the development of OSA+-a scalable service-oriented real-time middleware architecture. This middleware has been used as the basic platform for different domain applications: (i) conception of an autonomous guided vehicle system based on multithreaded Java microcontrollers and (ii) development of a permanent monitoring distributed system for an oil drilling application. This paper presents the basic architecture of OSA+ and its implementation for the distributed real-time embedded systems design.

Guiding Organic Management in a Service-Oriented Real-Time Middleware Architecture

To cope with the ever increasing complexity of todays computing systems, the concepts of organic and autonomic computing have been devised. Organic or autonomic systems are characterized by so-called self-X properties such as self-configuration and self-optimization. This approach is particularly interesting in the domain of distributed, embedded, real-time systems. We have already proposed a service-oriented middleware architecture for such systems that uses multi-agent principles for implementing the organic management. However, organic management needs some guidance in order to take dependencies between services into account as well as the current hardware configuration and other application-specific knowledge. It is important to allow the application developer or system designer to specify such information without having to modify the middleware. In this paper, we propose a generic mechanism based on capabilities that allows describing such dependencies and domain knowledge, which can be combined with an agent-based approach to organic management in order to realize self-X properties. We also describe how to make use of this approach for integrating the middlewares organic management with node-local organic management.