![](bg9.png)
hundred μs latency (Abeni, 2002), but still the result
is not enough by a factor of ten comparing to typical
RTOSes. Even though the mechanism is potentially
capable of achieving real-time responsiveness, it
could be easily spoiled by bad-mannered device
drivers, which disable interrupts for a long period.
Porting existing programs from RTOS to Linux
would increase the risk of implementing such device
drivers, due to the differences between the
programming models of RTOS and Linux. Also, the
developers usually using RTOS are unfamiliar with
programming on Linux. Then, the possibility to
write bad mannered device drivers becomes high. In
addition, porting all the software from RTOS to
Linux would impose the substantial engineering
cost.
Another approach, known as the hybrid system,
is to execute RTOS in the GPOS kernel. RTLinux
and RTAI replace the Linux hardware abstraction
layer with their own version of RTOSes
(Mantegazza, 2000); (Yodaiken, 1999). Those
RTOSes would be executed in the kernel mode
together with the Linux kernel. The interrupt
response time would only be a few μs, which is
comparable to typical RTOSes. However those
RTOSes only support their original programming
interfaces, which prevents the straight-forward reuse
of some existing real-time software developed for
traditional RTOSes. Linux on ITRON is an
alternative system to RTLinux and RTAI, which
replaces the Linux hardware abstraction layer with
the existing RTOS, μITRON (Takada, 2002). This
architecture enables the system to reuse both the
software developed for Linux and μITRON. The
hybrid system provides the high real-time
responsiveness comparable with RTOS with the
reasonable engineering cost because a large amount
of existing software for embedded systems in Japan
has been developed on μITRON. However,
considering another combination of RTOS and
GPOS would impose redesigning the hybrid system
again from scratch. Because it is usual for
manufacturers to leverage diverse RTOSes, this
engineering cost would be problematic.
A virtual machine monitor (VMM) is another
technology focusing on accommodating RTOS and
GPOS into a single embedded device without the
modifications or with just the minimal modifications
to the OS kernels (Heiser, 2008). VMM provides a
virtual hardware interface which is identical (or
almost identical) to some real hardware and the
isolation mechanism between virtualized guest
OSes. VMM supporting the full-virtualization
technique exposes a virtual hardware interface
identical to a real hardware interface. OSes can be
executed without any modification on the full-
virtualization based VMM. However, implementing
the full-virtualization technique complicates the
design of VMM itself or requires special hardware
supports for the hardware virtualization.
Unfortunately, the hardware supports for the
hardware virtualization is still an unfamiliar feature
for embedded system processors. This motivates
VMM for embedded system to use the para-
virtualization technique. The L4 microkernel is a
typical system to offer the para-virtualization
interface for embedded system. However, the
engineering cost required for para-virtualizing a
guest OS kernel is also problematic as described in
Section 4.2. In addition, switching the privilege
levels between a guest OS and VMM will entail the
significant performance degradation.
In order to achieve the low engineering cost
while not penalizing performance, SPUMONE
executes OS kernels and itself in the privileged
mode. This also contributes to reduce the
engineering cost of modifying OS kernels, because
the majority of privileged instructions can be
executed by a processor directly and only a minimal
set of instructions needs to be emulated.
Furthermore, SPUMONE multiplexes only minimal
hardware resources, while other resources are
exclusively assigned to each OS by simply
modifying each OS kernel not to access the same
hardware resources.
There are some researches on how to design
scalable OSes on multi-core and many-core
processors. Corey is a many-core operating which
allows applications to explicitly specify the
assignment of critical OS kernel data structures
among cores (Wickizer, 2008). This hints the kernel
to schedule processes to improve the cache locality.
Multikernel is an experimental OS kernel which
exploits the multi-core and many-core processor
parallelism by constructing the system with the
distributed model (Baumann, 2009). SPUMONE’s
basic design is similar to Multikernel, but our
contribution is to reuse existing software programs
developed on the top of various existing OSes while
satisfying the real-time responsiveness.
6 CONCLUSIONS
In this paper we proposed a light-weight
virtualization layer which achieves the low overhead
and low engineering cost to construct multi-OS
embedded systems. In addition, we evaluated the
A STUDY ON REAL-TIME RESPONSIVENESS ON VIRTUALIZATION BASED MULTI-OS EMBEDDED
SYSTEMS
377