Project Oberon: the design of an operating system and compiler
Project Oberon: the design of an operating system and compiler
Extensibility safety and performance in the SPIN operating system
SOSP '95 Proceedings of the fifteenth ACM symposium on Operating systems principles
Communications of the ACM
The performance of μ-kernel-based systems
Proceedings of the sixteenth ACM symposium on Operating systems principles
EMERALDS: a small-memory real-time microkernel
Proceedings of the seventeenth ACM symposium on Operating systems principles
Continuous Program Optimization: Design and Evaluation
IEEE Transactions on Computers
The embedded machine: predictable, portable real-time code
PLDI '02 Proceedings of the ACM SIGPLAN 2002 Conference on Programming language design and implementation
Real-Time Systems: Design Principles for Distributed Embedded Applications
Real-Time Systems: Design Principles for Distributed Embedded Applications
Synchronous Programming of Reactive Systems
Synchronous Programming of Reactive Systems
Maté: a tiny virtual machine for sensor networks
Proceedings of the 10th international conference on Architectural support for programming languages and operating systems
Reliable and Precise WCET Determination for a Real-Life Processor
EMSOFT '01 Proceedings of the First International Workshop on Embedded Software
Time-Safety Checking for Embedded Programs
EMSOFT '02 Proceedings of the Second International Conference on Embedded Software
TinyGALS: a programming model for event-driven embedded systems
Proceedings of the 2003 ACM symposium on Applied computing
Composable code generation for distributed giotto
LCTES '05 Proceedings of the 2005 ACM SIGPLAN/SIGBED conference on Languages, compilers, and tools for embedded systems
A hierarchical coordination language for interacting real-time tasks
EMSOFT '06 Proceedings of the 6th ACM & IEEE International conference on Embedded software
A virtual machine for sensor networks
Proceedings of the 2nd ACM SIGOPS/EuroSys European Conference on Computer Systems 2007
The embedded machine: Predictable, portable real-time code
ACM Transactions on Programming Languages and Systems (TOPLAS)
ACM Transactions on Embedded Computing Systems (TECS)
Predictable actor-oriented design strategies for timing-centric distributed embedded software
CAR'10 Proceedings of the 2nd international Asia conference on Informatics in control, automation and robotics - Volume 2
An extensible software framework for reliable distributed embedded system modeling
CAR'10 Proceedings of the 2nd international Asia conference on Informatics in control, automation and robotics - Volume 2
Separate compilation of hierarchical real-time programs into linear-bounded Embedded Machine code
Science of Computer Programming
Hi-index | 0.00 |
We present a new software system architecture for the implementation of hard real-time applications. The core of the system is a microkernel whose reactivity (interrupt handling as in synchronous reactive programs) and proactivity (task scheduling as in traditional RTOSs) are fully programmable. The microkernel, which we implemented on a StrongARM processor, consists of two interacting domain-specific virtual machines, a reactive E (Embedded) machine and a proactive S (Scheduling) machine. The microkernel code (or microcode) that runs on the microkernel is partitioned into E and S code. E code manages the interaction of the system with the physical environment: the execution of E code is triggered by environment interrupts, which signal external events such as the arrival of a message or sensor value, and it releases application tasks to the S machine. S code manages the interaction of the system with the processor: the execution of S code is triggered by hardware interrupts, which signal internal events such as the completion of a task or time slice, and it dispatches application tasks to the CPU, possibly preempting a running task. This partition of the system orthogonalizes the two main concerns of real-time implementations: E code refers to environment time and thus defines the reactivity of the system in a hardware- and scheduler-independent fashion; S code refers to CPU time and defines a system scheduler. If both time lines can be reconciled, then the code is called time safe; violations of time safety are handled again in a programmable way, by run-time exceptions. The separation of E from S code permits the independent programming, verification, optimization, composition, dynamic adaptation, and reuse of both reaction and scheduling mechanisms. Our measurements show that the system overhead is very acceptable even for large sets of task, generally in the 0.2--0.3% range.