Current processors can no longer increase the computing power by using higher
cycle frequencies because this leads to inacceptable power consumption. Instead,
multiple processing cores are integrated to multicore CPUs. This architecture
now available at low prices is known from special high-performance computers
from some decades ago. Commodity software does not benefit from multiple cores
unless it is adapted to parallel execution.
The x86 architecture is so wide-spread and cheap that it is increasingly
implemented in embedded and real-time systems with high performance needs.
On one hand, this allows to use common operating systems and available software.
But on the other hand, general purpose operating systems do not support real-time
needs sufficiently. A number of special real-time OS (RTOS) exist, but they
generally do not support commodity software. In addition, a variety of operating
system extensions are available, but they are tied closely to supported versions
of a kernel.
Mixed Hard Real-Time and High-Performance Computing on Multicore Processors
To analyse the applications of multicore architectures in real-time computing,
this project aims at realizing hard real-time in a userspace process without
(or with only minor) modifications to the kernel. Currently, it supports
all recent versions of the Linux kernel but the basic ideas should work on
With real-time scheduling, the high-priority tasks are executed preferentially,
but they are still interfered by interrupts and unpredictable latencies in
system calls. The goal of this project is to execute code on one (or some) of
the cores without (or with only minor) interference with the operating system.
This comes close to executing code without an operating system directly on the
processor. To allow the interaction between the shielded code and the rest of
the system, an interface will be developed that is designed with regard to
hard real-time needs.
An exemplary system with a quad-core processor could be designed as follows:
One core executes hard real-time code. This core has interrupts deactivated
and the code does not call any system calls after initialization. A second
core executes some real-time scheduled tasks that connect the hard real-time
tasks to the userspace processes and provide services like asynchronous
system calls. The two remaining cores are free for arbitrary programs to use
as much computing power as available.