Mario Aldea Rivas

MaRTE OS: An Ada Kernel for Real-Time Embedded Applications

MaRTE OS (Minimal Real-Time Operating System for Embedded Applications) is a real-time kernel for embedded applications that follows the Minimal Real-Time POSIX.13 subset, providing both the C and Ada language POSIX interfaces. It allows cross-development of Ada and C real-time applications. Mixed Ada-C applications can also be developed, with a globally consistent scheduling of Ada tasks and C threads. Details on the architecture and implementation of the kernel are described, together with some performance metrics.

Evaluation of new POSIX real-time operating systems services for small embedded platforms

The ongoing revision of the POSIX.13 standard - real-time profiles for portable operating system interfaces - proposes adding services to the minimum real-time system profile that are considered useful to the small embedded applications to which this profile is targeted. Concerns have been raised that these services may introduce too much overhead or may be difficult to implement. In this paper, we evaluate the implementation of some of these services in our MaRTE operating system. The implemented services are the monotonic clock, a high resolution sleep operation with specifiable clock, execution-time clock and timers, the sporadic server scheduling policy, and the timed mutex lock operation. We show that the complexity of these implementations is small, and the overheads introduced by the new services are fully acceptable.

Application-defined scheduling in Ada

This paper is a proposal for an application program interface (API) that would enable Ada applications to use application-defined scheduling algorithms in a way compatible with the scheduling model of the Ada 95 Real-Time Systems Annex. With this API, several application-defined schedulers, implemented by extending a tagged type, can coexist in the system in a predictable way together with their scheduled tasks, and with regular fixed priority tasks directly scheduled by the run-time system. Task synchronization through protected objects is also considered by adding the Stack Resource Policy, which can be used in a large variety of fixed and dynamic priority scheduling policies.

Implementing and Using Execution Time Clocks in Ada Hard Real-Time Applications

Off-line analysis techniques for hard real-time systems are all based on the assumption that we can estimate the worst-case execution time of the different tasks executing in the system. In the traditional cyclic-executive schedulers, execution time limits were enforced for each task by the scheduler. Unfortunately, in concurrent hard real-time systems such as those using the tasking model defined in Ada, no bound on the execution time of tasks is enforced, which may result in a system timing malfunction not detected by the analysis techniques. In this paper we explore the implementation of execution time clocks within the task scheduler, and we describe methods to detect execution time overruns in the application, and to limit their effects. We also discuss the use of execution time clocks to enhance the performance of sporadic server schedulers implemented at the application level.

Extending Ada's real-time systems annex with the POSIX scheduling services

In this paper we propose extending the scheduling model of the Ada 95 Real-Time Systems Annex with the services specified in the Real-Time POSIX standard. These services include a round robin within priorities scheduling policy, a sporadic server scheduling policy, and execution time clocks and timers. With these services the Ada Real-Time Annex will enable addressing a larger number of application requirements.

Implementation of the Ada 2005 Task Dispatching Model in MaRTE OS and GNAT

The Ada 2005 task dispatching model includes new scheduling policies such as EDF and round robin, in addition to the traditional fixed priority dispatching, and allows mixing these policies into a hierarchy of schedulers. This hierarchical scheduling model is a very interesting solution that allows us to have in the same system the best properties of the three policies: the high performance of EDF, the predictability of fixed priorities, and the fair distribution of unused capacity provided by a round robin scheduler. The paper presents one of the first implementations of this hierarchical dispatching model, built with GNAT over MaRTE OS. An evaluation of the implementation is provided and examples of usage are shown.

Operating system support for execution time budgets for thread groups

The recent Ada 2005 standard introduced a number of new real-time services, with the capability of creating and managing execution time budgets for groups of tasks. This capability has many practical applications in real-time systems in general, and therefore it is also interesting for real-time operating systems. In this paper we present an implementation of thread group budgets inside a POSIX real-operating system, which can be used to implement the new Ada 2005 services. The architecture and details of the implementation are shown, as they may be useful to other implementers of this functionality defined in the new standard.

Early Experience with an Implementation of the POSIX.13 Minimal Real-Time Operating System for Embedded Applications

Abstract 1 Although the real-time POSIX operating system standards define system services for large systems, standard subsets have been defined that allow small implementations for embedded systems. In this paper we present the architecture and internal details of an implementation of the standardized POSIX Minimal Realtime System profile. This implementation constitutes a kernel for high-efficiency small embedded systems, under which applications with hard-real time requirements can be built.

Execution time monitoring and interrupt handlers: position statement

In hard real-time systems it is essential to monitor the execution times of all tasks and detect situations in which the estimated worst-case execution time (WCET) is exceeded. This fact has been recognized by standards related to real-time systems. The POSIX 1] and Ada 2005 standards define primitives to monitor execution times (“Execution-time clocks”) and to trigger actions when the execution time of a task reaches a specific value (“Execution-time timers”).

Integrating application-defined scheduling with the new dispatching policies for ada tasks

In previous papers we had presented an application program interface (API) that enabled applications to use application-defined scheduling algorithms for Ada tasks in a way compatible with the scheduling model defined in the real-Time Annex of the language. Each application scheduler was implemented with a special task. This paper presents a new implementation in which the application scheduler actions are executed as part of the kernel on which the run-time system is based, thus increasing the efficiency. This paper also presents modifications to the proposed API that align it with the evolution of the Ada Issues being considered in the Ada 200Y standardization. First, we use the new concept of deadline as an abstract notion of urgency, to order the tasks in the scheduling queue of the underlying kernel, freeing the application scheduler of the responsibility of keeping the desired ordering of tasks, and thus simplifying it and reducing its overhead. In second place, we also consider task synchronization through protected objects using the new Stack Resource Policy proposed for the EDF task dispatching policy in Ada 200Y, which can be used in a large variety of fixed and dynamic priority scheduling policies without explicit intervention of the application scheduler.