Scheduling Soft Real-Time Applications on NOWs

2002

Simultaneous multithreading (SMT) improves processor throughput by processing instructions from multiple threads each cycle. This is the first work to explore soft real-time scheduling on an SMT processor. Scheduling with SMT requires two decisions: (1) which threads to run simultaneously (the co-schedule), and (2) how to share processor resources among co-scheduled threads. We explore algorithms for both for soft-real time multimedia applications, focusing more on co-schedule selection. We examine previous multiprocessor co-scheduling algorithms, including partitioning and global scheduling. We propose new variations that consider resource sharing and try to utilize SMT more effectively by exploiting application symbiosis. We find (using simulation) that the best algorithm uses global scheduling, exploits symbiosis, prioritizes high utilization tasks, and uses dynamic resource sharing. This algorithm, however, imposes significant profiling overhead and does not provide admission control. We propose alternatives to overcome these limitations, but at the cost of schedulability.

Real-Time Systems, 2002

As desktop computer computational power continues to increases dramatically, it is becoming commonplace to run a combination of deadline-sensitive applications. Despite the proliferation of computational power, the detailed nature of these applications causes new problems for the system resource allocation mechanisms. First, these applications are designed to meet their deadlines as long as nearly all the system's resources are available to them; once the system approaches saturation, the collective applications will fail to meet their deadlines. To aggravate the situation, conventional best effort managers will allocate resources to the competing applications based on a static form of equitability rather than addressing the dynamic relative benefit provided by each application. Second, the applications differ from conventional real-time applications: though members of this new class of desktop applications are sensitive to deadlines, their constraints are non-critical. They are also typically designed to use the full spectrum of functions provided by a general purpose system call interface rather than the more limited interface of a real-time OS. This paper describes a flexible soft real-time system design that addresses these two problems. The CPU scheduling strategy accommodates the community of applications by taking application benefit into account during times of heavy load. Applications are written to use the full interface of a general purpose system call interface, yet the system is able to schedule them according to their deadlines and resource reservation and availability. This paper describes the theoretical foundation of the approach, additional application responsibilities, the design of a middleware system to implement the approach, and then it presents an extensive set of experimental studies that demonstrate the behavior of the approach. The Dynamic QoS Manager middleware (implemented on top of two different versions of Unix), is shown to be highly effective system for supporting contemporary soft real-time desktop applications.

1999

This paper 1 focuses on the problem of providing isolation and real-time execution in scheduling multi-thread applications on a single processor. The proposed scheduling algorithm can be applied in a wide range of different situations, such as in a multimedia real-time systems, where applications may require a guaranteed level of Quality of Service, or in a network link, where different flows of packets may require a certain level of service. This algorithm does not require the exact knowledge of the service times and interarrival times of the tasks: hence, it is especially suited for soft real-time and multimedia environments.

Proceedings Seventh IEEE Real-Time Technology and Applications Symposium, 2001

This paper analyzes the results of two case studies in applying the Rialto/NT scheduler to real Windows 2000 applications. The first study is of a soft modem-a modem whose signal processing work is performed on the host CPU, rather than on a dedicated signal processing chip. The second is of an audio player application. Both of these are frequently used real-time applications-ones running on systems that were not designed to support predictable real-time execution. To function correctly, both applications require that ongoing computations be performed in a timely manner. In both cases, we first measured an original version designed to run on Windows 2000, and then modified the application to take advantage of ongoing CPU Reservations provided by the Rialto/NT scheduler. We report on the benefits and problems observed when using reservations in these realworld scenarios. In both cases, we found that a real-time scheduler can provide the needed predictability for the application in the presence of competing applications, while also providing other benefits, such as minimizing the soft modem's impact on the scheduling predictability of other computations in the system. We also describe the methodologies we used to analyze the real-time behavior of the operating system and applications during these studies, including the use of instrumented kernels to produce execution traces.

2008 IEEE International Conference on Emerging Technologies and Factory Automation, 2008

A remarkable research activity has been carried out in the past few years to support real-time applications by means of appropriate scheduling solutions. For scarcely known or highly dynamic applications, feedback scheduling has emerged as an effective technique to tune the scheduling parameters, based on a run-time monitoring of the timing performance of the application. This technique requires a specialised API for the application and is therefore unfit for legacy applications, for which the source code is not accessible. In this paper, we present an alternative technique, called Legacy Feedback Scheduling (LFS), for feedback based adaptation of the scheduling parameters. LFS does not make any assumption on the programming model of the application and is applicable to legacy applications. Throughout the paper, we carry out a comparison between a well settled technique (called adaptive reservations), which leverages a particular structure for the application, and LFS. The conclusion is that the greater generality and flexibility of the LFS has to be paid in terms of timing performance. However, LFS successfully identifies the "average" scheduling parameters needed to sustain a given execution rate.

Proceedings. 2003 International Symposium on System-on-Chip (IEEE Cat. No.03EX748), 2003

Real-time systems are growing in complexity and realtime and soft real-time applications are becoming common in general-purpose computing environments. Thus, there is a growing need for scheduling solutions that simultaneously support processes with a variety of different timeliness constraints. Toward this goal we have developed the Resource Allocation/Dispatching (RAD) integrated scheduling model and the Rate-Based Earliest Deadline (RBED) integrated multi-class real-time scheduler based on this model. We present RAD and the RBED scheduler and formally prove the correctness of the operations that RBED employs. We then describe our implementation of RBED and present results demonstrating how RBED simultaneously and seamlessly supports hard real-time, soft real-time, and best-effort processes.

Proceedings of the 5th European conference on Computer systems - EuroSys '10, 2010

We present an approach for adaptive scheduling of soft realtime legacy applications (for which no timing information is exposed to the system). Our strategy is based on the combination of two techniques: 1) a real-time monitor that observes the sequence of events generated by the application to infer its activation period, 2) a feedback mechanism that adapts the scheduling parameters to ensure a timely execution of the application. By a thorough experimental evaluation of an implementation of our approach, we show its performance and its efficiency.

Parallel applications can benefit from the ability to explicitly control their thread scheduling policies in user-space. However, modern operating systems lack the interfaces necessary to make this type of "user-level" scheduling efficient. The key component missing is the ability for applications to gain direct access to cores and keep control of those cores even when making I/O operations that traditionally block in the kernel. A number of former systems provided limited support for these capabilities, but they have been abandoned in modern systems, where all efforts are now focused exclusively on kernel-based scheduling approaches similar to Linux’s. In many circles, the term "kernel" has actually become synonymous with Linux, and its Unix-based model of process and thread management is often assumed as the only possible choice. In this work, we explore the OS and runtime support required to resurrect user-level threading as a viable mechanism for exploiting parallelism on modern systems. The idea is that applications request cores, not threads, from the underlying system and employ user-level scheduling techniques to multiplex their own set of threads on top of those cores. So long as an application has control of a core, it will have uninterrupted, dedicated access to it. This gives developers more control over what runs where (and when), so they can design their algorithms to take full advantage of the parallelism available to them. They express their parallelism via core requests and their concurrency via user-level threads. We frame our work with a discussion of Akaros, a new, experimental operating system we developed, whose “Many-Core Process” (MCP) abstraction is built specifically with user-level scheduling in mind. The Akaros kernel provides low-level primitives for gaining direct access to cores, and a user-level library, called parlib, provides a framework for building custom threading packages that make use of those cores. From a parlib-based version of pthreads to a port of Lithe and the popular Go programming language, the combination of Akaros and parlib proves itself as a powerful medium to help bring user-level scheduling back from the dark ages.

1997

Multimedia applications are becoming ubiquitous. Unlike conventional interactive and batch applications, these applications often have real-time requirements. As multimedia applications are integrated with conventional non-real-time applications in the generalpurpose computing environment, the problem arises of how to support the resulting mix of activities. A key question is how does the operating system schedule processor cycles to

Proceedings Real-Time Technology and Applications Symposium, 1995

Distributed multimedia applications are typical of a new class of workstation applications that require realtime communication and computation services to be effective. Unfortunately, there remains a wide gap between the development of real-time computing technology in the research community and the deployment of real-time solutions in commercial systems. In this work we explore technology for allowing two operating systems, a general purpose operating system and a predictable real-time kernel, to co-exist on the same hardware. We discuss the problems of multiplexing shared devices and partitioning shared data structures to accommodate two operating systems, and present a CPU executive that allows the IBM Microkernel (a derivative of the Mach microkernel) with an OSF/1 server to co-exist with a simple real-time kernel we have built. We also extend the traditional theory of scheduling periodic tasks on a uniprocessor to accommodate the case where a real-time kernel is allocated only a fraction of the total CPU capacity.