Aaron Block

A Flexible Real-Time Locking Protocol for Multiprocessors

Real-time scheduling algorithms for multiprocessor systems have been the subject of considerable recent interest. For such an algorithm to be truly useful in practice, support for semaphore-based locking must be provided. However, for many global scheduling algorithms, no such mechanisms have been proposed. Furthermore, in the partitioned case, most prior semaphore schemes are either inefficient or restrict critical sections considerably. In this paper, a new flexible multiprocessor locking scheme is presented that can be applied under both partitioning and global scheduling. This scheme allows unrestricted critical-section nesting, but has been designed to deal with the common case of short non-nested accesses efficiently.

LITMUS^RT : A Testbed for Empirically Comparing Real-Time Multiprocessor Schedulers

We present a real-time, Linux-based testbed called LITMUS, which we have developed for empirically evaluating multiprocessor real-time scheduling algorithms. We also present the results from such an evaluation, in which partitioned earliest-deadline-first (EDF) scheduling, preemptive and nonpreemptive global EDF scheduling, and two variants of the global PD2 Pfair algorithm were considered. The tested algorithms were compared based on both raw performance and schedulability (with real overheads considered) assuming either hard- or soft-real-time constraints. To our knowledge, this paper is the first attempt by anyone to compare partitioned and global real-time scheduling approaches using empirical data

Real-Time Synchronization on Multiprocessors: To Block or Not to Block, to Suspend or Spin?

In the domain of multiprocessor real-time systems, there has been a wealth of recent work on scheduling, but relatively little work on the equally-important topic of synchronization. When synchronizing accesses to shared resources, four basic options exist: lock-free execution, wait-free execution, spin- based locking, and suspension-based locking. To our knowledge, no empirical multiprocessor-based evaluation of these basic techniques that focuses on real-time systems has ever been conducted before. In this paper, we present such an evaluation and report on our efforts to incorporate synchronization support in the testbed used in this effort.

An Adaptive Framework for Multiprocessor Real-Time System

In this paper, we develop an adaptive scheduling framework for changing the processor shares of tasks - a process called reweighting - on real-time multiprocessor platforms. Our particular focus is adaptive frameworks that are deployed in environments in which tasks may frequently require significant share changes. Prior work on enabling real-time adaptivity on multiprocessors has focused exclusively on scheduling algorithms that can enact needed adaptations. The algorithm proposed in this paper uses both feedback and optimization techniques to determine at runtime which adaptations are needed.

Quick-release fair scheduling

In prior work on multiprocessor fairness, efficient techniques with provable properties for reallocating spare processing capacity have been elusive. In this paper, we address this shortcoming by proposing a new notion of multiprocessor fairness, called quick-release fair (QRfair) scheduling. Under QRfair scheduling, each task is specified by giving both a minimum and a maximum weight (i.e., processor share). The goal is to schedule each task (as the spare capacity changes) at a rate that is (i) at least that implied by its minimum weight and (ii) at most that implied by its maximum weight. We present a quick-release variant of the PD/sup 2/ Pfair scheduling algorithm called PD/sup Q/ and prove that the allocations of PD/sup Q/ always satisfy (i) and (ii). Also, we present results from simulation experiments that show the efficacy of PD/sup Q/.

Task reweighting under global scheduling on multiprocessors

Abstract We consider schemes for enacting task share changes—a process called reweighting—on real-time multiprocessor platforms. Our particular focus is reweighting schemes that are deployed in environments in which tasks may frequently request significant share changes. Prior work has shown that fair scheduling algorithms are capable of reweighting tasks with minimal allocation error and that partitioning-based scheduling algorithms can reweight tasks with better average-case performance, but greater error. However, preemption and migration overheads can be high in fair schemes. In this paper, we consider the question of whether non-fair, earliest-deadline-first (

Accuracy versus migration overhead in real-time multiprocessor reweighting algorithms

\mathsf{EDF}

Adaptive multiprocessor real-time systems

) global scheduling techniques can improve the accuracy of reweighting relative to partitioning-based schemes and provide improved average-case performance relative to fair-scheduled systems. Our conclusion is that, for soft real-time systems, global

Accuracy versus Migration Overhead in Multiprocessor Reweighting Algorithms

\mathsf{EDF}

Task reweighting on multiprocessors: efficiency versus accuracy

schemes provide a good mix of accuracy and average-case performance.