Prior work has shown that the global earliest-deadline-first (GEDF) scheduling algorithm ensures bounded deadline tardiness on multiprocessors with no utilization loss; therefore, GEDF may be a good candidate scheduling algorithm for soft real-time workloads. However, such workloads are often implemented assuming an average-case provisioning, and in prior tardiness-bound derivations for GEDF, worst-case execution costs are assumed. As worst-case costs can be orders of magnitude higher than average-case costs, using a worstcase provisioning may result in significant wasted processing capacity. In this paper, prior tardiness-bound derivations for GEDF are generalized so that execution times are probabilistic, and a bound on expected (mean) tardiness is derived. It is shown that, as long as the total expected utilization is strictly less than the number of available processors, the expected tardiness of every task is bounded under GEDF. The result also implies that any quantile of the tardiness distribution is also bounded. 1

Multicore architectures, which have multiple processing units on a single chip, have been adopted by most chip manufacturers. Most such chips contain on-chip caches that areshared by some or all of the cores on the chip. To effectively use the available processing resources on such plat-forms, scheduling methods must be aware of these caches. In this paper, we explore various heuristics that attempt to im-prove cache performance when scheduling real-time workloads. Such heuristics are applicable when multiple multi-threaded applications exist with large working sets. In addition, we present a case study that shows how our best-performing heuristics can improve the end-user performance of video encoding applications.

The importance of accounting for interrupts in multiprocessor real-time schedulability analsysis is discussed. Three interrupt accounting methods, two of which are newly described here, are analyzed and compared.

Multicore architectures, which have multiple processing units on a single chip, have been adopted by most chip manufacturers. Most such chips contain on-chip caches that are shared by some or all of the cores on the chip. Prior work has presented methods for improving the performance of such caches when scheduling soft real-time workloads. Given these methods, two additional research issues arise: (1) how to automatically profile the cache behavior of real-time tasks within the scheduler; and (2) how to implement scheduling methods efficiently, so that scheduling overheads do not offset any cache-related performance gains. This paper addresses these two issues in an implementation of a cacheaware soft real-time scheduler within Linux, and shows that the use of this scheduler can result in performance improvements that directly result from a decrease in shared cache miss rates.

Current hard real-time scheduling and analysis techniques are unable to efficiently utilize the computational bandwidth provided by multicore platforms. This is due to the large gap between worst-case execution time predictions used in schedulability analysis and actual execution times seen in practice. In this paper, we view this gap as “slack ” that can be accounted for during schedulability analysis and reclaimed for less critical work. We use this technique to develop an architecture for scheduling mixed-criticality real-time workloads on multiprocessor platforms. Our architecture provides temporal isolation among tasks of different criticalities while allowing slack to be redistributed across criticality levels. 1.

Ongoing research is discussed on the development of operating-system support for enabling mixed-criticality workloads to be supported on multicore platforms. This work is motivated by avionics systems in which such workloads occur. In the mixed-criticality workload model that is considered, task execution costs may be determined using more-stringent methods at high criticality levels, and less-stringent methods at low criticality levels. The main focus of this research effort is devising mechanisms for providing “temporal isolation” across criticality levels: lower levels should not adversely “interfere” with higher levels.

The importance of accounting for interrupts in multiprocessor real-time schedulability analsysis is discussed and three interrupt accounting methods, namely quantum-centric, task-centric, and processor-centric accounting, are analyzed and contrasted. Additionally, two special cases, dedicated interrupt handling (i.e., all interrupts are processed by one processor) and timer multiplexing (i.e., all jobs are released by a single hardware timer), are considered and corresponding analysis is derived. All discussed approaches are evaluated in terms of schedulability based on interrupt costs previously measured on a Sun Niagara multicore processor. The results show that there is no single “best ” accounting technique that is always preferable, but rather that the relative performance of each approach varies significantly based on task set composition, i.e., the number of tasks and the maximum utilization.

While most prior work on multiprocessor real-time scheduling focuses on independent tasks, dependencies due to non-preemptive sections, suspensions, and pipelinebased precedence constraints are common in practice. In this paper, such complexities are considered in the context of the global earliest-deadline-first scheduling algorithm. It is shown that any periodic task system with such dependencies can be transformed into one with only suspensions in a way that preserves maximum per-task response times. This result enables analysis directed at systems with suspensions to be applied if non-preemptive sections and/or pipelines are present as well. 1

The evolution of multicore platforms has led to much recent work on multiprocessor scheduling techniques for soft realtime workloads. However, end users routinely run such workloads atop general-purpose operating systems with seemingly good results, albeit typically on over-provisioned systems. This raises the question: when, if ever, is the use of an analysisbased scheduler actually warranted? In this paper, this question is addressed via a video-decoding case study in which a scheme based on the global earliest-deadline-first (G-EDF) algorithm was compared against Linux’s CFS scheduler. In this study, the G-EDF-based scheme proved to be superior under heavy workloads in terms of several timing metrics, including jitter and deadline tardiness. Prior to discussing these results, an explanation of how existing G-EDF-related scheduling theory was applied to provision the studied system is given and various “mismatches ” between theoretical assumptions and practice that were faced are discussed. 1

We utilize a multiprocessor server-based approach to schedule a general class of soft real-time systems with stochastic execution demands, when bounded average-case tardiness is sufficient for schedulability. A key feature of the task model considered here is that the stochastic execution-time demands can have arbitrary amounts of dependence within pre-specified time intervals of bounded length. This is an important practical step forward from requiring complete independence of execution times between successive jobs of the same task. Our main result does not require the scheduler to know the execution time of each job in advance, and requires only average-case utilization to be bounded by the number of processors. This constraint is mild compared to constraints on worst-case utilization because in multiprocessor systems, worst-case execution times may be orders of magnitude higher than average-case execution times. 1