An Architecture for Declarative Real-Time Scheduling on Linux

2005

Developing real-time applications using the POSIX standard API guarantees applications portability at the source code level. However, POSIX standard includes just fixed-priority scheduling and it is not always suited to fulfill the requirements of every real-time system. Recently, an API to use applicationdefined scheduling algorithms in a way compatible with POSIX was proposed. This model allows the implementation of different scheduling policies in a portable way. Nevertheless, this API is more intended for kernel programmers than for real-time application developers. In this paper, a framework for developing and using a library of POSIX compatible application-defined schedulers is proposed. An API based in this framework is presented and some functionalities have been added to it, including fault-tolerance capabilities. With the proposed API, a library of application-defined schedulers can be used to develop real-time applications in a consistent and efficient way. The proposal has been implemented in RTLinux along with a library including many scheduling policies and results of the evaluation of the implementation are presented.

Real-Time Systems, 2013

In this work, we provide an experimental comparison between Global-EDF and Partitioned-EDF, considering the run-time overhead of a real-time operating system (RTOS). Recent works have confirmed that OS implementation aspects, such as the choice of scheduling data structures and interrupt handling mechanisms, impact real-time schedulability as much as scheduling theoretic aspects. However, these studies used real-time patches applied into a general-purpose OS. By measuring the run-time overhead of an RTOS designed from scratch, we show how close the schedulability ratio of task sets is to the theoretical hard real-time schedulability tests. Moreover, we show how a well-designed object-oriented RTOS allows code reuse of scheduling components (e.g., thread, scheduling criteria, and schedulers) and easy real-time scheduling extensions. We compare our RTOS to a real-time patch for Linux in terms of the task set schedulability ratio of several generated task sets. In some cases, Global-EDF considering the overhead of the RTOS is superior to Partitioned-EDF considering the overhead of the patched Linux, which clearly shows how different OSs impact hard real-time schedulers.

Computer Systems Science and Engineering

The Linux operating system has been employed to execute numerous real-time applications. However, it is limited to support soft real-time systems by two scheduling policies: First-In-First-Out and Round Robin. For real-time systems with critical constraints, the soft real-time support and these scheduling policies are still insufficient. In this work, the Earliest Deadline First scheduling policy, which has been shown in theory to be an optimal one in uniprocessor systems, is introduced as an extension of the Linux kernel. This policy is implemented into the real-time class, without the necessity of defining an additional class. The Linux kernel affords capabilities of a hard real-time operating system by an RT-Preempt patch, enabling the use of Linux to implement hard realtime systems. The integration is compliant with the POSIX real-time and thread standards, ensuring applications portability, employing the GLIBC library. In order to validate the proposed implementation, a set of experiments is conducted, showing that a real-time system that cannot be feasibly scheduled using existing policies, attains feasibility when it is scheduled using the integrated Earliest Deadline First policy (RTOS). The former aims to support the time-sharing applications and therefore allocates equitably the available resources to the system tasks. Instead, an RTOS gives support to real-time applications and incorporates policies that enable the compliance with the timing constraints of the tasks. In an RTOS, the tasks are commonly implemented as threads, which are tied to processes. An RTOS contains also a kernel that provides basic computer functions and takes control over the execution of the threads and the processes. It responds to the system calls, offers scheduling and timing services, as well as manages external interrupts. A system call allows a thread or a process to invoke the functions provided by the kernel.

2010

Hierarchical scheduling frameworks (HSFs) have been devised to support the integration of independently developed and analyzed subsystems. This paper presents an efficient, modular and extendible design for enhancing a real-time operating system with periodic tasks, two-level fixed-priority HSF based on the idling periodic and deferrable servers, and virtual timers. It relies on Relative Timed Event Queues (RELTEQ), a timed event management component targeted at embedded operating systems, which supports long event interarrival time, long lifetime of the event queue, no drift and low overhead. It minimizes the overhead in terms of processor and memory usage, limits the interference of inactive servers on system level, and minimizes the necessary modifications of the underlying operating system. The proposed design was implemented and evaluated within the µC/OS-II real-time operating system used by our industrial and academic partners.

We present an implementation of Real-Time CORBA's distributable threads (DTs) as a first-class, end-to-end realtime programming and scheduling abstraction in the Linux kernel. We use Ingo Molnar's PREEMPT RT kernel patch, which enables nearly complete kernel pre-emption, and add local (real-time) scheduling support to the Linux kernel, atop which we build DT scheduling support. We implement DTs using Linux's threading capabilities. Our implementation of a suite of independent and collaborative DT schedulers confirm the effectiveness of our implementation.

Lecture Notes in Computer Science, 2005

Real-time scheduling is the kernel mechanism having the most impact on RTOS performance. After describing existing algorithms and methodologies for embedded realtime applications, we present their limitations in handling dynamic environments, and discuss new research trends for overcoming them in next generation operating systems. 20.1 Landscape This summary is intended to give a brief overview of the status of scheduling methods, in particular with respect to flexible scheduling. It does not aim to be complete or provide in-depth literature survey. Rather, directions and issues, together with seminal algorithms are presented. Most of the presented algorithms are research prototypes.

2002

A Ana, por su eterna (im)paciencia, y en memoria de nuestro amigo Lucas I have never begun a novel with more misgiving. If I call it a novel it is only because I don't know what else to call it. I have little story to tell and I end neither with a death nor a marriage.

2005

The application-defined scheduling model allows the implementation and use of different scheduling policies in a way compatible with the scheduling model defined in POSIX 1 . The new scheduling policies are integrated into a real-time operating system without modifying its internal structure. In this paper, we discuss the application-defined scheduling model and propose some extensions to it. Particularly, we propose an extension to provide flexibility in defining application-defined synchronization mechanisms, in order to schedule efficiently aperiodic tasks using shared resources. Furthermore, an extension to the application-defined scheduling API is proposed to simplify the use of application-defined schedulers and to integrate new functionalities to the real-time applications developed using the proposed model. The extensions shown in this paper have been implemented in RTLinux and results of the evaluation of the implementation are presented.

arXiv (Cornell University), 2023

There is increasing interest in using Linux in the real-time domain due to the emergence of cloud and edge computing, the need to decrease costs, and the growing number of complex functional and non-functional requirements of realtime applications. Linux presents a valuable opportunity as it has rich hardware support, an open-source development model, a well-established programming environment, and avoids vendor lock-in. Although Linux was initially developed as a generalpurpose operating system, some real-time capabilities have been added to the kernel over many years to increase its predictability and reduce its scheduling latency. Unfortunately, Linux currently has no support for time-triggered (TT) scheduling, which is widely used in the safety-critical domain for its determinism, low run-time scheduling latency, and strong isolation properties. We present an enhancement of the Linux scheduler as a new low-overhead TT scheduling class to support offline table-driven scheduling of tasks on multicore Linux nodes. Inspired by the Slot shifting algorithm, we complement the new scheduling class with a low overhead slot shifting manager running on a non-timetriggered core to provide guaranteed execution time to real-time aperiodic tasks by using the slack of the time-triggered tasks and avoiding high-overhead table regeneration for adding new periodic tasks. Furthermore, we evaluate our implementation on server-grade hardware with Intel Xeon Scalable Processor.

IFAC Proceedings Volumes, 1991

YARTOS is an experimental real-time operating system kernel that provides guaranteed response times to tasks. It is currently used as a vehicle for research in the design, analysis, and implementation of real-time applications. It is a micro-kernel with an underlying formal model based on sporadic tasks with response time requirements and shared software resources. It is distinguished by the programming model it supports and by its use of a novel processor scheduling and resource allocation policy. The implementation of YARTOS is outlined and two real-time applications that run under YARTOS are described.