Jorge Real

Mode Change Protocols for Real-Time Systems: A Survey and a New Proposal

This paper contains both a survey of mode change protocols for single-processor, fixed-priority, preemptively scheduled real-time systems, and a proposal of several new protocols along with their corresponding schedulability analysis and configuration methods. First, a classification of the protocols found in the literature is given and a set of requirements is proposed for their evaluation. Then, the new protocols are introduced and discussed in the light of the stated requirements. A number of mode change protocols are based on delaying the initiation of the new mode by applying an offset to the initial release of tasks in the destination mode. We tackle the problem of how to obtain these offsets for the proposed protocols. The issue of consistently sharing resources during the mode change by means of a priority inheritance protocol is also dealt with.

TLSF: a new dynamic memory allocator for real-time systems

Dynamic storage allocation (DSA) algorithms play an important role in the modern software engineering paradigms and techniques (such as object oriented programming). Using DSA increases the flexibility and functionalities of applications. There exists a large number of references to this particular issue in the literature. However, the use of DSA has been considered a source of indeterminism in the real-time domain, due to the unconstrained response time of DSA algorithms and the fragmentation problem. Nowadays, real-time applications require more flexibility: the ability to adjust system configuration in response to workload changes and application reconfiguration. This aspect adds value to the definition and implementation of dynamic storage allocation algorithms. Considering these reasons, DSA algorithms with a bounded and acceptable timing behaviour must be developed to be used by real-time operating systems (RTOSs). In this paper a DSA algorithm called two-level segregated fit memory allocator (TLSF), developed specifically to be used by RTOS, is introduced. The TLSF algorithm provides explicit allocation and deallocation of memory blocks with a temporal cost /spl Theta/(1).

Offsets for scheduling mode changes

In multi-moded real-time systems there may exist a different set of tasks per mode. During its mission, the system may switch to a new operating mode, which will involve completing running old-mode tasks and starting new-mode tasks. This represents a transient, bounded overload, which may not be schedulable unless some new-mode tasks are delayed until the old-mode load has decreased. Although this idea has already been proposed elsewhere, a method for obtaining the shortest offsets that make a transition schedulable has not yet been devised. The management of shared resources during the transition represents an added problem to tackle. This paper presents a new mode change protocol and an algorithm to calculate the necessary offsets to schedule mode changes according to a set of requirements and in the presence of shared resources.

The Ceiling Protocol in Multi-moded Real-Time Systems

Fixed-priority scheduling has become a very important approach for implementing real-time systems. Two key aspects of the method are its support for resource management using priority inheritance protocols and its ability to model modes of operation. In this paper, we discuss the impact of mode changes on the immediate inheritance priority ceiling protocol. We show that the approach adopted in Ada can result in an increased blocking time for tasks that can unnecessarily jeopardise their schedulability. We propose several solutions to help solve this problem.

Incorporating operating modes to an ada real-time framework

Based on a previous proposal of a framework of real-time utilities in Ada 2005, this paper deals with the extension of that framework to include operating modes and mode changes.

Dynamic ceiling priorities and Ada 95

Ada 95 provides dynamic priorities for tasks but ceiling priorities for protected objects are statically assigned by means of a pragma. The semantic complexity as well as the potential inefficiency of any resulting implementation seem to have been the main objections to including dynamic ceilings in Ada 95. Nevertheless, in frequent scenarios such as multi-moded real-time systems, it is desirable for ceiling priorities to be dynamic, to accommodate the different priority assignments given to tasks in the different modes. This problem is usually worked around by applying the so-called ceiling of ceilings as a static ceiling for all modes, which may result in lower schedulability as extra blocking potentially occurs. In this paper we investigate on how to use a hypothetical Set_Ceiling dynamic operation, without incurring the risk of semantic ambiguities, and how a multi-moded system can benefit from its existence.

Implementing mode changes with shared resources in Ada

The ability to support mode changes is a desirable feature for many real-time systems in which the functionality provided may vary as the mission progresses. The addition and deletion of tasks, the change of task profiles, the coherent management of resources and, at the same time, the required timeliness guarantee is an exercise of coordination of activities in a real-time system. In this paper we suggest how to safely implement mode changes in Ada, taking resource management into account. We consider the hypothesis of Ada allowing dynamic ceilings for protected objects and then show how to plan the mode change so that during the transition, tasks do not use the resources inconsistently.

Using Ada 95 for Prototyping Real-Time Systems

An Ada 95-based model is proposed for prototyping of real-time systems. The model of the system is automatically derived from a specification made in the QUISAP language, which is part of a homonym environment for the rapid prototyping of real-time systems. The QUISAP language design principles are based on two main foundations: the language is based on the event-action model, described by Jahanian and Mok [1], and the translation process from the specification to an executable prototype in Ada is automatic. Moreover, there is a set of tools designed for the validation of the model under development. These tools include translators from QUISAP to formal models like Petri nets and RTL expressions and a simulation environment which allows the evolution of the prototype to be simulated and observed. In this paper, we consider two essential aspects of the prototype: the activity model, which follows a multi-tasking approach, and the data representation model, which is object-oriented. In both cases, the influence of Ada 95 is considered.

Running Ada on real-time linux

The Real-Time Linux operating system (RTLinux) is an attractive platform for real-time programming, since real-time tasks can be guaranteed bounded response times, whilst a number of applications, IDEs, GUIs, etc. are also available for the same platform. In RTLinux, real-time tasks are implemented (in C) as kernel modules. Special care must be taken when writing kernel modules: an error in a single task can make the whole system hang or crash, since they are executed in the kernel memory space. This is clearly an area where Ada can be of great help: Adas strong typing, consistency checking, robust syntax and readability, and the availability of high quality compilers, encourage the writing of correct software and allow to catch coding errors early in the implementation. In this paper, we show the state of development of a compilation system for Ada programs on RTLinux, based on the GNAT Ada compiler.

Combining Time-Triggered Plans with Priority Scheduled Task Sets

Time-triggered and concurrent priority-based scheduling are the two major approaches in use for real-time and embedded systems. Both approaches have their own advantages and drawbacks. On the one hand, priority-based systems facilitate separation of concerns between functional and timing requirements by relying on an underlying real-time operating system that takes all scheduling decisions at run time. But this is at the cost of indeterminism in the exact timing pattern of execution of activities, namely variable release jitter. On the other hand, time-triggered schedules are more intricate to design since all scheduling decisions must be taken beforehand in the design phase, but their advantage is determinism and more chances for minimisation of release jitter. In this paper we propose a software architecture that enables the combined and controlled execution of time-triggered plans and priority-scheduled tasks. We also describe the implementation of an Ada library supporting it. Our aim is to take advantage of the best of both approaches by providing jitter-controlled execution of time-triggered tasks e.g., control tasks, coexisting with a set of priority-scheduled tasks, with less demanding jitter requirements.